gsd-pi 2.81.0 → 2.82.0

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

@@ -1,12 +1,5 @@
-/**
- * GSD Parallel Monitor Overlay
- *
- * Full-screen TUI overlay showing real-time parallel worker progress.
- * 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.
- */
+// Project/App: GSD-2
+// File Purpose: Parallel worker monitor overlay with width-safe operations-console rendering.
 import { existsSync, statSync, readFileSync, openSync, readSync, closeSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { spawnSync } from "node:child_process";
@@ -14,6 +7,7 @@ import { matchesKey, Key } from "@gsd/pi-tui";
 import { formatDuration } from "../shared/mod.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
 import { resolveGsdPathContract } from "./paths.js";
+import { renderBar, renderKeyHints, renderProgressBar, safeLine, statusGlyph, } from "./tui/render-kit.js";
 // ─── Data Helpers ─────────────────────────────────────────────────────────
 function readJsonSafe(filePath) {
     try {
@@ -226,17 +220,6 @@ function unitTypeLabel(unitType) {
     };
     return labels[unitType || ""] || (unitType || "---").toUpperCase().slice(0, 5);
 }
-function progressBar(done, total, width) {
-    if (total === 0)
-        return "░".repeat(width);
-    const filled = Math.round((done / total) * width);
-    return "█".repeat(filled) + "░".repeat(width - filled);
-}
-function healthGlyph(alive, heartbeatAge) {
-    if (!alive)
-        return "○";
-    return "●";
-}
 // ─── Overlay Class ────────────────────────────────────────────────────────
 export class ParallelMonitorOverlay {
     tui;
@@ -247,6 +230,7 @@ export class ParallelMonitorOverlay {
     workers = [];
     events = [];
     cachedLines;
+    cachedWidth;
     scrollOffset = 0;
     disposed = false;
     resizeHandler = null;
@@ -279,6 +263,7 @@ export class ParallelMonitorOverlay {
         }
         this.events = this.events.slice(-10);
         this.cachedLines = undefined;
+        this.cachedWidth = undefined;
         this.tui.requestRender();
     }
     dispose() {
@@ -313,13 +298,14 @@ export class ParallelMonitorOverlay {
     }
     invalidate() {
         this.cachedLines = undefined;
+        this.cachedWidth = undefined;
     }
     render(width) {
-        if (this.cachedLines)
+        if (this.cachedLines && this.cachedWidth === width)
             return this.cachedLines;
         const t = this.theme;
         const lines = [];
-        const w = Math.max(width, 60);
+        const w = Math.max(1, width);
         // Header
         const totalCost = this.workers.reduce((s, wk) => s + wk.cost, 0);
         const aliveCount = this.workers.filter((wk) => wk.alive).length;
@@ -328,7 +314,7 @@ export class ParallelMonitorOverlay {
         lines.push(t.fg("muted", `  ${now}  │  ${aliveCount}/${this.workers.length} alive  │  Total: `) +
             t.bold(`$${totalCost.toFixed(2)}`) +
             t.fg("muted", "  │  5s refresh"));
-        lines.push(t.fg("muted", "─".repeat(w)));
+        lines.push(renderBar(t, w));
         if (this.workers.length === 0) {
             lines.push("");
             lines.push(t.fg("warning", "  No parallel workers found."));
@@ -339,7 +325,7 @@ export class ParallelMonitorOverlay {
                 lines.push("");
                 // Health + ID + state
                 const healthColor = wk.alive ? "success" : "error";
-                const glyph = healthGlyph(wk.alive, wk.heartbeatAge);
+                const glyph = statusGlyph(t, wk.alive ? "active" : "idle");
                 const stateText = wk.alive
                     ? t.fg("success", "RUNNING")
                     : t.fg("error", t.bold("DEAD"));
@@ -374,21 +360,25 @@ export class ParallelMonitorOverlay {
                     });
                     lines.push(`     ${t.fg("muted", "slices")}  ${chips.join("  ")}`);
                     // Task progress bar
-                    const bar = progressBar(wk.doneTasks, wk.totalTasks, 25);
+                    const barWidth = Math.max(6, Math.min(25, w - 32));
+                    const bar = renderProgressBar(t, wk.doneTasks, wk.totalTasks, barWidth, {
+                        filledChar: "█",
+                        emptyChar: "░",
+                        emptyColor: "dim",
+                    });
                     const pct = wk.totalTasks > 0 ? Math.round((wk.doneTasks / wk.totalTasks) * 100) : 0;
-                    lines.push(`     ${t.fg("muted", "tasks")}   ${t.fg("success", bar)}  ${wk.doneTasks}/${wk.totalTasks} ` +
+                    lines.push(`     ${t.fg("muted", "tasks")}   ${bar}  ${wk.doneTasks}/${wk.totalTasks} ` +
                         t.fg("muted", `(${pct}%)  │  slices done ${wk.doneSlices}/${wk.totalSlices}`));
                 }
                 // Errors
                 for (const err of wk.errors.slice(-2)) {
-                    const truncated = err.length > w - 10 ? err.slice(0, w - 11) + "…" : err;
-                    lines.push(`     ${t.fg("error", "⚠ " + truncated)}`);
+                    lines.push(`     ${t.fg("error", "! " + err)}`);
                 }
             }
         }
         // Event feed
         lines.push("");
-        lines.push(t.fg("muted", "─".repeat(w)));
+        lines.push(renderBar(t, w));
         lines.push(`  ${t.bold("Recent Events")}`);
         if (this.events.length === 0) {
             lines.push(t.fg("muted", "  No events yet..."));
@@ -396,8 +386,7 @@ export class ParallelMonitorOverlay {
         else {
             for (const evt of this.events.slice(-8)) {
                 const mid = evt.match(/^✓ (M\d+)\//)?.[1] || "";
-                const truncated = evt.length > w - 10 ? evt.slice(0, w - 11) + "…" : evt;
-                lines.push(`  ${t.fg("muted", "│")} ${t.fg("accent", mid)} ${truncated.replace(/^✓ M\d+\//, "")}`);
+                lines.push(`  ${t.fg("muted", "│")} ${t.fg("accent", mid)} ${evt.replace(/^✓ M\d+\//, "")}`);
             }
         }
         // Footer
@@ -411,13 +400,16 @@ 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/${formattedShortcutPair("parallel")} close  │  ↑↓ scroll`));
+        lines.push(renderKeyHints(t, [`ESC/q/${formattedShortcutPair("parallel")} close`, "↑↓ scroll"], w));
         // Apply scroll — use terminal rows as height estimate
         const termHeight = process.stdout.rows || 40;
         const maxScroll = Math.max(0, lines.length - termHeight);
         this.scrollOffset = Math.min(Math.max(this.scrollOffset, 0), maxScroll);
-        const visible = lines.slice(this.scrollOffset, this.scrollOffset + termHeight);
+        const visible = lines
+            .slice(this.scrollOffset, this.scrollOffset + termHeight)
+            .map((line) => safeLine(line, w));
         this.cachedLines = visible;
+        this.cachedWidth = width;
         return visible;
     }
 }

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

@@ -22,22 +22,24 @@ Use `subagent` only for fresh-context review when useful: reviewer for cross-cut
 
 1. Use the inlined Slice Summary and UAT templates.
 2. {{skillActivation}}
-3. Run all slice-level verification checks from the slice plan. Fix failures before marking done; refresh current state if needed.
-4. Task summaries use a flat file layout under `tasks/` such as `T01-SUMMARY.md`, not inside per-task subdirectories like `tasks/T01/SUMMARY.md`. Never use `tasks/*/SUMMARY.md`.
-5. If observability/diagnostics were planned, verify them unless the slice is simple.
-6. Address every gate in Gates to Close. Q8 maps to **Operational Readiness**: health signal, failure signal, recovery procedure, monitoring gaps. Empty sections are recorded as omitted.
-7. If requirement status changed, call `gsd_requirement_update`; do not write `.gsd/REQUIREMENTS.md` directly.
-8. Prepare `gsd_slice_complete` content with camelCase fields `milestoneId`, `sliceId`, `sliceTitle`, `oneLiner`, `narrative`, `verification`, and `uatContent`.
-9. Draft concrete UAT with preconditions, numbered steps, expected outcomes, edge cases, UAT Type, and Not Proven By This UAT.
-10. Review the inlined task-summary excerpts for DECISIONS.md and KNOWLEDGE.md-worthy decisions, patterns, and gotchas. Read full `*-SUMMARY.md` files only when an excerpt is absent, truncated, or lacks the specific evidence needed for the slice narrative. Capture significant items with `capture_thought`; do not append knowledge files directly.
-11. Call `gsd_slice_complete`. The DB-backed tool is the canonical write path. Do **not** manually write `{{sliceSummaryPath}}`. Do **not** manually write `{{sliceUatPath}}`. Do not edit roadmap checkboxes; the tool renders files and updates projections.
-12. Do not run git commands.
-13. Update `.gsd/PROJECT.md` with a full `write` only if the current project state needs refresh.
+3. Run all slice-level verification checks from the slice plan through the closeout-safe verification surface (`gsd_exec` / Context Mode verification evidence); refresh current state if needed. Do not use direct `bash` for verification commands.
+4. Complete the slice only when every required verification check passes. If verification fails or the fix requires source changes, do **not** edit source files in this unit and do **not** call `gsd_slice_complete`.
+5. For task-specific failures, call `gsd_task_reopen` with the failing completed task and a concrete reason so execution can redo the work. For plan-invalidating failures, call `gsd_replan_slice` with the blocker and updated execution tasks. Then stop with: "Slice {{sliceId}} needs execution follow-up."
+6. Task summaries use a flat file layout under `tasks/` such as `T01-SUMMARY.md`, not inside per-task subdirectories like `tasks/T01/SUMMARY.md`. Never use `tasks/*/SUMMARY.md`.
+7. If observability/diagnostics were planned, verify them unless the slice is simple.
+8. Address every gate in Gates to Close. Q8 maps to **Operational Readiness**: health signal, failure signal, recovery procedure, monitoring gaps. Empty sections are recorded as omitted.
+9. If requirement status changed, call `gsd_requirement_update`; do not write `.gsd/REQUIREMENTS.md` directly.
+10. Prepare `gsd_slice_complete` content with camelCase fields `milestoneId`, `sliceId`, `sliceTitle`, `oneLiner`, `narrative`, `verification`, and `uatContent`.
+11. Draft concrete UAT with preconditions, numbered steps, expected outcomes, edge cases, UAT Type, and Not Proven By This UAT.
+12. Review the inlined task-summary excerpts for DECISIONS.md and KNOWLEDGE.md-worthy decisions, patterns, and gotchas. Read full `*-SUMMARY.md` files only when an excerpt is absent, truncated, or lacks the specific evidence needed for the slice narrative. Capture significant items with `capture_thought`; do not append knowledge files directly.
+13. When verification passes, call `gsd_slice_complete`. The DB-backed tool is the canonical write path. Do **not** manually write `{{sliceSummaryPath}}`. Do **not** manually write `{{sliceUatPath}}`. Do not edit roadmap checkboxes; the tool renders files and updates projections.
+14. Do not run git commands.
+15. Update `.gsd/PROJECT.md` with a full `write` only if the current project state needs refresh.
 
 **Autonomous execution:** no human is available. Do not call `ask_user_questions` or `secure_env_collect`; make reasonable assumptions and document them.
 
 **File system safety:** if re-reading task summaries, use `find .gsd/milestones/{{milestoneId}}/slices/{{sliceId}}/tasks -name "*-SUMMARY.md"` or `ls .gsd/milestones/{{milestoneId}}/slices/{{sliceId}}/tasks/*-SUMMARY.md`. Never pass `{{slicePath}}` or any directory path directly to the `read` tool.
 
-**You MUST call `gsd_slice_complete` with summary and UAT content before finishing.**
+**You MUST call `gsd_slice_complete` with summary and UAT content before finishing only after verification passes.**
 
 When done, say: "Slice {{sliceId}} complete."

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

@@ -129,7 +129,16 @@ If ANY box is unchecked, **STOP**. Do NOT emit the ready phrase. Emit the missin
 
 Do not announce the ready phrase as something you are "about to" do. The ready phrase is a post-write signal, not an intent signal.
 
-After completing steps 1–7 above, say exactly: "Milestone {{milestoneId}} ready." — nothing else. Auto-mode will start automatically.
+After completing steps 1–7 above, end with this concise user-facing handoff:
+
+```
+Milestone {{milestoneId}} ready.
+
+Next steps:
+- Run `/gsd auto` to start execution if it does not begin automatically.
+- Use `/gsd status` or `/gsd visualize` to inspect the roadmap.
+- Use `/gsd notifications` to review or configure delivery alerts.
+```
 
 ### Multi-Milestone
 
@@ -215,7 +224,16 @@ If ANY box is unchecked, **STOP**. Do NOT emit the ready phrase. Emit the missin
 
 Do not announce the ready phrase as something you are "about to" do. The ready phrase is a post-write signal, not an intent signal.
 
-After completing every step above, say exactly: "Milestone {{milestoneId}} ready." — nothing else. Auto-mode will start automatically.
+After completing every step above, end with this concise user-facing handoff:
+
+```
+Milestone {{milestoneId}} ready.
+
+Next steps:
+- Run `/gsd auto` to start execution if it does not begin automatically.
+- Use `/gsd status` or `/gsd visualize` to inspect the roadmap.
+- Use `/gsd notifications` to review or configure delivery alerts.
+```
 
 ## Critical Rules
 

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

@@ -252,7 +252,16 @@ If ANY box is unchecked, **STOP**. Do NOT emit the ready phrase. Emit the missin
 
 Do not announce the ready phrase as something you are "about to" do. It is a post-write signal, not intent.
 
-After completing steps 1–7 above, say exactly: "Milestone {{milestoneId}} ready." — nothing else. Auto-mode will start automatically.
+After completing steps 1–7 above, end with this concise user-facing handoff:
+
+```
+Milestone {{milestoneId}} ready.
+
+Next steps:
+- Run `/gsd auto` to start execution if it does not begin automatically.
+- Use `/gsd status` or `/gsd visualize` to inspect the roadmap.
+- Use `/gsd notifications` to review or configure delivery alerts.
+```
 
 ### Multi-Milestone
 
@@ -345,6 +354,15 @@ If ANY box is unchecked, **STOP**. Do NOT emit the ready phrase. Emit the missin
 
 Do not announce the ready phrase as something you are "about to" do. It is a post-write signal, not intent.
 
-After completing all phases above, say exactly: "Milestone M001 ready." — nothing else. Auto-mode will start automatically.
+After completing all phases above, end with this concise user-facing handoff:
+
+```
+Milestone M001 ready.
+
+Next steps:
+- Run `/gsd auto` to start execution if it does not begin automatically.
+- Use `/gsd status` or `/gsd visualize` to inspect the roadmap.
+- Use `/gsd notifications` to review or configure delivery alerts.
+```
 
 {{inlinedTemplates}}

package/dist/resources/extensions/gsd/recovery-classification.js

@@ -1,9 +1,15 @@
 // Project/App: GSD-2
 // File Purpose: ADR-015 Recovery Classification module for runtime failure taxonomy.
 import { classifyError, isTransient } from "./error-classifier.js";
+import { ReconciliationFailedError } from "./state-reconciliation.js";
 export function classifyFailure(input) {
     const message = errorMessage(input.error);
-    const failureKind = input.failureKind ?? inferFailureKind(message);
+    // ADR-017: ReconciliationFailedError is a typed throw from the State
+    // Reconciliation Module. Recognize it by class regardless of caller-supplied
+    // failureKind so the taxonomy stays consistent.
+    const failureKind = input.error instanceof ReconciliationFailedError
+        ? "reconciliation-drift"
+        : input.failureKind ?? inferFailureKind(message);
     switch (failureKind) {
         case "tool-schema":
             return {
@@ -45,6 +51,14 @@ export function classifyFailure(input) {
                 exitReason: "verification-drift",
                 remediation: "Inspect the verification artifact and reconcile the state snapshot before resuming.",
             };
+        case "reconciliation-drift":
+            return {
+                failureKind,
+                action: "escalate",
+                reason: `Reconciliation drift${unitSuffix(input)}: ${message}`,
+                exitReason: "reconciliation-drift",
+                remediation: "Inspect the persistent or repair-failed drift kinds reported by the State Reconciliation Module before resuming.",
+            };
         case "provider": {
             const providerClass = classifyError(message, input.retryAfterMs);
             return {

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

@@ -521,6 +521,46 @@ export function readSessionLockData(basePath) {
 export function isSessionLockProcessAlive(data) {
     return isPidAlive(data.pid);
 }
+/**
+ * ADR-017 raw primitive: remove orphaned lock artifacts (lock dir + lock file)
+ * when the recorded PID is dead or no metadata is present. Mirrors the
+ * pre-flight cleanup logic in acquireSessionLock so the stale-worker drift
+ * handler can clear the orphan proactively without going through the full
+ * acquire path. No-op when the lock is held by an alive process.
+ *
+ * Returns true when artifacts were removed (drift was present).
+ */
+export function removeStaleSessionLock(basePath) {
+    const lp = lockPath(basePath);
+    const gsdDir = gsdRoot(basePath);
+    const lockTarget = effectiveLockTarget(gsdDir);
+    const lockDir = lockTarget + ".lock";
+    const existingData = readExistingLockData(lp);
+    const isOrphan = !existingData ||
+        (typeof existingData.pid === "number" && !isPidAlive(existingData.pid));
+    if (!isOrphan)
+        return false;
+    let removed = false;
+    if (existsSync(lockDir)) {
+        try {
+            rmSync(lockDir, { recursive: true, force: true });
+            removed = true;
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    if (existsSync(lp)) {
+        try {
+            unlinkSync(lp);
+            removed = true;
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    return removed;
+}
 /**
  * Returns true if we currently hold a session lock for the given path.
  */

package/dist/resources/extensions/gsd/state-reconciliation/drift/completion.js

@@ -0,0 +1,131 @@
+// Project/App: GSD-2
+// File Purpose: ADR-017 missing-completion-timestamp drift handler. Detects
+// tasks/slices/milestones marked complete (status = 'complete' | 'done') in
+// the DB but whose `completed_at` column is null, and where the on-disk
+// SUMMARY.md attests to completion. Backfills `completed_at` from the
+// SUMMARY.md mtime — deterministic and idempotent (re-running yields the
+// same value).
+import { existsSync, statSync } from "node:fs";
+import { getMilestone, getMilestoneSlices, getSliceTasks, isDbAvailable, updateMilestoneStatus, updateSliceStatus, updateTaskStatus, } from "../../gsd-db.js";
+import { resolveMilestoneFile, resolveSliceFile, resolveTaskFile, } from "../../paths.js";
+const COMPLETE_STATUSES = new Set(["complete", "done"]);
+function summaryMtimeIso(path) {
+    try {
+        return statSync(path).mtime.toISOString();
+    }
+    catch {
+        return null;
+    }
+}
+export function detectMissingCompletionTimestampDrift(state, ctx) {
+    if (!isDbAvailable())
+        return [];
+    const mid = state.activeMilestone?.id;
+    if (!mid)
+        return [];
+    const milestone = getMilestone(mid);
+    if (!milestone)
+        return [];
+    const drifts = [];
+    // Milestone-level
+    if (COMPLETE_STATUSES.has(milestone.status) &&
+        milestone.completed_at === null) {
+        const summary = resolveMilestoneFile(ctx.basePath, mid, "SUMMARY");
+        if (summary && existsSync(summary)) {
+            drifts.push({
+                kind: "missing-completion-timestamp",
+                entity: "milestone",
+                ids: [mid],
+            });
+        }
+    }
+    // Slice and task levels iterate independently — tasks can complete before
+    // the parent slice closes, so task drift must be checked even when the
+    // slice is still pending.
+    for (const slice of getMilestoneSlices(mid)) {
+        if (COMPLETE_STATUSES.has(slice.status) &&
+            slice.completed_at === null) {
+            const summary = resolveSliceFile(ctx.basePath, mid, slice.id, "SUMMARY");
+            if (summary && existsSync(summary)) {
+                drifts.push({
+                    kind: "missing-completion-timestamp",
+                    entity: "slice",
+                    ids: [`${mid}/${slice.id}`],
+                });
+            }
+        }
+        for (const task of getSliceTasks(mid, slice.id)) {
+            if (!COMPLETE_STATUSES.has(task.status))
+                continue;
+            if (task.completed_at !== null)
+                continue;
+            const taskSummary = resolveTaskFile(ctx.basePath, mid, slice.id, task.id, "SUMMARY");
+            if (taskSummary && existsSync(taskSummary)) {
+                drifts.push({
+                    kind: "missing-completion-timestamp",
+                    entity: "task",
+                    ids: [`${mid}/${slice.id}/${task.id}`],
+                });
+            }
+        }
+    }
+    return drifts;
+}
+export function repairMissingCompletionTimestamp(record, ctx) {
+    const composite = record.ids[0];
+    if (!composite)
+        return;
+    const parts = composite.split("/");
+    if (record.entity === "milestone") {
+        const [mid] = parts;
+        if (!mid)
+            return;
+        const milestone = getMilestone(mid);
+        if (!milestone ||
+            milestone.completed_at !== null ||
+            !COMPLETE_STATUSES.has(milestone.status))
+            return;
+        const summary = resolveMilestoneFile(ctx.basePath, mid, "SUMMARY");
+        const ts = summary ? summaryMtimeIso(summary) : null;
+        if (!ts)
+            return;
+        updateMilestoneStatus(mid, milestone.status, ts);
+        return;
+    }
+    if (record.entity === "slice") {
+        const [mid, sid] = parts;
+        if (!mid || !sid)
+            return;
+        const slice = getMilestoneSlices(mid).find((s) => s.id === sid);
+        if (!slice ||
+            slice.completed_at !== null ||
+            !COMPLETE_STATUSES.has(slice.status))
+            return;
+        const summary = resolveSliceFile(ctx.basePath, mid, sid, "SUMMARY");
+        const ts = summary ? summaryMtimeIso(summary) : null;
+        if (!ts)
+            return;
+        updateSliceStatus(mid, sid, slice.status, ts);
+        return;
+    }
+    if (record.entity === "task") {
+        const [mid, sid, tid] = parts;
+        if (!mid || !sid || !tid)
+            return;
+        const task = getSliceTasks(mid, sid).find((t) => t.id === tid);
+        if (!task ||
+            task.completed_at !== null ||
+            !COMPLETE_STATUSES.has(task.status))
+            return;
+        const summary = resolveTaskFile(ctx.basePath, mid, sid, tid, "SUMMARY");
+        const ts = summary ? summaryMtimeIso(summary) : null;
+        if (!ts)
+            return;
+        updateTaskStatus(mid, sid, tid, task.status, ts);
+    }
+}
+export const completionTimestampHandler = {
+    kind: "missing-completion-timestamp",
+    detect: detectMissingCompletionTimestampDrift,
+    repair: repairMissingCompletionTimestamp,
+};