@opengsd/gsd-pi 1.1.1-dev.3ea310e → 1.1.1-dev.595401e

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

@@ -62,6 +62,8 @@ export class GSDDashboardOverlay {
     refreshInFlight = null;
     disposed = false;
     resizeHandler = null;
+    cachedMetrics = null;
+    lastSeenUnitCount = -1;
     constructor(tui, theme, onClose) {
         this.tui = tui;
         this.theme = theme;
@@ -105,7 +107,8 @@ export class GSDDashboardOverlay {
             return;
         this.dashData = getAutoDashboardData();
         const nextIdentity = this.computeDashboardIdentity(this.dashData);
-        if (initial || nextIdentity !== this.loadedDashboardIdentity) {
+        const identityChanged = initial || nextIdentity !== this.loadedDashboardIdentity;
+        if (identityChanged) {
             const loaded = await this.loadData();
             if (this.disposed)
                 return;
@@ -116,7 +119,9 @@ export class GSDDashboardOverlay {
         if (initial) {
             this.loading = false;
         }
-        this.invalidate();
+        if (identityChanged) {
+            this.invalidate();
+        }
         this.tui.requestRender();
     }
     async loadData() {
@@ -392,7 +397,7 @@ export class GSDDashboardOverlay {
         }
         const ledger = getLedger();
         if (ledger && ledger.units.length > 0) {
-            const totals = getProjectTotals(ledger.units);
+            const { totals, promptStats, phases, slices, models } = this.ensureMetricsCache(ledger.units);
             lines.push(blank());
             lines.push(hr());
             lines.push(row(th.fg("text", th.bold("Cost & Usage"))));
@@ -424,7 +429,6 @@ export class GSDDashboardOverlay {
                 }
                 lines.push(row(budgetParts.join(`  ${th.fg("dim", "·")}  `)));
             }
-            const promptStats = getPromptSizeStats(ledger.units);
             if (promptStats) {
                 const promptParts = [
                     `${th.fg("dim", "avg prompt:")} ${th.fg("text", formatCharCount(promptStats.averagePromptChars))}`,
@@ -435,7 +439,6 @@ export class GSDDashboardOverlay {
                 }
                 lines.push(row(promptParts.join(`  ${th.fg("dim", "·")}  `)));
             }
-            const phases = aggregateByPhase(ledger.units);
             if (phases.length > 0) {
                 lines.push(blank());
                 lines.push(row(th.fg("dim", "By Phase")));
@@ -446,7 +449,6 @@ export class GSDDashboardOverlay {
                     lines.push(row(joinColumns(left, right, contentWidth)));
                 }
             }
-            const slices = aggregateBySlice(ledger.units);
             if (slices.length > 0) {
                 lines.push(blank());
                 lines.push(row(th.fg("dim", "By Slice")));
@@ -475,7 +477,6 @@ export class GSDDashboardOverlay {
                     }
                 }
             }
-            const models = aggregateByModel(ledger.units);
             if (models.length >= 1) {
                 lines.push(blank());
                 lines.push(row(th.fg("dim", "By Model")));
@@ -534,6 +535,19 @@ export class GSDDashboardOverlay {
         const bar = th.fg(color, "█".repeat(filled)) + th.fg("dim", "░".repeat(Math.max(0, barWidth - filled)));
         return `${th.fg("dim", labelText)}${" ".repeat(gap)}${bar}${" ".repeat(gap)}${th.fg("dim", rightText)}`;
     }
+    ensureMetricsCache(units) {
+        if (!this.cachedMetrics || units.length !== this.lastSeenUnitCount) {
+            this.cachedMetrics = {
+                totals: getProjectTotals(units),
+                promptStats: getPromptSizeStats(units),
+                phases: aggregateByPhase(units),
+                slices: aggregateBySlice(units),
+                models: aggregateByModel(units),
+            };
+            this.lastSeenUnitCount = units.length;
+        }
+        return this.cachedMetrics;
+    }
     invalidate() {
         this.cachedWidth = undefined;
         this.cachedLines = undefined;

package/dist/resources/extensions/gsd/docs/preferences-reference.md

@@ -305,10 +305,18 @@ This config sets a parent workspace with two child repositories. The implicit `p
   - `max_cycles`: number — max times this hook fires per trigger (default: 1, max: 10).
   - `model`: string — optional model override.
   - `artifact`: string — expected output file name (relative to task/slice dir). Hook is skipped if file already exists (idempotent).
+  - `criticality`: `"advisory"` or `"blocking"` — advisory preserves current best-effort behavior; blocking requires clean hook completion plus a valid outcome verdict before auto-mode advances. Default: `"advisory"`.
   - `retry_on`: string — if this file is produced instead of the artifact, re-run the trigger unit then re-run hooks.
+  - `on_block`: object — optional routing for blocking findings:
+    - `action`: `"retry-unit"`, `"retry-task"`, `"queue-task"`, `"queue-slice"`, or `"pause"`.
+    - `artifact`: string — optional compatibility artifact for retry routing.
   - `agent`: string — agent definition file to use for hook execution.
   - `enabled`: boolean — toggle without removing (default: `true`).
 
+  Blocking hook artifacts must begin with YAML frontmatter containing either `verdict` or `outcome.verdict`.
+  Supported verdicts are `pass`, `advisory`, `needs-rework`, `needs-remediation`, and `needs-attention`.
+  `pass` and `advisory` continue; `needs-rework` retries the trigger unit when routed with `retry-unit`/`retry-task`; `needs-remediation` and `needs-attention` pause with recovery guidance.
+
 - `pre_dispatch_hooks`: array — hooks that fire before a unit is dispatched. Each entry has:
   - `name`: string — unique hook identifier.
   - `before`: string[] — unit types to intercept.

package/dist/resources/extensions/gsd/doctor-runtime-checks.js

@@ -258,14 +258,14 @@ export async function checkRuntimeHealth(basePath, issues, fixesApplied, shouldF
                 catch {
                     count = MAX_UAT_ATTEMPTS + 1;
                 }
-                if (count <= MAX_UAT_ATTEMPTS)
+                if (count < MAX_UAT_ATTEMPTS)
                     continue;
                 issues.push({
                     severity: "warning",
                     code: "uat_retry_exhausted",
                     scope: "slice",
                     unitId: `${mid}/${sid}`,
-                    message: `run-uat for ${mid}/${sid} exhausted ${count - 1} retry attempt(s) without an ASSESSMENT verdict. Reset the retry counter after fixing the underlying UAT/tool issue, then rerun /gsd auto.`,
+                    message: `run-uat for ${mid}/${sid} exhausted ${count} attempt(s) without an ASSESSMENT verdict. Reset the retry counter after fixing the underlying UAT/tool issue, then rerun /gsd auto.`,
                     file: `.gsd/runtime/${fileName}`,
                     fixable: true,
                 });

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

@@ -21,9 +21,10 @@ export function resetRetryState(state) {
 const PERMANENT_RE = /auth|unauthorized|forbidden|invalid.*key|invalid.*api|billing|quota exceeded|account/i;
 // Include provider-specific quota-window phrasing like:
 // - "You've hit your limit"
+// - "You've reached your limit"
 // - "usage limit" / "quota reached"
 // - "out of extra usage"
-const RATE_LIMIT_RE = /rate.?limit|too many requests|429|hit your limit|usage limit|out of extra usage|quota (?:reached|hit)|limit.*resets?/i;
+const RATE_LIMIT_RE = /rate.?limit|too many requests|429|(?:hit|reached) your (?:\w+ )?limit|(?:usage|session|weekly|daily|monthly|quota) limit|out of extra usage|quota (?:reached|hit)|limit.*resets?/i;
 // OpenRouter affordability-style quota errors should be treated as transient
 // so core retry logic can lower maxTokens and continue in-session.
 const AFFORDABILITY_RE = /requires more credits|can only afford|insufficient credits|not enough credits|fewer max_tokens/i;

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

@@ -140,13 +140,13 @@ export function readEscalationArtifact(path) {
 }
 // ─── Detection ────────────────────────────────────────────────────────────
 /**
- * Returns the task id of the first task with an un-resolved pause-escalation
- * (escalation_pending=1, not yet respondedAt). awaiting_review slices are NOT
- * returned — they don't pause the loop.
+ * Returns the task id of the first task with an unresolved escalation.
+ * `continueWithDefault=true` artifacts keep the awaiting_review flag for
+ * compatibility, but still pause dispatch until the user explicitly responds.
  */
 export function detectPendingEscalation(tasks, basePath) {
     for (const t of tasks) {
-        if (t.escalation_pending !== 1)
+        if (t.escalation_pending !== 1 && t.escalation_awaiting_review !== 1)
             continue;
         if (!t.escalation_artifact_path)
             continue;

package/dist/resources/extensions/gsd/exec-sandbox.js

@@ -247,6 +247,7 @@ function writeMeta(path, result, request, now) {
         id: result.id,
         runtime: result.runtime,
         purpose: request.purpose ?? null,
+        ...(request.metadata ? { metadata: request.metadata } : {}),
         script_chars: request.script.length,
         started_at: now.toISOString(),
         finished_at: new Date(now.getTime() + result.duration_ms).toISOString(),
@@ -260,6 +261,7 @@ function writeMeta(path, result, request, now) {
         stderr_truncated: result.stderr_truncated,
         stdout_path: result.stdout_path,
         stderr_path: result.stderr_path,
+        ...(request.metadata ? { metadata: request.metadata } : {}),
     };
     writeFileSync(path, `${JSON.stringify(meta, null, 2)}\n`);
 }

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

@@ -32,6 +32,68 @@ import { isInteractiveCommandContext, notifyForensicsNeedsInteractiveMenu, } fro
 import { ensurePreferencesFile, serializePreferencesToFrontmatter } from "./commands-prefs-wizard.js";
 import { summarizeWorktreeTelemetry, percentile } from "./worktree-telemetry.js";
 import { homedir } from "node:os";
+// ─── Filing Tool Scope ───────────────────────────────────────────────────────
+const FORENSICS_FILING_TOOLS = ["bash", "write"];
+function uniqueAppend(base, additions) {
+    const seen = new Set(base);
+    const next = [...base];
+    for (const name of additions) {
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        next.push(name);
+    }
+    return next;
+}
+function sameOrderedTools(a, b) {
+    return a.length === b.length && a.every((name, index) => name === b[index]);
+}
+function getRegisteredToolNames(pi, fallback) {
+    if (typeof pi.getAllTools === "function") {
+        return pi.getAllTools().map((tool) => tool.name);
+    }
+    return [...fallback];
+}
+export function createForensicsToolScope(pi) {
+    const savedTools = [...pi.getActiveTools()];
+    const registeredTools = new Set([...getRegisteredToolNames(pi, savedTools), ...savedTools]);
+    const availableFilingTools = FORENSICS_FILING_TOOLS.filter((name) => registeredTools.has(name));
+    const missingFilingTools = FORENSICS_FILING_TOOLS.filter((name) => !registeredTools.has(name));
+    const activeToolsForTurn = uniqueAppend(savedTools, availableFilingTools);
+    return {
+        savedTools,
+        activeToolsForTurn,
+        availableFilingTools,
+        missingFilingTools,
+        toolsChanged: !sameOrderedTools(savedTools, activeToolsForTurn),
+    };
+}
+export function applyForensicsToolScope(pi, scope) {
+    if (scope.toolsChanged)
+        pi.setActiveTools(scope.activeToolsForTurn);
+}
+export function restoreForensicsToolScope(pi, scope) {
+    if (scope.toolsChanged)
+        pi.setActiveTools(scope.savedTools);
+}
+export function buildForensicsToolingSection(scope) {
+    const available = new Set(scope.availableFilingTools);
+    const requested = scope.availableFilingTools.length
+        ? scope.availableFilingTools.map((name) => `\`${name}\``).join(", ")
+        : "none";
+    const statusFor = (name) => available.has(name)
+        ? `- \`${name}\`: available for this queued forensics turn`
+        : `- \`${name}\`: unavailable in this host session`;
+    return `
+## Filing Tool Availability
+
+For this queued forensic turn, the extension requested the registered filing tools: ${requested}.
+
+${FORENSICS_FILING_TOOLS.map(statusFor).join("\n")}
+
+If \`bash\` is available, use the GitHub duplicate-check and issue-creation protocols below. If \`bash\` is unavailable, do not attempt duplicate-check or issue-creation tool calls with another tool; provide the paste-once shell script fallback instead.
+`;
+}
 // ─── Duplicate Detection ──────────────────────────────────────────────────────
 const DEDUP_PROMPT_SECTION = `
 ## Pre-Investigation: Duplicate Check (REQUIRED)
@@ -42,6 +104,8 @@ Before reading GSD source code or performing deep analysis, you MUST search for
 
 Use keywords from the user's problem description and the anomaly summaries in the forensic report above.
 
+If \`bash\` is unavailable in the Filing Tool Availability section, do not attempt live duplicate-search tool calls. Say the live duplicate search must be run by the user, continue the source investigation, and include the duplicate-search commands in the paste-once fallback when issue filing is accepted.
+
 1. **Search closed issues** for similar keywords:
    \`\`\`
    gh issue list --repo open-gsd/gsd-pi --state closed --search "<keywords from root cause>" --limit 20
@@ -151,16 +215,24 @@ export async function handleForensics(args, ctx, pi) {
             gsdSourceDir = fallback;
     }
     const forensicData = formatReportForPrompt(report);
+    const toolScope = createForensicsToolScope(pi);
     const content = loadPrompt("forensics", {
         problemDescription,
         forensicData,
         gsdSourceDir,
         dedupSection,
+        toolingSection: buildForensicsToolingSection(toolScope),
     });
     ctx.ui.notify(`Forensic report saved: ${relative(basePath, savedPath)}`, "info");
     ctx.ui.setStatus("gsd-forensics", "running");
-    pi.sendMessage({ customType: "gsd-forensics", content, display: false }, { triggerTurn: true });
-    ctx.ui.setStatus("gsd-forensics", undefined);
+    try {
+        applyForensicsToolScope(pi, toolScope);
+        await pi.sendMessage({ customType: "gsd-forensics", content, display: false }, { triggerTurn: true });
+    }
+    finally {
+        restoreForensicsToolScope(pi, toolScope);
+        ctx.ui.setStatus("gsd-forensics", undefined);
+    }
     // Persist forensics context so follow-up turns can re-inject it (#2941)
     writeForensicsMarker(basePath, savedPath, content);
 }

package/dist/resources/extensions/gsd/gsd-db.js

@@ -1290,7 +1290,7 @@ export function setTaskEscalationPending(milestoneId, sliceId, taskId, artifactP
            escalation_artifact_path = :path
      WHERE milestone_id = :mid AND slice_id = :sid AND id = :tid`).run({ ":path": artifactPath, ":mid": milestoneId, ":sid": sliceId, ":tid": taskId });
 }
-/** Set awaiting-review state (artifact exists but continueWithDefault=true, no pause). Mutually exclusive with pending. */
+/** Set awaiting-review state (artifact exists and requires explicit user review). Mutually exclusive with pending. */
 export function setTaskEscalationAwaitingReview(milestoneId, sliceId, taskId, artifactPath) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
@@ -2578,7 +2578,10 @@ export function decayMemoriesBefore(cutoffTs, now) {
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
     currentDb.prepare(`UPDATE memories
      SET confidence = MAX(0.1, confidence - 0.1), updated_at = :now
-     WHERE superseded_by IS NULL AND updated_at < :cutoff AND confidence > 0.1`).run({ ":now": now, ":cutoff": cutoffTs });
+     WHERE superseded_by IS NULL
+       AND updated_at < :cutoff
+       AND confidence > 0.1
+       AND (structured_fields IS NULL OR structured_fields NOT LIKE '%"sourceDecisionId"%')`).run({ ":now": now, ":cutoff": cutoffTs });
 }
 export function supersedeLowestRankedMemories(limit, now) {
     if (!currentDb)

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

@@ -115,15 +115,10 @@ async function runQuickTaskChoice(ctx, pi) {
 }
 async function dispatchDiscussForNextMilestoneWithBacklog(ctx, pi, basePath, nextId) {
     const backlogContext = buildRequirementsBacklogDiscussContext(nextId);
-    const discussMilestoneTemplates = inlineTemplate("context", "Context");
     const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-    const basePrompt = loadPrompt("guided-discuss-milestone", {
-        workingDirectory: basePath,
-        milestoneId: nextId,
-        milestoneTitle: `New milestone ${nextId}`,
-        inlinedTemplates: discussMilestoneTemplates,
-        structuredQuestionsAvailable,
+    const basePrompt = await buildDiscussMilestonePrompt(nextId, `New milestone ${nextId}`, basePath, structuredQuestionsAvailable, {
         commitInstruction: buildDocsCommitInstruction(`docs(${nextId}): milestone context from discuss`),
+        includeContextMode: false,
         fastPathInstruction: [
             "> **Requirements backlog active.**",
             "> Map unmapped active requirements to this milestone before finalizing context.",
@@ -1054,7 +1049,7 @@ function buildHeadlessDiscussPrompt(nextId, seedContext, _basePath) {
  * @param basePath - Root directory of the project
  * @returns The discuss prompt string
  */
-async function buildDiscussPreparationContext(ctx, basePath, mode = "greenfield") {
+async function buildDiscussPreparationContext(ctx, basePath, mode = "greenfield", skipPriorContext = false) {
     const prefs = loadEffectiveGSDPreferences()?.preferences ?? {};
     if (prefs.discuss_preparation === false)
         return "";
@@ -1071,7 +1066,7 @@ async function buildDiscussPreparationContext(ctx, basePath, mode = "greenfield"
         const parts = [];
         if (codebaseBrief)
             parts.push(`### Codebase Brief\n\n${codebaseBrief}`);
-        if (priorContextBrief)
+        if (priorContextBrief && !skipPriorContext)
             parts.push(`### Prior Context Brief\n\n${priorContextBrief}`);
         if (parts.length === 0)
             return "";
@@ -1103,17 +1098,11 @@ async function dispatchNewMilestoneDiscuss(ctx, pi, basePath, nextId, stepMode,
         await dispatchWorkflow(pi, prompt, "gsd-run", ctx, "discuss-milestone", { basePath });
         return;
     }
-    const preparationContext = await buildDiscussPreparationContext(ctx, basePath, "milestone");
-    const discussMilestoneTemplates = inlineTemplate("context", "Context");
+    const preparationContext = await buildDiscussPreparationContext(ctx, basePath, "milestone", true);
     const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-    let prompt = loadPrompt("guided-discuss-milestone", {
-        workingDirectory: basePath,
-        milestoneId: nextId,
-        milestoneTitle: `New milestone ${nextId}`,
-        inlinedTemplates: discussMilestoneTemplates,
-        structuredQuestionsAvailable,
+    let prompt = await buildDiscussMilestonePrompt(nextId, `New milestone ${nextId}`, basePath, structuredQuestionsAvailable, {
         commitInstruction: buildDocsCommitInstruction(`docs(${nextId}): milestone context from discuss`),
-        fastPathInstruction: "",
+        includeContextMode: false,
     });
     if (preparationContext)
         prompt += preparationContext;
@@ -1364,8 +1353,6 @@ export async function showDiscuss(ctx, pi, basePath, options) {
     // Special case: milestone is in needs-discussion phase (has CONTEXT-DRAFT.md but no roadmap yet).
     // Route to the draft discussion flow instead of erroring — the discussion IS how the roadmap gets created.
     if (state.phase === "needs-discussion") {
-        const draftFile = resolveMilestoneFile(basePath, mid, "CONTEXT-DRAFT");
-        const draftContent = draftFile ? await loadFile(draftFile) : null;
         const choice = await showNextAction(ctx, {
             title: `GSD — ${mid}: ${milestoneTitle}`,
             summary: ["This milestone has a draft context from a prior discussion.", "It needs a dedicated discussion before auto-planning can begin."],
@@ -1390,30 +1377,23 @@ export async function showDiscuss(ctx, pi, basePath, options) {
             notYetMessage: "Run /gsd discuss when ready to discuss this milestone.",
         });
         if (choice === "discuss_draft") {
-            const discussMilestoneTemplates = inlineTemplate("context", "Context");
             const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-            const basePrompt = loadPrompt("guided-discuss-milestone", {
-                workingDirectory: basePath,
-                milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
+            const seed = await buildDiscussMilestonePrompt(mid, milestoneTitle, basePath, structuredQuestionsAvailable, {
                 commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
-                fastPathInstruction: "",
+                includeContextMode: false,
             });
-            const seed = draftContent
-                ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
-                : basePrompt;
             setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: mid, step: true });
             await dispatchWorkflow(pi, seed, "gsd-discuss", ctx, "discuss-milestone", { basePath });
         }
         else if (choice === "discuss_fresh") {
-            const discussMilestoneTemplates = inlineTemplate("context", "Context");
             const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-            setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: mid, step: true });
-            await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
-                workingDirectory: basePath,
-                milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
+            const prompt = await buildDiscussMilestonePrompt(mid, milestoneTitle, basePath, structuredQuestionsAvailable, {
                 commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
-                fastPathInstruction: "",
-            }), "gsd-discuss", ctx, "discuss-milestone", { basePath });
+                includeContextMode: false,
+                includeDraftSeed: false,
+            });
+            setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: mid, step: true });
+            await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-milestone", { basePath });
         }
         else if (choice === "skip_milestone") {
             const { ensureDbOpen } = await import("./bootstrap/dynamic-tools.js");
@@ -1631,20 +1611,12 @@ async function dispatchDiscussForMilestone(ctx, pi, basePath, mid, milestoneTitl
             "> Ask only questions where the answer would materially change scope.",
         ].join("\n")
         : "";
-    const discussMilestoneTemplates = inlineTemplate("context", "Context");
     const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-    const basePrompt = loadPrompt("guided-discuss-milestone", {
-        workingDirectory: basePath,
-        milestoneId: mid,
-        milestoneTitle,
-        inlinedTemplates: discussMilestoneTemplates,
-        structuredQuestionsAvailable,
+    const prompt = await buildDiscussMilestonePrompt(mid, milestoneTitle, basePath, structuredQuestionsAvailable, {
         commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
+        includeContextMode: false,
         fastPathInstruction,
     });
-    const prompt = draftContent
-        ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
-        : basePrompt;
     await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-milestone", { basePath });
 }
 // ─── Smart Entry Point ────────────────────────────────────────────────────────
@@ -2122,8 +2094,6 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
     }
     // ── Draft milestone — needs discussion before planning ────────────────
     if (state.phase === "needs-discussion") {
-        const draftFile = resolveMilestoneFile(basePath, milestoneId, "CONTEXT-DRAFT");
-        const draftContent = draftFile ? await loadFile(draftFile) : null;
         const choice = await showNextAction(ctx, {
             title: `GSD — ${milestoneId}: ${milestoneTitle}`,
             summary: ["This milestone has a draft context from a prior discussion.", "It needs a dedicated discussion before auto-planning can begin."],
@@ -2148,30 +2118,23 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             notYetMessage: "Run /gsd when ready to discuss this milestone.",
         });
         if (choice === "discuss_draft") {
-            const discussMilestoneTemplates = inlineTemplate("context", "Context");
             const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-            const basePrompt = loadPrompt("guided-discuss-milestone", {
-                workingDirectory: basePath,
-                milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
+            const seed = await buildDiscussMilestonePrompt(milestoneId, milestoneTitle, basePath, structuredQuestionsAvailable, {
                 commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
-                fastPathInstruction: "",
+                includeContextMode: false,
             });
-            const seed = draftContent
-                ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
-                : basePrompt;
             setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId, step: stepMode });
             await dispatchWorkflow(pi, seed, "gsd-discuss", ctx, "discuss-milestone", { basePath });
         }
         else if (choice === "discuss_fresh") {
-            const discussMilestoneTemplates = inlineTemplate("context", "Context");
             const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-            setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId, step: stepMode });
-            await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
-                workingDirectory: basePath,
-                milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
+            const prompt = await buildDiscussMilestonePrompt(milestoneId, milestoneTitle, basePath, structuredQuestionsAvailable, {
                 commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
-                fastPathInstruction: "",
-            }), "gsd-discuss", ctx, "discuss-milestone", { basePath });
+                includeContextMode: false,
+                includeDraftSeed: false,
+            });
+            setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId, step: stepMode });
+            await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-milestone", { basePath });
         }
         else if (choice === "skip_milestone") {
             const milestoneIds = findMilestoneIds(basePath);
@@ -2279,14 +2242,12 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 await dispatchWorkflow(pi, await buildPlanMilestonePrompt(milestoneId, milestoneTitle, basePath), "gsd-run", ctx, "plan-milestone", { basePath });
             }
             else if (choice === "discuss") {
-                const discussMilestoneTemplates = inlineTemplate("context", "Context");
                 const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
-                await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
-                    workingDirectory: basePath,
-                    milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
+                const prompt = await buildDiscussMilestonePrompt(milestoneId, milestoneTitle, basePath, structuredQuestionsAvailable, {
                     commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
-                    fastPathInstruction: "",
-                }), "gsd-run", ctx, "discuss-milestone", { basePath });
+                    includeContextMode: false,
+                });
+                await dispatchWorkflow(pi, prompt, "gsd-run", ctx, "discuss-milestone", { basePath });
             }
             else if (choice === "skip_milestone") {
                 const milestoneIds = findMilestoneIds(basePath);

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

@@ -614,7 +614,10 @@ export function decayStaleMemories(thresholdUnits = 20) {
             return []; // not enough processed units yet
         const cutoff = row['processed_at'];
         const affected = adapter.prepare(`SELECT id FROM memories
-       WHERE superseded_by IS NULL AND updated_at < :cutoff AND confidence > 0.1`).all({ ':cutoff': cutoff }).map((r) => r['id']);
+       WHERE superseded_by IS NULL
+         AND updated_at < :cutoff
+         AND confidence > 0.1
+         AND (structured_fields IS NULL OR structured_fields NOT LIKE '%"sourceDecisionId"%')`).all({ ':cutoff': cutoff }).map((r) => r['id']);
         decayMemoriesBefore(cutoff, new Date().toISOString());
         return affected;
     }

package/dist/resources/extensions/gsd/post-unit-hooks.js

@@ -19,6 +19,15 @@ export function isRetryPending() {
 export function consumeRetryTrigger() {
     return getOrCreateRegistry().consumeRetryTrigger();
 }
+export function consumeHookFailure() {
+    return getOrCreateRegistry().consumeHookFailure();
+}
+export function isGateBlockPending() {
+    return getOrCreateRegistry().isGateBlockPending();
+}
+export function consumeGateBlock() {
+    return getOrCreateRegistry().consumeGateBlock();
+}
 export function resetHookState() {
     getOrCreateRegistry().resetState();
 }

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

@@ -15,6 +15,14 @@ const VALID_UOK_TURN_ACTIONS = new Set([
     "snapshot",
     "status-only",
 ]);
+const VALID_POST_UNIT_HOOK_CRITICALITIES = new Set(["advisory", "blocking"]);
+const VALID_POST_UNIT_HOOK_ON_BLOCK_ACTIONS = new Set([
+    "retry-unit",
+    "retry-task",
+    "queue-task",
+    "queue-slice",
+    "pause",
+]);
 export function validatePreferences(preferences) {
     const errors = [];
     const warnings = [];
@@ -474,9 +482,40 @@ export function validatePreferences(preferences) {
             if (typeof hook.artifact === "string" && hook.artifact.trim()) {
                 validHook.artifact = hook.artifact.trim();
             }
+            if (hook.criticality !== undefined) {
+                const criticality = typeof hook.criticality === "string" ? hook.criticality.trim() : "";
+                if (VALID_POST_UNIT_HOOK_CRITICALITIES.has(criticality)) {
+                    validHook.criticality = criticality;
+                }
+                else {
+                    errors.push(`post_unit_hooks "${name}" invalid criticality: ${String(hook.criticality)}`);
+                }
+            }
             if (typeof hook.retry_on === "string" && hook.retry_on.trim()) {
                 validHook.retry_on = hook.retry_on.trim();
             }
+            if (hook.on_block !== undefined) {
+                if (!hook.on_block || typeof hook.on_block !== "object") {
+                    errors.push(`post_unit_hooks "${name}" on_block must be an object`);
+                }
+                else {
+                    const onBlock = hook.on_block;
+                    const action = typeof onBlock.action === "string" ? onBlock.action.trim() : "";
+                    if (!VALID_POST_UNIT_HOOK_ON_BLOCK_ACTIONS.has(action)) {
+                        errors.push(`post_unit_hooks "${name}" invalid on_block action: ${String(onBlock.action)}`);
+                    }
+                    else {
+                        validHook.on_block = { action: action };
+                        if (typeof onBlock.artifact === "string" && onBlock.artifact.trim()) {
+                            validHook.on_block.artifact = onBlock.artifact.trim();
+                        }
+                    }
+                }
+            }
+            if (validHook.criticality === "blocking" && !validHook.artifact) {
+                errors.push(`post_unit_hooks "${name}" criticality blocking requires artifact`);
+                continue;
+            }
             if (typeof hook.agent === "string" && hook.agent.trim()) {
                 validHook.agent = hook.agent.trim();
             }

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

@@ -26,9 +26,16 @@ function hasRequiredExtensionAssets(rootDir, exists = existsSync) {
     return (exists(join(rootDir, "prompts")) &&
         exists(join(rootDir, "templates", "task-summary.md")));
 }
+function isSourceExtensionDir(moduleDir) {
+    return moduleDir.replaceAll("\\", "/").endsWith("/src/resources/extensions/gsd");
+}
 export function resolveExtensionDirFromCandidates(moduleDir, agentGsdDir, exists = existsSync) {
     const moduleUsable = hasRequiredExtensionAssets(moduleDir, exists);
     const agentUsable = hasRequiredExtensionAssets(agentGsdDir, exists);
+    // Source checkouts must use their own prompt tree. Otherwise local tests and
+    // dev runs can silently render stale prompts from ~/.gsd/agent/extensions/gsd.
+    if (moduleUsable && isSourceExtensionDir(moduleDir))
+        return moduleDir;
     // Prefer the user-local extension tree when both are valid. This avoids
     // leaking npm/global-install paths into prompts on Windows.
     if (agentUsable)