gsd-pi 2.71.0-dev.e17e0ce → 2.72.0-dev.593fa74

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

@@ -6,17 +6,12 @@
  * records in the DB. This module inserts milestone-level validation gates
  * that correspond to the validation checks performed.
  *
- * Gate IDs for milestone validation:
- *   MV01 — Success criteria checklist
- *   MV02 — Slice delivery audit
- *   MV03 — Cross-slice integration
- *   MV04 — Requirement coverage
- *
- * These use the existing quality_gates table with scope "milestone".
+ * Gate IDs for milestone validation (MV01–MV04) are sourced from the
+ * gate registry so the definitions stay in lockstep with prompt builders,
+ * dispatch rules, and state derivation. See gate-registry.ts.
  */
 import { _getAdapter } from "./gsd-db.js";
-/** Milestone validation gate IDs. */
-const MILESTONE_GATE_IDS = ["MV01", "MV02", "MV03", "MV04"];
+import { getGatesForTurn } from "./gate-registry.js";
 /**
  * Insert milestone-level quality_gates records for a validation run.
  *
@@ -24,21 +19,25 @@ const MILESTONE_GATE_IDS = ["MV01", "MV02", "MV03", "MV04"];
  * from the overall milestone validation verdict. Individual gate-level
  * verdicts are not available (the handler receives a single verdict),
  * so all gates share the overall verdict.
+ *
+ * Gate IDs come from the registry — adding/removing an MV-scoped gate
+ * in gate-registry.ts automatically flows through here.
  */
 export function insertMilestoneValidationGates(milestoneId, sliceId, verdict, evaluatedAt) {
     const db = _getAdapter();
     if (!db)
         return;
     const gateVerdict = verdict === "pass" ? "pass" : "flag";
-    for (const gateId of MILESTONE_GATE_IDS) {
+    const milestoneGates = getGatesForTurn("validate-milestone");
+    for (const def of milestoneGates) {
         db.prepare(`INSERT OR REPLACE INTO quality_gates
        (milestone_id, slice_id, gate_id, scope, task_id, status, verdict, rationale, findings, evaluated_at)
        VALUES (:mid, :sid, :gid, 'milestone', '', 'complete', :verdict, :rationale, '', :evaluated_at)`).run({
             ":mid": milestoneId,
             ":sid": sliceId,
-            ":gid": gateId,
+            ":gid": def.id,
             ":verdict": gateVerdict,
-            ":rationale": `Milestone validation verdict: ${verdict}`,
+            ":rationale": `${def.promptSection} — milestone validation verdict: ${verdict}`,
             ":evaluated_at": evaluatedAt,
         });
     }

package/dist/resources/extensions/gsd/notification-overlay.js

@@ -2,7 +2,7 @@
 // Scrollable panel showing all persisted notifications with severity filtering.
 // Toggled with Ctrl+Alt+N (⌃⌥N on macOS), Ctrl+Shift+N fallback, or /gsd notifications.
 import { truncateToWidth, visibleWidth, matchesKey, Key } from "@gsd/pi-tui";
-import { readNotifications, markAllRead, clearNotifications, } from "./notification-store.js";
+import { readNotifications, markAllRead, clearNotifications, onNotificationStoreChange, } from "./notification-store.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
 import { padRight, joinColumns } from "../shared/mod.js";
 const FILTER_CYCLE = ["all", "error", "warning", "info"];
@@ -74,6 +74,7 @@ export class GSDNotificationOverlay {
     refreshTimer;
     disposed = false;
     resizeHandler = null;
+    unsubscribeStore = null;
     constructor(tui, theme, onClose) {
         this.tui = tui;
         this.theme = theme;
@@ -90,20 +91,18 @@ export class GSDNotificationOverlay {
             this.tui.requestRender();
         };
         process.stdout.on("resize", this.resizeHandler);
-        // Refresh every 3s for new notifications
+        // Subscribe to store mutations for immediate updates
+        this.unsubscribeStore = onNotificationStoreChange(() => {
+            if (this.disposed)
+                return;
+            this._refreshFromDisk();
+        });
+        // 30s safety-net for cross-process edits (web subprocess, parallel workers)
         this.refreshTimer = setInterval(() => {
             if (this.disposed)
                 return;
-            const fresh = readNotifications();
-            const signature = notificationSignature(fresh);
-            if (signature !== this.entriesSignature) {
-                markAllRead();
-                this.entries = readNotifications();
-                this.entriesSignature = notificationSignature(this.entries);
-                this.invalidate();
-                this.tui.requestRender();
-            }
-        }, 3000);
+            this._refreshFromDisk();
+        }, 30_000);
     }
     get filter() {
         return FILTER_CYCLE[this.filterIndex];
@@ -188,11 +187,26 @@ export class GSDNotificationOverlay {
     dispose() {
         this.disposed = true;
         clearInterval(this.refreshTimer);
+        if (this.unsubscribeStore) {
+            this.unsubscribeStore();
+            this.unsubscribeStore = null;
+        }
         if (this.resizeHandler) {
             process.stdout.removeListener("resize", this.resizeHandler);
             this.resizeHandler = null;
         }
     }
+    _refreshFromDisk() {
+        const fresh = readNotifications();
+        const signature = notificationSignature(fresh);
+        if (signature !== this.entriesSignature) {
+            markAllRead();
+            this.entries = readNotifications();
+            this.entriesSignature = notificationSignature(this.entries);
+            this.invalidate();
+            this.tui.requestRender();
+        }
+    }
     wrapInBox(inner, width) {
         const th = this.theme;
         const border = (s) => th.fg("borderAccent", s);

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

@@ -301,10 +301,11 @@ function _withLock(basePath, fn) {
             break;
         }
     }
-    // Only run the mutation if we actually own the lock
-    const ownsLock = fd !== null;
+    // Best-effort: mutation runs regardless of lock status (idempotent overwrites).
+    // createdLock gates cleanup only — never skip fn() on lock failure.
+    const createdLock = fd !== null;
     try {
-        if (ownsLock && fd !== null) {
+        if (createdLock && fd !== null) {
             // Write our PID timestamp into the lock for stale detection
             writeFileSync(lockPath, String(Date.now()), "utf-8");
             closeSync(fd);
@@ -313,7 +314,7 @@ function _withLock(basePath, fn) {
     }
     finally {
         // Only delete the lock if we created it — never remove another process's lock
-        if (ownsLock) {
+        if (createdLock) {
             try {
                 unlinkSync(lockPath);
             }

package/dist/resources/extensions/gsd/prompt-validation.js

@@ -0,0 +1,126 @@
+/**
+ * GSD Prompt Validation — Validates enhanced context and turn output
+ * artifacts before writing.
+ *
+ * Implements R109 validation requirement: CONTEXT.md must have required
+ * sections before being written to disk. Additionally, per-turn validators
+ * check that artifacts produced by gate-owning turns contain the gate
+ * sections declared in gate-registry.ts, so a malformed summary/validation
+ * markdown file cannot silently drop a quality gate.
+ */
+import { getGatesForTurn } from "./gate-registry.js";
+/**
+ * Validate that enhanced context content has all required sections.
+ *
+ * Required sections per R109:
+ * - Scope section (## Scope, ## Milestone Scope, or ## Why This Milestone)
+ * - Architectural Decisions section (## Architectural Decisions)
+ * - Acceptance Criteria section (## Acceptance Criteria or ## Final Integrated Acceptance)
+ *
+ * Additionally validates that the Architectural Decisions section contains
+ * at least one decision entry (### heading or **Decision marker).
+ *
+ * @param content - The enhanced context markdown content
+ * @returns ValidationResult with valid flag and list of missing sections
+ */
+export function validateEnhancedContext(content) {
+    const missing = [];
+    // Required section 1: Scope (multiple acceptable header variants)
+    const hasScopeSection = /^## Scope\b/m.test(content) ||
+        /^## Milestone Scope\b/m.test(content) ||
+        /^## Why This Milestone\b/m.test(content);
+    if (!hasScopeSection) {
+        missing.push("Milestone Scope or Why This Milestone");
+    }
+    // Required section 2: Architectural Decisions
+    const hasArchitecturalDecisions = /^## Architectural Decisions\b/m.test(content);
+    if (!hasArchitecturalDecisions) {
+        missing.push("Architectural Decisions");
+    }
+    // Required section 3: Acceptance Criteria (multiple acceptable header variants)
+    const hasAcceptanceCriteria = /^## Acceptance Criteria\b/m.test(content) ||
+        /^## Final Integrated Acceptance\b/m.test(content);
+    if (!hasAcceptanceCriteria) {
+        missing.push("Acceptance Criteria");
+    }
+    // Additional validation: Architectural Decisions must have at least one entry
+    if (hasArchitecturalDecisions) {
+        // Extract the section content between ## Architectural Decisions and the next ## heading.
+        // Uses indexOf-based extraction instead of regex with \z (which is invalid in JavaScript
+        // regex — it's PCRE/Ruby syntax and JS treats it as literal 'z').
+        const sectionStart = content.indexOf("## Architectural Decisions");
+        if (sectionStart === -1) {
+            missing.push("Architectural Decisions");
+        }
+        else {
+            const afterHeading = content.slice(sectionStart + "## Architectural Decisions".length);
+            const nextSection = afterHeading.search(/^## /m);
+            const sectionContent = nextSection === -1 ? afterHeading : afterHeading.slice(0, nextSection);
+            // Check for actual decision entries:
+            // - ### heading (subsection per decision)
+            // - **Decision marker (inline decision format)
+            const hasDecisionEntry = /^### /m.test(sectionContent) || /^\*\*Decision/m.test(sectionContent);
+            if (!hasDecisionEntry) {
+                missing.push("At least one architectural decision entry");
+            }
+        }
+    }
+    return {
+        valid: missing.length === 0,
+        missing,
+    };
+}
+// ─── Per-Turn Gate Section Validators ─────────────────────────────────────
+//
+// Each validator checks that the artifact written by a turn contains a
+// heading for every gate owned by that turn. The registry is the source
+// of truth for which sections must exist; adding a new gate automatically
+// flows through via `getGatesForTurn(turn)`.
+/**
+ * Escape a string so it can be embedded safely inside a regular expression.
+ */
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Validate that an artifact contains an `## H2` heading for every gate the
+ * named turn owns. Returns the list of missing gate section headers.
+ *
+ * Soft rule: a section counts as "present" if it is declared (H2 heading
+ * exists) — empty-body sections are allowed and handled by the tool
+ * handler, which will record such gates as `omitted`.
+ */
+export function validateGateSections(content, turn) {
+    const missing = [];
+    for (const def of getGatesForTurn(turn)) {
+        const pattern = new RegExp(`^##\\s+${escapeRegExp(def.promptSection)}\\b`, "m");
+        if (!pattern.test(content)) {
+            missing.push(`${def.id} (## ${def.promptSection})`);
+        }
+    }
+    return { valid: missing.length === 0, missing };
+}
+/**
+ * Validate a SUMMARY.md produced by the complete-slice turn. Requires
+ * an H2 heading for every gate owned by complete-slice (e.g. Q8 →
+ * "## Operational Readiness"). Intended for use in the tool handler's
+ * pre-write checks or in the post-unit validation sweep.
+ */
+export function validateSliceSummaryOutput(content) {
+    return validateGateSections(content, "complete-slice");
+}
+/**
+ * Validate a task SUMMARY.md produced by the execute-task turn. Only
+ * flags gates that are still pending for the task; skips the check
+ * when no rows are seeded (simple task).
+ */
+export function validateTaskSummaryOutput(content) {
+    return validateGateSections(content, "execute-task");
+}
+/**
+ * Validate a VALIDATION.md produced by the validate-milestone turn.
+ * Requires an H2 heading for every MV gate declared in the registry.
+ */
+export function validateMilestoneValidationOutput(content) {
+    return validateGateSections(content, "validate-milestone");
+}

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

@@ -16,6 +16,8 @@ All relevant context has been preloaded below — the slice plan, all task summa
 
 {{inlinedContext}}
 
+{{gatesToClose}}
+
 **Match effort to complexity.** A simple slice with 1-2 tasks needs a brief summary and lightweight verification. A complex slice with 5 tasks across multiple subsystems needs thorough verification and a detailed summary. Scale the work below accordingly.
 
 Then:
@@ -23,7 +25,7 @@ Then:
 2. {{skillActivation}}
 3. Run all slice-level verification checks defined in the slice plan. All must pass before marking the slice done. If any fail, fix them first. Task artifacts use a **flat file layout** directly inside `tasks/` (for example `T01-SUMMARY.md`, `T02-SUMMARY.md`) rather than per-task subdirectories. If you need to count or re-read task summaries during verification, use `find .gsd/milestones/{{milestoneId}}/slices/{{sliceId}}/tasks -name "*-SUMMARY.md"` or `ls .gsd/milestones/{{milestoneId}}/slices/{{sliceId}}/tasks/*-SUMMARY.md`. Never use `tasks/*/SUMMARY.md` — that glob expects subdirectories that do not exist.
 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.
+5. Address every gate listed in the **Gates to Close** section above — each gate maps to a specific slice-summary section the handler inspects (for example, Q8 maps to **Operational Readiness**: health signal, failure signal, recovery procedure, and monitoring gaps). Leaving a section empty records the gate as `omitted`.
 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. 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.

package/dist/resources/extensions/gsd/prompts/execute-task.md

@@ -22,6 +22,8 @@ A researcher explored the codebase and a planner decomposed the work — you are
 
 {{slicePlanExcerpt}}
 
+{{gatesToClose}}
+
 ## Backing Source Artifacts
 - Slice plan: `{{planPath}}`
 - Task plan source: `{{taskPlanPath}}`

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

@@ -18,6 +18,8 @@ All relevant context has been preloaded below — the roadmap, all slice summari
 
 {{inlinedContext}}
 
+{{gatesToEvaluate}}
+
 ## Execution Protocol
 
 ### Step 1 — Dispatch Parallel Reviewers

package/dist/resources/extensions/gsd/shortcut-defs.js

@@ -5,16 +5,19 @@ export const GSD_SHORTCUTS = {
         key: "g",
         action: "Open GSD dashboard",
         command: "/gsd status",
+        hasFallback: true,
     },
     notifications: {
         key: "n",
         action: "Open notification history",
         command: "/gsd notifications",
+        hasFallback: true,
     },
     parallel: {
         key: "p",
         action: "Open parallel worker monitor",
         command: "/gsd parallel watch",
+        hasFallback: false, // Ctrl+Shift+P conflicts with cycleModelBackward
     },
 };
 function combo(prefix, key) {
@@ -27,7 +30,10 @@ export function fallbackShortcutCombo(id) {
     return combo("Ctrl+Shift+", GSD_SHORTCUTS[id].key);
 }
 export function shortcutPair(id, formatter = (combo) => combo) {
-    return `${formatter(primaryShortcutCombo(id))} / ${formatter(fallbackShortcutCombo(id))}`;
+    const primary = formatter(primaryShortcutCombo(id));
+    if (!GSD_SHORTCUTS[id].hasFallback)
+        return primary;
+    return `${primary} / ${formatter(fallbackShortcutCombo(id))}`;
 }
 export function formattedShortcutPair(id) {
     return shortcutPair(id, formatShortcut);

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

@@ -13,7 +13,7 @@ import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { debugCount, debugTime } from './debug-logger.js';
 import { logWarning, logError } from './workflow-logger.js';
 import { extractVerdict } from './verdict-parser.js';
-import { isDbAvailable, wasDbOpenAttempted, getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, insertSlice, insertTask, updateTaskStatus, getPendingSliceGateCount, } from './gsd-db.js';
+import { isDbAvailable, wasDbOpenAttempted, getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, insertSlice, insertTask, updateTaskStatus, getPendingGateCountForTurn, } 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
@@ -724,7 +724,14 @@ export async function deriveStateFromDb(basePath) {
             };
         }
     }
-    const pendingGateCount = getPendingSliceGateCount(activeMilestone.id, activeSlice.id);
+    // ── Quality gate evaluation check ──────────────────────────────────
+    // Pause before execution only when gates owned by the `gate-evaluate`
+    // turn (Q3/Q4) are still pending. Q8 is also `scope:"slice"` but is
+    // owned by `complete-slice`, so it must NOT block the evaluating-gates
+    // phase — otherwise auto-loop stalls forever waiting for a gate that
+    // this turn never evaluates. See gate-registry.ts for the ownership map.
+    // Slices with zero gate rows (pre-feature or simple) skip straight through.
+    const pendingGateCount = getPendingGateCountForTurn(activeMilestone.id, activeSlice.id, "gate-evaluate");
     if (pendingGateCount > 0) {
         return {
             activeMilestone, activeSlice, activeTask: null,

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

@@ -9,7 +9,8 @@
 import { join } from "node:path";
 import { mkdirSync } from "node:fs";
 import { isClosedStatus } from "../status-guards.js";
-import { transaction, insertMilestone, insertSlice, getSlice, getSliceTasks, getMilestone, updateSliceStatus, setSliceSummaryMd, } from "../gsd-db.js";
+import { transaction, insertMilestone, insertSlice, getSlice, getSliceTasks, getMilestone, updateSliceStatus, setSliceSummaryMd, saveGateResult, getPendingGatesForTurn, } from "../gsd-db.js";
+import { getGatesForTurn } from "../gate-registry.js";
 import { resolveSlicePath, clearPathCache } from "../paths.js";
 import { checkOwnership, sliceUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
@@ -19,6 +20,19 @@ import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning, logError } from "../workflow-logger.js";
+/**
+ * Map a complete-slice-owned gate id to the CompleteSliceParams field
+ * whose presence drives `pass` vs. `omitted`. Keep this in lockstep with
+ * the gates declared in gate-registry.ts under ownerTurn "complete-slice".
+ */
+function sliceGateFieldForId(id, params) {
+    switch (id) {
+        case "Q8":
+            return params.operationalReadiness;
+        default:
+            return undefined;
+    }
+}
 /**
  * Render slice summary markdown matching the template format.
  * YAML frontmatter uses snake_case keys for parseSummary() compatibility.
@@ -134,6 +148,10 @@ ${reqSurfaced}
 
 ${reqInvalidated}
 
+## Operational Readiness
+
+${params.operationalReadiness?.trim() || "None."}
+
 ## Deviations
 
 ${params.deviations || "None."}
@@ -271,6 +289,39 @@ export async function handleCompleteSlice(params, basePath) {
     }
     // Store rendered markdown in DB for D004 recovery
     setSliceSummaryMd(params.milestoneId, params.sliceId, summaryMd, uatMd);
+    // ── Close gates owned by complete-slice (Q8) ───────────────────────────
+    // Each owned gate maps to a specific summary section via the registry.
+    // If the caller populated the corresponding field, record `pass`; if the
+    // field is empty, record `omitted`. Without this loop, Q8 would stay
+    // pending forever and block future state derivation (see gate-registry).
+    try {
+        const pendingGates = getPendingGatesForTurn(params.milestoneId, params.sliceId, "complete-slice");
+        if (pendingGates.length > 0) {
+            const ownedDefs = new Map(getGatesForTurn("complete-slice").map((g) => [g.id, g]));
+            for (const row of pendingGates) {
+                const def = ownedDefs.get(row.gate_id);
+                if (!def)
+                    continue;
+                // Map gate id → param field it maps to. Keep the map local so
+                // adding a new complete-slice gate is a single place change.
+                const field = sliceGateFieldForId(def.id, params);
+                const hasContent = typeof field === "string" && field.trim().length > 0;
+                saveGateResult({
+                    milestoneId: params.milestoneId,
+                    sliceId: params.sliceId,
+                    gateId: def.id,
+                    verdict: hasContent ? "pass" : "omitted",
+                    rationale: hasContent
+                        ? `${def.promptSection} section populated in slice summary`
+                        : `${def.promptSection} section left empty — recorded as omitted`,
+                    findings: hasContent ? field.trim() : "",
+                });
+            }
+        }
+    }
+    catch (gateErr) {
+        logWarning("tool", `complete-slice gate close warning for ${params.milestoneId}/${params.sliceId}: ${gateErr.message}`);
+    }
     // Invalidate all caches
     invalidateStateCache();
     clearPathCache();

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

@@ -9,7 +9,8 @@
 import { join } from "node:path";
 import { mkdirSync } from "node:fs";
 import { isClosedStatus } from "../status-guards.js";
-import { transaction, insertMilestone, insertSlice, insertTask, insertVerificationEvidence, getMilestone, getSlice, getTask, updateTaskStatus, setTaskSummaryMd, deleteVerificationEvidence, } from "../gsd-db.js";
+import { transaction, insertMilestone, insertSlice, insertTask, insertVerificationEvidence, getMilestone, getSlice, getTask, updateTaskStatus, setTaskSummaryMd, deleteVerificationEvidence, saveGateResult, getPendingGatesForTurn, } from "../gsd-db.js";
+import { getGatesForTurn } from "../gate-registry.js";
 import { resolveSliceFile, resolveTasksDir, clearPathCache } from "../paths.js";
 import { checkOwnership, taskUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
@@ -19,6 +20,23 @@ import { renderAllProjections, renderSummaryContent } from "../workflow-projecti
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning, logError } from "../workflow-logger.js";
+/**
+ * Map an execute-task-owned gate id to the CompleteTaskParams field whose
+ * presence drives `pass` vs. `omitted`. Keep in lockstep with the gates
+ * declared in gate-registry.ts under ownerTurn "execute-task".
+ */
+function taskGateFieldForId(id, params) {
+    switch (id) {
+        case "Q5":
+            return params.failureModes;
+        case "Q6":
+            return params.loadProfile;
+        case "Q7":
+            return params.negativeTests;
+        default:
+            return undefined;
+    }
+}
 /**
  * Normalize a list parameter that may arrive as a string (newline-delimited
  * bullet list from the LLM) into a string array (#3361).
@@ -189,6 +207,38 @@ export async function handleCompleteTask(params, basePath) {
     }
     // Store rendered markdown in DB for D004 recovery
     setTaskSummaryMd(params.milestoneId, params.sliceId, params.taskId, summaryMd);
+    // ── Close gates owned by execute-task (Q5/Q6/Q7) for this task ────────
+    // Each gate id maps to a specific params field via taskGateFieldForId.
+    // When the model populates the field, record `pass`; when it's empty,
+    // record `omitted`. Task-scoped rows are filtered by taskId so a single
+    // task's completion doesn't touch sibling tasks' gate rows.
+    try {
+        const pendingGates = getPendingGatesForTurn(params.milestoneId, params.sliceId, "execute-task", params.taskId);
+        if (pendingGates.length > 0) {
+            const ownedDefs = new Map(getGatesForTurn("execute-task").map((g) => [g.id, g]));
+            for (const row of pendingGates) {
+                const def = ownedDefs.get(row.gate_id);
+                if (!def)
+                    continue;
+                const field = taskGateFieldForId(def.id, params);
+                const hasContent = typeof field === "string" && field.trim().length > 0;
+                saveGateResult({
+                    milestoneId: params.milestoneId,
+                    sliceId: params.sliceId,
+                    taskId: params.taskId,
+                    gateId: def.id,
+                    verdict: hasContent ? "pass" : "omitted",
+                    rationale: hasContent
+                        ? `${def.promptSection} section populated in task summary`
+                        : `${def.promptSection} section left empty — recorded as omitted`,
+                    findings: hasContent ? field.trim() : "",
+                });
+            }
+        }
+    }
+    catch (gateErr) {
+        logWarning("tool", `complete-task gate close warning for ${params.milestoneId}/${params.sliceId}/${params.taskId}: ${gateErr.message}`);
+    }
     // Invalidate all caches
     invalidateStateCache();
     clearPathCache();

package/dist/resources/extensions/gsd/tools/workflow-tool-executors.js

@@ -2,6 +2,7 @@ import { ensureDbOpen } from "../bootstrap/dynamic-tools.js";
 import { sanitizeCompleteMilestoneParams } from "../bootstrap/sanitize-complete-milestone.js";
 import { loadWriteGateSnapshot, shouldBlockContextArtifactSaveInSnapshot } from "../bootstrap/write-gate.js";
 import { getMilestone, getSliceStatusSummary, getSliceTaskCounts, _getAdapter, saveGateResult, } from "../gsd-db.js";
+import { GATE_REGISTRY } from "../gate-registry.js";
 import { saveArtifactToDb } from "../db-writer.js";
 import { handleCompleteMilestone } from "./complete-milestone.js";
 import { handleCompleteTask } from "./complete-task.js";
@@ -323,7 +324,9 @@ export async function executeSaveGateResult(params, basePath = process.cwd()) {
             isError: true,
         };
     }
-    const validGates = ["Q3", "Q4", "Q5", "Q6", "Q7", "Q8"];
+    // Source of truth: gate-registry.ts. Every declared GateId is accepted,
+    // so adding a new gate in one place automatically flows through here.
+    const validGates = Object.keys(GATE_REGISTRY);
     if (!validGates.includes(params.gateId)) {
         return {
             content: [{ type: "text", text: `Error: Invalid gateId "${params.gateId}". Must be one of: ${validGates.join(", ")}` }],

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

@@ -49,8 +49,15 @@ async function probeAndRegister(pi) {
         return false;
     }
     const models = await discoverModels();
-    if (models.length === 0)
-        return true; // Running but no models pulled
+    if (models.length === 0) {
+        // No local models means there's nothing usable to register in GSD.
+        // Keep the footer/status clean instead of advertising Ollama availability.
+        if (providerRegistered) {
+            pi.unregisterProvider("ollama");
+            providerRegistered = false;
+        }
+        return false;
+    }
     const baseUrl = client.getOllamaHost();
     // Use authMode "apiKey" with a dummy key (#3440).
     // authMode "none" requires a custom streamSimple handler, but Ollama uses
@@ -102,10 +109,11 @@ export default function ollama(pi) {
         else {
             probeAndRegister(pi)
                 .then((found) => {
-                if (found)
-                    ctx.ui.setStatus("ollama", "Ollama");
+                ctx.ui.setStatus("ollama", found ? "Ollama" : undefined);
             })
-                .catch(() => { });
+                .catch(() => {
+                ctx.ui.setStatus("ollama", undefined);
+            });
         }
     });
     pi.on("session_shutdown", async () => {

package/dist/resources/extensions/shared/gsd-phase-state.js

@@ -0,0 +1,35 @@
+/**
+ * GSD Phase State — cross-extension coordination
+ * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+ *
+ * Lightweight module-level state that GSD auto-mode writes to and the
+ * subagent tool reads from. Both extensions run in the same process so
+ * a module variable is sufficient — no file I/O needed.
+ */
+let _active = false;
+let _currentPhase = null;
+/** Mark GSD auto-mode as active. */
+export function activateGSD() {
+    _active = true;
+}
+/** Mark GSD auto-mode as inactive and clear the current phase. */
+export function deactivateGSD() {
+    _active = false;
+    _currentPhase = null;
+}
+/** Set the currently dispatched GSD phase (e.g. "plan-milestone"). */
+export function setCurrentPhase(phase) {
+    _currentPhase = phase;
+}
+/** Clear the current phase (unit completed or aborted). */
+export function clearCurrentPhase() {
+    _currentPhase = null;
+}
+/** Returns true if GSD auto-mode is currently active. */
+export function isGSDActive() {
+    return _active;
+}
+/** Returns the current GSD phase, or null if none is active. */
+export function getCurrentPhase() {
+    return _active ? _currentPhase : null;
+}

package/dist/resources/extensions/subagent/agents.js

@@ -5,6 +5,12 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { getAgentDir, parseFrontmatter } from "@gsd/pi-coding-agent";
 const PROJECT_AGENT_DIR_CANDIDATES = [".gsd", ".pi"];
+export function parseConflictsWith(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const conflicts = value.split(",").map((s) => s.trim()).filter(Boolean);
+    return conflicts.length > 0 ? conflicts : undefined;
+}
 function parseAgentTools(value) {
     if (typeof value === "string") {
         const tools = value
@@ -52,11 +58,13 @@ function loadAgentsFromDir(dir, source) {
             continue;
         }
         const tools = parseAgentTools(frontmatter.tools);
+        const conflictsWith = parseConflictsWith(frontmatter.conflicts_with);
         agents.push({
             name: frontmatter.name,
             description: frontmatter.description,
             tools: tools && tools.length > 0 ? tools : undefined,
             model: frontmatter.model,
+            conflictsWith,
             systemPrompt: body,
             source,
             filePath,