gsd-pi 2.71.0 → 2.72.0-dev.593fa74

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

@@ -1,8 +1,9 @@
 // GSD Extension — Notification History Overlay
 // Scrollable panel showing all persisted notifications with severity filtering.
-// Toggled with Ctrl+Alt+N (⌃⌥N on macOS) or opened from /gsd notifications.
+// 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"];
 function severityIcon(severity) {
@@ -55,6 +56,11 @@ function formatTimestamp(ts) {
         return ts.slice(11, 19); // fallback: HH:MM:SS
     }
 }
+function notificationSignature(entries) {
+    return entries
+        .map((entry) => `${entry.ts}|${entry.severity}|${entry.read ? 1 : 0}|${entry.message}`)
+        .join("\n");
+}
 export class GSDNotificationOverlay {
     tui;
     theme;
@@ -64,9 +70,11 @@ export class GSDNotificationOverlay {
     scrollOffset = 0;
     filterIndex = 0;
     entries = [];
+    entriesSignature = "";
     refreshTimer;
     disposed = false;
     resizeHandler = null;
+    unsubscribeStore = null;
     constructor(tui, theme, onClose) {
         this.tui = tui;
         this.theme = theme;
@@ -74,6 +82,7 @@ export class GSDNotificationOverlay {
         // Mark all as read on open
         markAllRead();
         this.entries = readNotifications();
+        this.entriesSignature = notificationSignature(this.entries);
         // Resize handler
         this.resizeHandler = () => {
             if (this.disposed)
@@ -82,18 +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();
-            if (fresh.length !== this.entries.length) {
-                this.entries = fresh;
-                markAllRead();
-                this.invalidate();
-                this.tui.requestRender();
-            }
-        }, 3000);
+            this._refreshFromDisk();
+        }, 30_000);
     }
     get filter() {
         return FILTER_CYCLE[this.filterIndex];
@@ -104,7 +113,10 @@ export class GSDNotificationOverlay {
         return this.entries.filter((e) => e.severity === this.filter);
     }
     handleInput(data) {
-        if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c")) || matchesKey(data, Key.ctrlAlt("n"))) {
+        if (matchesKey(data, Key.escape) ||
+            matchesKey(data, Key.ctrl("c")) ||
+            matchesKey(data, Key.ctrlAlt("n")) ||
+            matchesKey(data, Key.ctrlShift("n"))) {
             this.dispose();
             this.onClose();
             return;
@@ -146,6 +158,7 @@ export class GSDNotificationOverlay {
         if (data === "c") {
             clearNotifications();
             this.entries = [];
+            this.entriesSignature = notificationSignature(this.entries);
             this.scrollOffset = 0;
             this.invalidate();
             this.tui.requestRender();
@@ -174,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);
@@ -215,7 +243,8 @@ export class GSDNotificationOverlay {
         lines.push(row(joinColumns(`${title}  ${th.fg("dim", "filter:")} ${filterLabel}`, th.fg("dim", count), contentWidth)));
         lines.push(hr());
         // Controls
-        lines.push(row(th.fg("dim", "↑/↓ scroll  f filter  c clear  Esc close")));
+        const closeShortcut = formattedShortcutPair("notifications");
+        lines.push(row(th.fg("dim", `↑/↓ scroll  f filter  c clear  Esc close  (${closeShortcut})`)));
         lines.push(blank());
         // Entries
         const filtered = this.filteredEntries;

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

@@ -9,16 +9,23 @@ import { randomUUID } from "node:crypto";
 const MAX_ENTRIES = 500;
 const FILENAME = "notifications.jsonl";
 const LOCKFILE = "notifications.lock";
+const DEDUP_WINDOW_MS = 30_000;
+const DEDUP_PRUNE_THRESHOLD = 200;
 // ─── Module State ───────────────────────────────────────────────────────
 let _basePath = null;
 let _lineCount = 0; // Hint for rotation — not authoritative for public API
 let _suppressCount = 0;
+let _recentMessageTimestamps = new Map();
+const _changeListeners = new Set();
 // ─── Public API ─────────────────────────────────────────────────────────
 /**
  * Initialize the notification store. Call once at session start with the
  * project root. Seeds in-memory counters from the existing file on disk.
  */
 export function initNotificationStore(basePath) {
+    if (_basePath !== basePath) {
+        _recentMessageTimestamps.clear();
+    }
     _basePath = basePath;
     // Seed line count hint for rotation — public counters read from disk
     _lineCount = _readEntriesFromDisk(basePath).length;
@@ -32,11 +39,24 @@ export function appendNotification(message, severity, source = "notify") {
         return;
     if (_suppressCount > 0)
         return;
+    const persistedMessage = message.length > 500 ? message.slice(0, 500) + "…" : message;
+    const dedupKey = `${_basePath}:${severity}:${source}:${persistedMessage}`;
+    const now = Date.now();
+    const lastSeen = _recentMessageTimestamps.get(dedupKey);
+    if (lastSeen !== undefined && now - lastSeen < DEDUP_WINDOW_MS)
+        return;
+    _recentMessageTimestamps.set(dedupKey, now);
+    if (_recentMessageTimestamps.size > DEDUP_PRUNE_THRESHOLD) {
+        for (const [key, ts] of _recentMessageTimestamps) {
+            if (now - ts > DEDUP_WINDOW_MS)
+                _recentMessageTimestamps.delete(key);
+        }
+    }
     const entry = {
         id: randomUUID(),
         ts: new Date().toISOString(),
         severity,
-        message: message.length > 500 ? message.slice(0, 500) + "…" : message,
+        message: persistedMessage,
         source,
         read: false,
     };
@@ -49,6 +69,7 @@ export function appendNotification(message, severity, source = "notify") {
         if (_lineCount > MAX_ENTRIES) {
             _rotate();
         }
+        _emitChange();
     }
     catch {
         // Non-fatal — never let persistence break the caller
@@ -77,6 +98,7 @@ export function markAllRead(basePath) {
     const hasUnread = entries.some((e) => !e.read);
     if (!hasUnread)
         return;
+    let changed = false;
     try {
         _withLock(bp, () => {
             // Re-read inside lock to get freshest state
@@ -85,11 +107,14 @@ export function markAllRead(basePath) {
                 return;
             const lines = fresh.map((e) => JSON.stringify({ ...e, read: true }));
             _atomicWrite(bp, lines.join("\n") + "\n");
+            changed = true;
         });
     }
     catch {
         // Non-fatal
     }
+    if (changed)
+        _emitChange();
 }
 /**
  * Clear all notifications. Atomic write of empty content under lock.
@@ -102,6 +127,8 @@ export function clearNotifications(basePath) {
         _withLock(bp, () => {
             _atomicWrite(bp, "");
         });
+        _lineCount = 0;
+        _emitChange();
     }
     catch {
         // Non-fatal
@@ -146,6 +173,16 @@ export function suppressPersistence() {
 export function unsuppressPersistence() {
     _suppressCount = Math.max(0, _suppressCount - 1);
 }
+/**
+ * Subscribe to notification-store mutations (append, mark-read, clear).
+ * Returns an unsubscribe function.
+ */
+export function onNotificationStoreChange(listener) {
+    _changeListeners.add(listener);
+    return () => {
+        _changeListeners.delete(listener);
+    };
+}
 // ─── Test Helpers ───────────────────────────────────────────────────────
 /**
  * Reset module state. Only for use in tests.
@@ -154,6 +191,8 @@ export function _resetNotificationStore() {
     _basePath = null;
     _lineCount = 0;
     _suppressCount = 0;
+    _recentMessageTimestamps = new Map();
+    _changeListeners.clear();
 }
 // ─── Internal ───────────────────────────────────────────────────────────
 function _readEntriesFromDisk(basePath) {
@@ -191,12 +230,23 @@ function _rotate() {
             const trimmed = entries.slice(entries.length - MAX_ENTRIES);
             const lines = trimmed.map((e) => JSON.stringify(e));
             _atomicWrite(_basePath, lines.join("\n") + "\n");
+            _lineCount = trimmed.length;
         });
     }
     catch {
         // Non-fatal
     }
 }
+function _emitChange() {
+    for (const listener of _changeListeners) {
+        try {
+            listener();
+        }
+        catch {
+            // Non-fatal
+        }
+    }
+}
 /**
  * Atomic file rewrite via temp-file + rename. Prevents partial reads
  * by other processes (web API subprocess, parallel workers).
@@ -251,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);
@@ -263,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/notification-widget.js

@@ -2,24 +2,14 @@
 // Always-on ambient widget rendered belowEditor showing unread count and
 // the most recent notification message. Refreshes every 5 seconds.
 // Widget key: "gsd-notifications", placement: "belowEditor"
-import { getUnreadCount, readNotifications } from "./notification-store.js";
-import { formatShortcut } from "./files.js";
+import { getUnreadCount, onNotificationStoreChange } from "./notification-store.js";
+import { formattedShortcutPair } from "./shortcut-defs.js";
 // ─── Pure rendering ──���────────────────────────���─────────────────────────
 export function buildNotificationWidgetLines() {
     const unread = getUnreadCount();
     if (unread === 0)
         return [];
-    const entries = readNotifications();
-    const latest = entries[0]; // newest-first
-    if (!latest)
-        return [];
-    const icon = latest.severity === "error" ? "✗" : latest.severity === "warning" ? "⚠" : "●";
-    const badge = `${unread} unread`;
-    const msgMax = 80;
-    const truncated = latest.message.length > msgMax
-        ? latest.message.slice(0, msgMax - 1) + "…"
-        : latest.message;
-    return [`  ${icon} [${badge}]  ${truncated}  (${formatShortcut("Ctrl+Alt+N")} to view)`];
+    return [`  🔔 Notifications: ${unread} unread  (${formattedShortcutPair("notifications")})`];
 }
 // ─── Widget init ────────────────────────────────────────────────────────
 const REFRESH_INTERVAL_MS = 5_000;
@@ -39,6 +29,7 @@ export function initNotificationWidget(ctx) {
             cachedLines = undefined;
             _tui.requestRender();
         };
+        const unsubscribe = onNotificationStoreChange(refresh);
         const refreshTimer = setInterval(refresh, REFRESH_INTERVAL_MS);
         return {
             render(_width) {
@@ -50,6 +41,7 @@ export function initNotificationWidget(ctx) {
                 cachedLines = undefined;
             },
             dispose() {
+                unsubscribe();
                 clearInterval(refreshTimer);
             },
         };

package/dist/resources/extensions/gsd/parallel-monitor-overlay.js

@@ -2,7 +2,8 @@
  * GSD Parallel Monitor Overlay
  *
  * Full-screen TUI overlay showing real-time parallel worker progress.
- * Opened via `/gsd parallel watch` or Ctrl+Alt+P (⌃⌥P on macOS).
+ * Opened via `/gsd parallel watch`, Ctrl+Alt+P (⌃⌥P on macOS),
+ * or Ctrl+Shift+P fallback.
  * Reads the same data sources as `scripts/parallel-monitor.mjs` but
  * renders as a native pi-tui overlay with theme integration.
  */
@@ -11,6 +12,7 @@ import { join } from "node:path";
 import { spawnSync } from "node:child_process";
 import { matchesKey, Key } from "@gsd/pi-tui";
 import { formatDuration } from "../shared/mod.js";
+import { formattedShortcutPair } from "./shortcut-defs.js";
 // ─── Data Helpers ─────────────────────────────────────────────────────────
 function readJsonSafe(filePath) {
     try {
@@ -285,7 +287,10 @@ export class ParallelMonitorOverlay {
         }
     }
     handleInput(data) {
-        if (matchesKey(data, Key.escape) || data === "q") {
+        if (matchesKey(data, Key.escape) ||
+            matchesKey(data, Key.ctrlAlt("p")) ||
+            matchesKey(data, Key.ctrlShift("p")) ||
+            data === "q") {
             this.dispose();
             this.onClose();
             return;
@@ -403,7 +408,7 @@ export class ParallelMonitorOverlay {
             }
             lines.push(`  ${t.bold("Total: $" + this.workers.reduce((s, wk) => s + wk.cost, 0).toFixed(2))}`);
         }
-        lines.push(t.fg("muted", "  ESC/q to close  │  ↑↓ scroll"));
+        lines.push(t.fg("muted", `  ESC/q/${formattedShortcutPair("parallel")} close  │  ↑↓ scroll`));
         // Apply scroll — use terminal rows as height estimate
         const termHeight = process.stdout.rows || 40;
         const maxScroll = Math.max(0, lines.length - termHeight);

package/dist/resources/extensions/gsd/pre-execution-checks.js

@@ -229,6 +229,33 @@ function extractPathFromAnnotation(raw) {
     // Fall back to the original behavior for already-plain paths.
     return trimmed.replace(/`/g, "");
 }
+/**
+ * Planning units sometimes use task.inputs for prose like "Current enum shape"
+ * instead of concrete file paths. Those entries should not fail path checks.
+ * Keep validation for anything that still looks like a real file reference:
+ * explicit backticks, globs, separators, dot-paths, or single-token basenames
+ * like Dockerfile.
+ */
+function shouldValidateInputAsPath(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return false;
+    if (/^`+[^`]+`+/.test(trimmed)) {
+        return true;
+    }
+    const candidate = extractPathFromAnnotation(trimmed);
+    if (!candidate)
+        return false;
+    if (!/\s/.test(candidate)) {
+        return true;
+    }
+    return (candidate.startsWith("/") ||
+        candidate.startsWith("./") ||
+        candidate.startsWith("../") ||
+        candidate.startsWith("~/") ||
+        /[\\/]/.test(candidate) ||
+        /[*?[\]{}]/.test(candidate));
+}
 /**
  * Build a set of files that will be created by tasks up to (but not including) taskIndex.
  * All paths are normalized for consistent comparison.
@@ -262,6 +289,8 @@ export function checkFilePathConsistency(tasks, basePath) {
             // Skip empty strings
             if (!file.trim())
                 continue;
+            if (!shouldValidateInputAsPath(file))
+                continue;
             // Normalize path for consistent comparison
             const normalizedFile = normalizeFilePath(file);
             // Check if file exists on disk
@@ -289,7 +318,7 @@ export function checkFilePathConsistency(tasks, basePath) {
  *
  * All paths are normalized before comparison to ensure ./src/a.ts matches src/a.ts.
  */
-export function checkTaskOrdering(tasks, _basePath) {
+export function checkTaskOrdering(tasks, basePath) {
     const results = [];
     // Build map: normalized file → task index that creates it
     const fileCreators = new Map();
@@ -309,9 +338,13 @@ export function checkTaskOrdering(tasks, _basePath) {
         const task = tasks[i];
         const filesToCheck = [...task.inputs];
         for (const file of filesToCheck) {
+            if (!shouldValidateInputAsPath(file))
+                continue;
             const normalizedFile = normalizeFilePath(file);
             const creator = fileCreators.get(normalizedFile);
-            if (creator && creator.index > i) {
+            const absolutePath = resolve(basePath, normalizedFile);
+            const existsOnDisk = existsSync(absolutePath);
+            if (creator && creator.index > i && !existsOnDisk) {
                 // Task reads file that is created later — impossible ordering
                 results.push({
                     category: "file",

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,14 +16,16 @@ 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:
 1. Use the **Slice Summary** and **UAT** output templates from the inlined context above
 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.
+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.
@@ -35,7 +37,7 @@ Then:
 
 **Autonomous execution:** Do not call `ask_user_questions` or `secure_env_collect`. You are running in auto-mode — there is no human available to answer questions. Make reasonable assumptions and document them in the slice summary. If a decision genuinely requires human input, note it in the summary and proceed with the best available option.
 
-**File system safety:** Task summaries are preloaded in the inlined context above. If you need to re-read any of them, use `find .gsd/milestones/{{milestoneId}}/slices/{{sliceId}}/tasks -name "*-SUMMARY.md"` to list file paths first — never pass `{{slicePath}}` or any other directory path directly to the `read` tool. The `read` tool only accepts file paths, not directories.
+**File system safety:** Task summaries are preloaded in the inlined context above. Task artifacts use a **flat file layout** — files such as `T01-SUMMARY.md` and `T02-SUMMARY.md` live directly inside the `tasks/` directory, not inside per-task subdirectories like `tasks/T01/SUMMARY.md`. If you need to re-read any of them, use `find .gsd/milestones/{{milestoneId}}/slices/{{sliceId}}/tasks -name "*-SUMMARY.md"` to list file paths first. Never use `tasks/*/SUMMARY.md`, and never pass `{{slicePath}}` or any other directory path directly to the `read` tool. The `read` tool only accepts file paths, not directories.
 
 **You MUST call `gsd_complete_slice` with the slice summary and UAT content before finishing. The tool persists to both DB and disk and renders `{{sliceSummaryPath}}` and `{{sliceUatPath}}` automatically.**
 

package/dist/resources/extensions/gsd/prompts/discuss.md

@@ -73,6 +73,8 @@ After each round of answers, decide whether you already have enough depth to wri
 
 You are a thinking partner, not an interviewer.
 
+**Turn-taking contract (non-bypassable).** Never fabricate, simulate, or role-play user responses. Never generate fake transcript markers like `[User]`, `[Human]`, or `User:` to invent input. Ask one question round (1-3 questions) per turn, then stop and wait for the user's actual response before continuing. If you use `ask_user_questions`, call it at most once per turn and treat its returned response as the only valid structured user input for that round.
+
 **Start open, follow energy.** Let the user's enthusiasm guide where you dig deeper. If they light up about a particular aspect, explore it. If they're vague about something, that's where you probe.
 
 **Challenge vagueness, make abstract concrete.** When the user says something abstract ("it should be smart" / "it needs to handle edge cases" / "good UX"), push for specifics. What does "smart" mean in practice? Which edge cases? What does good UX look like for this specific interaction?