gsd-pi 2.70.1 → 2.71.0-dev.72557e1

package/dist/resources/extensions/gsd/auto-start.js

@@ -248,17 +248,9 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 logWarning("engine", `mkdir failed: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
-        if (ctx.model?.provider === "claude-code") {
-            try {
-                const { ensureProjectWorkflowMcpConfig } = await import("./mcp-project-config.js");
-                const result = ensureProjectWorkflowMcpConfig(base);
-                if (result.status !== "unchanged") {
-                    ctx.ui.notify(`Claude Code MCP prepared at ${result.configPath}`, "info");
-                }
-            }
-            catch (err) {
-                ctx.ui.notify(`Claude Code MCP prep failed: ${err instanceof Error ? err.message : String(err)}`, "warning");
-            }
+        {
+            const { prepareWorkflowMcpForProject } = await import("./workflow-mcp-auto-prep.js");
+            prepareWorkflowMcpForProject(ctx, base);
         }
         // Initialize GitServiceImpl
         s.gitService = new GitServiceImpl(s.basePath, loadEffectiveGSDPreferences()?.preferences?.git ?? {});
@@ -531,7 +523,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             }
         }
         // ── DB lifecycle ──
-        const gsdDbPath = join(s.basePath, ".gsd", "gsd.db");
+        const gsdDbPath = resolveProjectRootDbPath(s.basePath);
         const gsdDirPath = join(s.basePath, ".gsd");
         if (existsSync(gsdDirPath) && !existsSync(gsdDbPath)) {
             const hasDecisions = existsSync(join(gsdDirPath, "DECISIONS.md"));

package/dist/resources/extensions/gsd/auto-tool-tracking.js

@@ -82,7 +82,7 @@ export function clearInFlightTools() {
  * handler. When these errors occur, retrying the same unit will produce the same
  * failure, so the retry loop must be broken.
  */
-const TOOL_INVOCATION_ERROR_RE = /Validation failed for tool|Expected ',' or '\}' in JSON|Unexpected end of JSON|Unexpected token.*in JSON/i;
+const TOOL_INVOCATION_ERROR_RE = /Validation failed for tool|Expected ',' or '\}'(?: after property value)?(?: in JSON)?|Unexpected end of JSON|Unexpected token.*in JSON/i;
 /**
  * Returns true if the error message indicates a tool invocation failure due to
  * malformed/truncated arguments (as opposed to a normal tool execution error).

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -39,6 +39,8 @@ export function registerHooks(pi) {
         resetToolCallLoopGuard();
         resetAskUserQuestionsCache();
         await syncServiceTierStatus(ctx);
+        const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
+        prepareWorkflowMcpForProject(ctx, process.cwd());
         // Apply show_token_cost preference (#1515)
         try {
             const { loadEffectiveGSDPreferences } = await import("../preferences.js");
@@ -78,6 +80,8 @@ export function registerHooks(pi) {
         resetAskUserQuestionsCache();
         clearDiscussionFlowState();
         await syncServiceTierStatus(ctx);
+        const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
+        prepareWorkflowMcpForProject(ctx, process.cwd());
         loadToolApiKeys();
     });
     pi.on("before_agent_start", async (event, ctx) => {
@@ -107,6 +111,8 @@ export function registerHooks(pi) {
             return { cancel: true };
         }
         const basePath = process.cwd();
+        const { ensureDbOpen } = await import("./dynamic-tools.js");
+        await ensureDbOpen();
         const state = await deriveState(basePath);
         if (!state.activeMilestone || !state.activeSlice || !state.activeTask)
             return;

package/dist/resources/extensions/gsd/bootstrap/system-context.js

@@ -257,6 +257,10 @@ function buildWorktreeContextBlock() {
  */
 const RESUME_INTENT_PATTERNS = /^(continue|resume|ok|go|go ahead|proceed|keep going|carry on|next|yes|yeah|yep|sure|do it|let's go|pick up where you left off)$/;
 async function buildGuidedExecuteContextInjection(prompt, basePath) {
+    const ensureStateDbOpen = async () => {
+        const { ensureDbOpen } = await import("./dynamic-tools.js");
+        await ensureDbOpen();
+    };
     const executeMatch = prompt.match(/Execute the next task:\s+(T\d+)\s+\("([^"]+)"\)\s+in slice\s+(S\d+)\s+of milestone\s+(M\d+(?:-[a-z0-9]{6})?)/i);
     if (executeMatch) {
         const [, taskId, taskTitle, sliceId, milestoneId] = executeMatch;
@@ -265,6 +269,7 @@ async function buildGuidedExecuteContextInjection(prompt, basePath) {
     const resumeMatch = prompt.match(/Resume interrupted work\.[\s\S]*?slice\s+(S\d+)\s+of milestone\s+(M\d+(?:-[a-z0-9]{6})?)/i);
     if (resumeMatch) {
         const [, sliceId, milestoneId] = resumeMatch;
+        await ensureStateDbOpen();
         const state = await deriveState(basePath);
         if (state.activeMilestone?.id === milestoneId && state.activeSlice?.id === sliceId && state.activeTask) {
             return buildTaskExecutionContextInjection(basePath, milestoneId, sliceId, state.activeTask.id, state.activeTask.title);
@@ -279,6 +284,7 @@ async function buildGuidedExecuteContextInjection(prompt, basePath) {
     // replanning, gate evaluation, or other non-execution phases.
     const trimmed = prompt.trim().toLowerCase().replace(/[.!?,]+$/g, "");
     if (RESUME_INTENT_PATTERNS.test(trimmed)) {
+        await ensureStateDbOpen();
         const state = await deriveState(basePath);
         if (state.phase === "executing" && state.activeTask && state.activeMilestone && state.activeSlice) {
             return buildTaskExecutionContextInjection(basePath, state.activeMilestone.id, state.activeSlice.id, state.activeTask.id, state.activeTask.title);

package/dist/resources/extensions/gsd/commands/context.js

@@ -1,8 +1,18 @@
 import { checkRemoteAutoSession, isAutoActive, isAutoPaused, stopAutoRemote } from "../auto.js";
-import { assertSafeDirectory } from "../validate-directory.js";
+import { validateDirectory } from "../validate-directory.js";
 import { resolveProjectRoot } from "../worktree.js";
 import { showNextAction } from "../../shared/tui.js";
 import { handleStatus } from "./handlers/core.js";
+/**
+ * Typed error for when GSD is run outside a valid project directory.
+ * Command handlers catch this to show a friendly message instead of a raw exception.
+ */
+export class GSDNoProjectError extends Error {
+    constructor(reason) {
+        super(reason);
+        this.name = "GSDNoProjectError";
+    }
+}
 export function projectRoot() {
     let cwd;
     try {
@@ -13,11 +23,10 @@ export function projectRoot() {
         cwd = process.env.HOME ?? "/";
     }
     const root = resolveProjectRoot(cwd);
-    if (root !== cwd) {
-        assertSafeDirectory(cwd);
-    }
-    else {
-        assertSafeDirectory(root);
+    const pathToCheck = root !== cwd ? cwd : root;
+    const result = validateDirectory(pathToCheck);
+    if (result.severity === "blocked") {
+        throw new GSDNoProjectError(result.reason ?? "GSD must be run inside a project directory.");
     }
     return root;
 }

package/dist/resources/extensions/gsd/commands/dispatcher.js

@@ -1,3 +1,4 @@
+import { GSDNoProjectError } from "./context.js";
 import { handleAutoCommand } from "./handlers/auto.js";
 import { handleCoreCommand } from "./handlers/core.js";
 import { handleOpsCommand } from "./handlers/ops.js";
@@ -12,10 +13,19 @@ export async function handleGSDCommand(args, ctx, pi) {
         () => handleWorkflowCommand(trimmed, ctx, pi),
         () => handleOpsCommand(trimmed, ctx, pi),
     ];
-    for (const handler of handlers) {
-        if (await handler()) {
+    try {
+        for (const handler of handlers) {
+            if (await handler()) {
+                return;
+            }
+        }
+    }
+    catch (err) {
+        if (err instanceof GSDNoProjectError) {
+            ctx.ui.notify(`${err.message} \`cd\` into a project directory first.`, "warning");
             return;
         }
+        throw err;
     }
     ctx.ui.notify(`Unknown: /gsd ${trimmed}. Run /gsd help for available commands.`, "warning");
 }

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

@@ -17,6 +17,7 @@ import { parse } from "yaml";
 import { readGraph, writeGraph, getNextPendingStep, markStepComplete, expandIteration, } from "./graph.js";
 import { injectContext } from "./context-injector.js";
 import { parseUnitId } from "./unit-id.js";
+import { withFileLock } from "./file-lock.js";
 /** Read and parse the frozen DEFINITION.yaml from a run directory. */
 export function readFrozenDefinition(runDir) {
     const defPath = join(runDir, "DEFINITION.yaml");
@@ -135,18 +136,21 @@ export class CustomWorkflowEngine {
      * Returns "milestone-complete" when all steps are now done, "continue" otherwise.
      */
     async reconcile(state, completedStep) {
-        // 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;
-        const updatedGraph = markStepComplete(graph, stepId);
-        writeGraph(this.runDir, updatedGraph);
-        const allDone = updatedGraph.steps.every((s) => s.status === "complete" || s.status === "expanded");
-        return {
-            outcome: allDone ? "milestone-complete" : "continue",
-        };
+        const graphPath = join(this.runDir, "GRAPH.yaml");
+        return await withFileLock(graphPath, () => {
+            // 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;
+            const updatedGraph = markStepComplete(graph, stepId);
+            writeGraph(this.runDir, updatedGraph);
+            const allDone = updatedGraph.steps.every((s) => s.status === "complete" || s.status === "expanded");
+            return {
+                outcome: allDone ? "milestone-complete" : "continue",
+            };
+        });
     }
     /**
      * Return UI-facing metadata for progress display.

package/dist/resources/extensions/gsd/dispatch-guard.js

@@ -102,10 +102,27 @@ export function getPriorSliceCompletionBlocker(base, _mainBranch, unitType, unit
             }
         }
         else {
+            // Positional fallback is only a heuristic for legacy slices with no
+            // declared dependencies. Skip any earlier slice that depends on the
+            // target, directly or transitively, or we can deadlock a valid zero-dep
+            // slice behind its own downstream dependents (#3720).
+            const reverseDependents = new Set();
+            let changed = true;
+            while (changed) {
+                changed = false;
+                for (const slice of slices) {
+                    if (reverseDependents.has(slice.id))
+                        continue;
+                    if (slice.depends.some((depId) => depId === targetSid || reverseDependents.has(depId))) {
+                        reverseDependents.add(slice.id);
+                        changed = true;
+                    }
+                }
+            }
             const targetIndex = slices.findIndex((slice) => slice.id === targetSid);
             const incomplete = slices
                 .slice(0, targetIndex)
-                .find((slice) => !slice.done);
+                .find((slice) => !slice.done && !reverseDependents.has(slice.id));
             if (incomplete) {
                 return `Cannot dispatch ${unitType} ${unitId}: earlier slice ${targetMid}/${incomplete.id} is not complete.`;
             }

package/dist/resources/extensions/gsd/error-classifier.js

@@ -23,7 +23,7 @@ const RATE_LIMIT_RE = /rate.?limit|too many requests|429/i;
 const NETWORK_RE = /network|ECONNRESET|ETIMEDOUT|ECONNREFUSED|socket hang up|fetch failed|connection.*reset|dns/i;
 const SERVER_RE = /internal server error|500|502|503|overloaded|server_error|api_error|service.?unavailable/i;
 // ECONNRESET/ECONNREFUSED are in NETWORK_RE (same-model retry first).
-const CONNECTION_RE = /terminated|connection.?refused|other side closed|EPIPE|network.?(?:is\s+)?unavailable|stream_exhausted(?:_without_result)?/i;
+const CONNECTION_RE = /terminated|connection.?(?:refused|error)|other side closed|EPIPE|network.?(?:is\s+)?unavailable|stream_exhausted(?:_without_result)?/i;
 // Catch-all for V8 JSON.parse errors: all modern variants end with "in JSON at position \d+".
 // This eliminates the need to enumerate every error message variant individually.
 const STREAM_RE = /in JSON at position \d+|Unexpected end of JSON|SyntaxError.*JSON/i;

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

@@ -0,0 +1,60 @@
+import { existsSync } from "node:fs";
+function _require(name) {
+    try {
+        return require(name);
+    }
+    catch {
+        try {
+            const gsdPiRequire = require("module").createRequire(require("path").join(process.cwd(), "node_modules", "gsd-pi", "index.js"));
+            return gsdPiRequire(name);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+export function withFileLockSync(filePath, fn) {
+    const lockfile = _require("proper-lockfile");
+    if (!lockfile)
+        return fn();
+    if (!existsSync(filePath))
+        return fn();
+    try {
+        const release = lockfile.lockSync(filePath, { retries: 5, stale: 10000 });
+        try {
+            return fn();
+        }
+        finally {
+            release();
+        }
+    }
+    catch (err) {
+        if (err.code === "ELOCKED") {
+            // Could not get lock after retries, let's fallback to un-locked instead of crashing the whole state machine
+            return fn();
+        }
+        throw err;
+    }
+}
+export async function withFileLock(filePath, fn) {
+    const lockfile = _require("proper-lockfile");
+    if (!lockfile)
+        return await fn();
+    if (!existsSync(filePath))
+        return await fn();
+    try {
+        const release = await lockfile.lock(filePath, { retries: 5, stale: 10000 });
+        try {
+            return await fn();
+        }
+        finally {
+            await release();
+        }
+    }
+    catch (err) {
+        if (err.code === "ELOCKED") {
+            return await fn();
+        }
+        throw err;
+    }
+}

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

@@ -334,8 +334,9 @@ function resolveAvailableModel(modelId, availableModels, currentProvider) {
  * Build the discuss-and-plan prompt for a new milestone.
  * Used by all three "new milestone" paths (first ever, no active, all complete).
  */
-function buildDiscussPrompt(nextId, preamble, _basePath, preparationContext) {
+function buildDiscussPrompt(nextId, preamble, _basePath, pi, ctx, preparationContext) {
     const milestoneRel = `.gsd/milestones/${nextId}`;
+    const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
     const inlinedTemplates = [
         inlineTemplate("project", "Project"),
         inlineTemplate("requirements", "Requirements"),
@@ -347,6 +348,7 @@ function buildDiscussPrompt(nextId, preamble, _basePath, preparationContext) {
         milestoneId: nextId,
         preamble,
         preparationContext: preparationContext ?? "",
+        structuredQuestionsAvailable,
         contextPath: `${milestoneRel}/${nextId}-CONTEXT.md`,
         roadmapPath: `${milestoneRel}/${nextId}-ROADMAP.md`,
         inlinedTemplates,
@@ -390,7 +392,7 @@ function buildHeadlessDiscussPrompt(nextId, seedContext, _basePath) {
  * @param basePath - Root directory of the project
  * @returns The discuss prompt string
  */
-async function prepareAndBuildDiscussPrompt(ctx, nextId, preamble, basePath) {
+async function prepareAndBuildDiscussPrompt(ctx, pi, nextId, preamble, basePath) {
     const prefs = loadEffectiveGSDPreferences()?.preferences ?? {};
     // Run preparation if enabled (default: true) — results are injected as
     // supplementary context into the standard discuss prompt, NOT as a
@@ -421,7 +423,7 @@ async function prepareAndBuildDiscussPrompt(ctx, nextId, preamble, basePath) {
             logWarning("guided", `preparation failed, proceeding without context: ${err.message}`);
         }
     }
-    return buildDiscussPrompt(nextId, preamble, basePath, preparationContext);
+    return buildDiscussPrompt(nextId, preamble, basePath, pi, ctx, preparationContext);
 }
 /**
  * Bootstrap a .gsd/ project from scratch for headless use.
@@ -638,7 +640,7 @@ export async function showDiscuss(ctx, pi, basePath) {
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
             const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
             pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: false, createdAt: Date.now() });
-            await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
+            await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
         return;
     }
@@ -994,7 +996,7 @@ async function handleMilestoneActions(ctx, pi, basePath, milestoneId, milestoneT
         const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
         const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
         pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
-        await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
+        await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         return true;
     }
     // "back" or null
@@ -1161,7 +1163,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
         if (isFirst) {
             // First ever — skip wizard, just ask directly
             pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
-            await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, nextId, `New project, milestone ${nextId}. Do NOT read or explore .gsd/ — it's empty scaffolding.`, basePath), "gsd-run", ctx, "discuss-milestone");
+            await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New project, milestone ${nextId}. Do NOT read or explore .gsd/ — it's empty scaffolding.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
         else {
             const choice = await showNextAction(ctx, {
@@ -1179,7 +1181,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             });
             if (choice === "new_milestone") {
                 pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
-                await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
+                await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
             }
         }
         return;
@@ -1211,7 +1213,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
             const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
             pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
-            await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
+            await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
         else if (choice === "status") {
             const { fireStatusViaCommand } = await import("./commands.js");
@@ -1275,7 +1277,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
             const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
             pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
-            await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
+            await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
         return;
     }
@@ -1365,7 +1367,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
                 const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
                 pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
-                await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
+                await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
             }
             else if (choice === "discard_milestone") {
                 const confirmed = await showConfirm(ctx, {

package/dist/resources/extensions/gsd/init-wizard.js

@@ -225,17 +225,9 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
     catch {
         // Non-fatal — STATE.md will be regenerated on next /gsd invocation
     }
-    if (ctx.model?.provider === "claude-code") {
-        try {
-            const { ensureProjectWorkflowMcpConfig } = await import("./mcp-project-config.js");
-            const result = ensureProjectWorkflowMcpConfig(basePath);
-            if (result.status !== "unchanged") {
-                ctx.ui.notify(`Claude Code MCP prepared at ${result.configPath}`, "info");
-            }
-        }
-        catch (err) {
-            ctx.ui.notify(`Claude Code MCP prep failed: ${err instanceof Error ? err.message : String(err)}`, "warning");
-        }
+    {
+        const { prepareWorkflowMcpForProject } = await import("./workflow-mcp-auto-prep.js");
+        prepareWorkflowMcpForProject(ctx, basePath);
     }
     ctx.ui.notify("GSD initialized. Starting your first milestone...", "info");
     return { completed: true, bootstrapped: true };

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

@@ -9,16 +9,22 @@ 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();
 // ─── 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 +38,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,
     };
@@ -154,6 +173,7 @@ export function _resetNotificationStore() {
     _basePath = null;
     _lineCount = 0;
     _suppressCount = 0;
+    _recentMessageTimestamps = new Map();
 }
 // ─── Internal ───────────────────────────────────────────────────────────
 function _readEntriesFromDisk(basePath) {

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

@@ -19,7 +19,7 @@ export function buildNotificationWidgetLines() {
     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 [`  ${icon} [${badge}]  ${truncated}  (${formatShortcut("Ctrl+Alt+N")} or /gsd notifications)`];
 }
 // ─── Widget init ────────────────────────────────────────────────────────
 const REFRESH_INTERVAL_MS = 5_000;

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/prompts/complete-slice.md

@@ -21,7 +21,7 @@ All relevant context has been preloaded below — the slice plan, all task summa
 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.
 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.
@@ -35,7 +35,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.**