@opengsd/gsd-pi 1.1.1-dev.74e8dd1 → 1.1.1-dev.a5a2de8

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/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/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)