gsd-pi 2.63.0 → 2.64.0-dev.1a85e85

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

@@ -402,6 +402,23 @@ export async function saveDecisionToDb(fields, basePath) {
             adapter?.prepare('DELETE FROM decisions WHERE id = :id').run({ ':id': id });
             throw diskErr;
         }
+        // #2661: When a decision defers a slice, update the slice status in the DB
+        // so the dispatcher skips it. Without this, STATE.md and DECISIONS.md are
+        // in split-brain: the decision says "deferred" but the state still says
+        // "active", causing auto-mode to keep dispatching the deferred work.
+        try {
+            const sliceRef = extractDeferredSliceRef(fields);
+            if (sliceRef) {
+                db.updateSliceStatus(sliceRef.milestoneId, sliceRef.sliceId, 'deferred');
+            }
+        }
+        catch (deferErr) {
+            // Non-fatal — log but don't fail the decision save
+            logError('manifest', 'failed to update deferred slice status', {
+                fn: 'saveDecisionToDb',
+                error: String(deferErr.message),
+            });
+        }
         // Invalidate file-read caches so deriveState() sees the updated markdown.
         // Do NOT clear the artifacts table — we just wrote to it intentionally.
         invalidateStateCache();
@@ -414,6 +431,33 @@ export async function saveDecisionToDb(fields, basePath) {
         throw err;
     }
 }
+/**
+ * Extract a milestone/slice reference from a deferral decision.
+ *
+ * Detects deferrals by checking:
+ *   - scope contains "defer" (e.g., "deferral", "defer")
+ *   - choice or decision contains "defer" + an M###/S## pattern
+ *
+ * Returns { milestoneId, sliceId } if found, null otherwise.
+ */
+export function extractDeferredSliceRef(fields) {
+    const isDeferral = /\bdefer(?:ral|red|ring|s)?\b/i.test(fields.scope) ||
+        /\bdefer(?:ral|red|ring|s)?\b/i.test(fields.choice) ||
+        /\bdefer(?:ral|red|ring|s)?\b/i.test(fields.decision);
+    if (!isDeferral)
+        return null;
+    // Look for M###/S## pattern in choice first, then decision
+    const slicePattern = /\b(M\d{3,4})\/(S\d{2,3})\b/;
+    const choiceMatch = fields.choice.match(slicePattern);
+    if (choiceMatch) {
+        return { milestoneId: choiceMatch[1], sliceId: choiceMatch[2] };
+    }
+    const decisionMatch = fields.decision.match(slicePattern);
+    if (decisionMatch) {
+        return { milestoneId: decisionMatch[1], sliceId: decisionMatch[2] };
+    }
+    return null;
+}
 // ─── Update Requirement in DB + Regenerate Markdown ───────────────────────
 /**
  * Update a requirement in DB and regenerate REQUIREMENTS.md.
@@ -422,10 +466,34 @@ export async function saveDecisionToDb(fields, basePath) {
 export async function updateRequirementInDb(id, updates, basePath) {
     try {
         const db = await import('./gsd-db.js');
-        const existing = db.getRequirementById(id);
-        // If requirement doesn't exist in DB, create a skeleton and merge updates.
-        // This handles the case where requirements were written to REQUIREMENTS.md
-        // but never imported into the database (see #2919).
+        let existing = db.getRequirementById(id);
+        // If requirement doesn't exist in DB, seed the entire requirements table
+        // from REQUIREMENTS.md first (#3346). This handles the standard workflow
+        // where requirements are authored in markdown during discussion but never
+        // imported into the database — making gsd_requirement_update always fail
+        // with "not_found" at milestone completion.
+        if (!existing) {
+            const reqFilePath = resolveGsdRootFile(basePath, 'REQUIREMENTS');
+            try {
+                const content = readFileSync(reqFilePath, 'utf-8');
+                const { parseRequirementsSections } = await import('./md-importer.js');
+                const parsed = parseRequirementsSections(content);
+                if (parsed.length > 0) {
+                    logWarning('manifest', `Seeding ${parsed.length} requirements from REQUIREMENTS.md into DB (first update triggers import)`, { fn: 'updateRequirementInDb' });
+                    for (const req of parsed) {
+                        // Only seed if not already in DB (avoid overwriting concurrent inserts)
+                        if (!db.getRequirementById(req.id)) {
+                            db.upsertRequirement(req);
+                        }
+                    }
+                    // Re-check after seeding
+                    existing = db.getRequirementById(id);
+                }
+            }
+            catch {
+                // REQUIREMENTS.md missing or unparseable — fall through to skeleton
+            }
+        }
         const base = existing ?? {
             id,
             class: '',

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

@@ -498,13 +498,29 @@ function getDbCompletionCounts() {
     };
 }
 // ─── Anomaly Detectors ───────────────────────────────────────────────────────
-function detectStuckLoops(units, anomalies) {
-    const counts = new Map();
+/**
+ * Detect units that were dispatched multiple times (stuck in a loop).
+ *
+ * Counts distinct dispatches by grouping on (type, id, startedAt) first to
+ * collapse idle-watchdog duplicate snapshots (#1943), then counts unique
+ * startedAt values per type/id to determine actual dispatch count.
+ *
+ * Exported for testability.
+ */
+export function detectStuckLoops(units, anomalies) {
+    // First, collect unique startedAt values per type/id key
+    const dispatchMap = new Map();
     for (const u of units) {
         const key = `${u.type}/${u.id}`;
-        counts.set(key, (counts.get(key) ?? 0) + 1);
+        let starts = dispatchMap.get(key);
+        if (!starts) {
+            starts = new Set();
+            dispatchMap.set(key, starts);
+        }
+        starts.add(u.startedAt);
     }
-    for (const [key, count] of counts) {
+    for (const [key, starts] of dispatchMap) {
+        const count = starts.size;
         if (count > 1) {
             const [unitType, ...idParts] = key.split("/");
             anomalies.push({

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

@@ -1023,11 +1023,12 @@ export function insertMilestone(m) {
         ":boundary_map_markdown": m.planning?.boundaryMapMarkdown ?? "",
     });
 }
-export function upsertMilestonePlanning(milestoneId, planning, title) {
+export function upsertMilestonePlanning(milestoneId, planning) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
     currentDb.prepare(`UPDATE milestones SET
-      title = COALESCE(:title, title),
+      title = COALESCE(NULLIF(:title, ''), title),
+      status = COALESCE(NULLIF(:status, ''), status),
       vision = COALESCE(:vision, vision),
       success_criteria = COALESCE(:success_criteria, success_criteria),
       key_risks = COALESCE(:key_risks, key_risks),
@@ -1041,7 +1042,8 @@ export function upsertMilestonePlanning(milestoneId, planning, title) {
       boundary_map_markdown = COALESCE(:boundary_map_markdown, boundary_map_markdown)
      WHERE id = :id`).run({
         ":id": milestoneId,
-        ":title": title ?? null,
+        ":title": planning.title ?? "",
+        ":status": planning.status ?? "",
         ":vision": planning.vision ?? null,
         ":success_criteria": planning.successCriteria ? JSON.stringify(planning.successCriteria) : null,
         ":key_risks": planning.keyRisks ? JSON.stringify(planning.keyRisks) : null,
@@ -1058,13 +1060,25 @@ export function upsertMilestonePlanning(milestoneId, planning, title) {
 export function insertSlice(s) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
-    currentDb.prepare(`INSERT OR IGNORE INTO slices (
+    currentDb.prepare(`INSERT INTO slices (
       milestone_id, id, title, status, risk, depends, demo, created_at,
       goal, success_criteria, proof_level, integration_closure, observability_impact, sequence
     ) VALUES (
       :milestone_id, :id, :title, :status, :risk, :depends, :demo, :created_at,
       :goal, :success_criteria, :proof_level, :integration_closure, :observability_impact, :sequence
-    )`).run({
+    )
+    ON CONFLICT (milestone_id, id) DO UPDATE SET
+      title = CASE WHEN :raw_title IS NOT NULL THEN excluded.title ELSE slices.title END,
+      status = CASE WHEN slices.status IN ('complete', 'done') THEN slices.status ELSE excluded.status END,
+      risk = CASE WHEN :raw_risk IS NOT NULL THEN excluded.risk ELSE slices.risk END,
+      depends = excluded.depends,
+      demo = CASE WHEN :raw_demo IS NOT NULL THEN excluded.demo ELSE slices.demo END,
+      goal = CASE WHEN :raw_goal IS NOT NULL THEN excluded.goal ELSE slices.goal END,
+      success_criteria = CASE WHEN :raw_success_criteria IS NOT NULL THEN excluded.success_criteria ELSE slices.success_criteria END,
+      proof_level = CASE WHEN :raw_proof_level IS NOT NULL THEN excluded.proof_level ELSE slices.proof_level END,
+      integration_closure = CASE WHEN :raw_integration_closure IS NOT NULL THEN excluded.integration_closure ELSE slices.integration_closure END,
+      observability_impact = CASE WHEN :raw_observability_impact IS NOT NULL THEN excluded.observability_impact ELSE slices.observability_impact END,
+      sequence = CASE WHEN :raw_sequence IS NOT NULL THEN excluded.sequence ELSE slices.sequence END`).run({
         ":milestone_id": s.milestoneId,
         ":id": s.id,
         ":title": s.title ?? "",
@@ -1079,6 +1093,16 @@ export function insertSlice(s) {
         ":integration_closure": s.planning?.integrationClosure ?? "",
         ":observability_impact": s.planning?.observabilityImpact ?? "",
         ":sequence": s.sequence ?? 0,
+        // Raw sentinel params: NULL when caller omitted the field, used in ON CONFLICT guards
+        ":raw_title": s.title ?? null,
+        ":raw_risk": s.risk ?? null,
+        ":raw_demo": s.demo ?? null,
+        ":raw_goal": s.planning?.goal ?? null,
+        ":raw_success_criteria": s.planning?.successCriteria ?? null,
+        ":raw_proof_level": s.planning?.proofLevel ?? null,
+        ":raw_integration_closure": s.planning?.integrationClosure ?? null,
+        ":raw_observability_impact": s.planning?.observabilityImpact ?? null,
+        ":raw_sequence": s.sequence ?? null,
     });
 }
 export function upsertSlicePlanning(milestoneId, sliceId, planning) {
@@ -1574,19 +1598,31 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
                  definition_of_done, requirement_coverage, boundary_map_markdown
           FROM wt.milestones
         `).run());
-                // Merge slices — preserve worktree progress (status, summaries, planning)
+                // Merge slices — preserve worktree progress but never downgrade completed status (#2558).
+                // Uses INSERT OR REPLACE with a subquery that picks the best status — if the main DB
+                // already has a completed slice, keep that status even if the worktree copy is stale.
                 merged.slices = countChanges(adapter.prepare(`
           INSERT OR REPLACE INTO slices (
             milestone_id, id, title, status, risk, depends, demo, created_at, completed_at,
             full_summary_md, full_uat_md, goal, success_criteria, proof_level,
             integration_closure, observability_impact, sequence, replan_triggered_at
           )
-          SELECT milestone_id, id, title, status, risk, depends, demo, created_at, completed_at,
-                 full_summary_md, full_uat_md, goal, success_criteria, proof_level,
-                 integration_closure, observability_impact, sequence, replan_triggered_at
-          FROM wt.slices
+          SELECT w.milestone_id, w.id, w.title,
+                 CASE
+                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   THEN m.status ELSE w.status
+                 END,
+                 w.risk, w.depends, w.demo, w.created_at,
+                 CASE
+                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   THEN m.completed_at ELSE w.completed_at
+                 END,
+                 w.full_summary_md, w.full_uat_md, w.goal, w.success_criteria, w.proof_level,
+                 w.integration_closure, w.observability_impact, w.sequence, w.replan_triggered_at
+          FROM wt.slices w
+          LEFT JOIN slices m ON m.milestone_id = w.milestone_id AND m.id = w.id
         `).run());
-                // Merge tasks — preserve execution results, status, summaries
+                // Merge tasks — preserve execution results, never downgrade completed status (#2558)
                 merged.tasks = countChanges(adapter.prepare(`
           INSERT OR REPLACE INTO tasks (
             milestone_id, slice_id, id, title, status, one_liner, narrative,
@@ -1595,12 +1631,23 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
             description, estimate, files, verify, inputs, expected_output,
             observability_impact, full_plan_md, sequence
           )
-          SELECT milestone_id, slice_id, id, title, status, one_liner, narrative,
-                 verification_result, duration, completed_at, blocker_discovered,
-                 deviations, known_issues, key_files, key_decisions, full_summary_md,
-                 description, estimate, files, verify, inputs, expected_output,
-                 observability_impact, full_plan_md, sequence
-          FROM wt.tasks
+          SELECT w.milestone_id, w.slice_id, w.id, w.title,
+                 CASE
+                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   THEN m.status ELSE w.status
+                 END,
+                 w.one_liner, w.narrative,
+                 w.verification_result, w.duration,
+                 CASE
+                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   THEN m.completed_at ELSE w.completed_at
+                 END,
+                 w.blocker_discovered,
+                 w.deviations, w.known_issues, w.key_files, w.key_decisions, w.full_summary_md,
+                 w.description, w.estimate, w.files, w.verify, w.inputs, w.expected_output,
+                 w.observability_impact, w.full_plan_md, w.sequence
+          FROM wt.tasks w
+          LEFT JOIN tasks m ON m.milestone_id = w.milestone_id AND m.slice_id = w.slice_id AND m.id = w.id
         `).run());
                 // Merge memories — keep worktree-learned insights
                 merged.memories = countChanges(adapter.prepare(`

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

@@ -33,6 +33,7 @@ import { debugLog } from "./debug-logger.js";
 import { findMilestoneIds, nextMilestoneId, reserveMilestoneId, getReservedMilestoneIds, clearReservedMilestoneIds } from "./milestone-ids.js";
 import { parkMilestone, discardMilestone } from "./milestone-actions.js";
 import { selectAndApplyModel } from "./auto-model-selection.js";
+import { DISCUSS_TOOLS_ALLOWLIST } from "./constants.js";
 // ─── Re-exports (preserve public API for existing importers) ────────────────
 export { MILESTONE_ID_RE, generateMilestoneSuffix, nextMilestoneId, extractMilestoneSeq, parseMilestoneId, milestoneIdSort, maxMilestoneNum, findMilestoneIds, reserveMilestoneId, claimReservedId, getReservedMilestoneIds, clearReservedMilestoneIds, } from "./milestone-ids.js";
 export { showQueue, handleQueueReorder, showQueueAdd, buildExistingMilestonesContext, } from "./guided-flow-queue.js";
@@ -242,6 +243,24 @@ async function dispatchWorkflow(pi, note, customType = "gsd-run", ctx, unitType)
             });
         }
     }
+    // Scope tools for discuss flows (#2949).
+    // Providers with grammar-based constrained decoding (xAI/Grok) return
+    // "Grammar is too complex" when the combined tool schema is too large.
+    // Discuss flows only need a small subset of GSD tools — strip the heavy
+    // planning/execution/completion tools to keep the grammar within limits.
+    if (unitType?.startsWith("discuss-")) {
+        const currentTools = pi.getActiveTools();
+        // Keep all non-GSD tools (builtins, other extensions) and only the
+        // GSD tools on the discuss allowlist.
+        const scopedTools = currentTools.filter((t) => !t.startsWith("gsd_") || DISCUSS_TOOLS_ALLOWLIST.includes(t));
+        pi.setActiveTools(scopedTools);
+        debugLog("discuss-tool-scoping", {
+            unitType,
+            before: currentTools.length,
+            after: scopedTools.length,
+            removed: currentTools.length - scopedTools.length,
+        });
+    }
     const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".gsd", "agent", "GSD-WORKFLOW.md");
     const workflow = readFileSync(workflowPath, "utf-8");
     pi.sendMessage({

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

@@ -412,7 +412,33 @@ export function loadLedgerFromDisk(base) {
     return loadJsonFileOrNull(metricsPath(base), isMetricsLedger);
 }
 function loadLedger(base) {
-    return loadJsonFile(metricsPath(base), isMetricsLedger, defaultLedger);
+    const raw = loadJsonFile(metricsPath(base), isMetricsLedger, defaultLedger);
+    const before = raw.units.length;
+    raw.units = deduplicateUnits(raw.units);
+    if (raw.units.length < before) {
+        // Persist the cleaned ledger so duplicates don't re-accumulate
+        saveLedger(base, raw);
+    }
+    return raw;
+}
+/**
+ * Collapse duplicate entries with the same (type, id, startedAt) triple.
+ * Keeps the entry with the highest finishedAt (the most complete snapshot).
+ *
+ * This is a defensive measure against idle-watchdog race conditions that can
+ * produce duplicate entries on disk despite the in-memory idempotency guard
+ * in snapshotUnitMetrics(). See #1943.
+ */
+function deduplicateUnits(units) {
+    const map = new Map();
+    for (const u of units) {
+        const key = `${u.type}\0${u.id}\0${u.startedAt}`;
+        const existing = map.get(key);
+        if (!existing || u.finishedAt > existing.finishedAt) {
+            map.set(key, u);
+        }
+    }
+    return Array.from(map.values());
 }
 function saveLedger(base, data) {
     saveJsonFile(metricsPath(base), data);

package/dist/resources/extensions/gsd/native-git-bridge.js

@@ -569,10 +569,12 @@ export function nativeAddAllWithExclusions(basePath, exclusions) {
             return;
         }
         // When .gsd is a symlink, git rejects `:!.gsd/...` pathspecs with
-        // "beyond a symbolic link". Fall back to plain `git add -A` which
-        // respects .gitignore (where .gsd/ is listed by default).
+        // "beyond a symbolic link". Fall back to `git add -u` which only
+        // stages changes to already-tracked files — O(tracked) not O(filesystem).
+        // Using `git add -A` here would traverse the entire working tree,
+        // hanging indefinitely on repos with large untracked data dirs. (#1977)
         if (stderr.includes("beyond a symbolic link")) {
-            nativeAddAll(basePath);
+            gitFileExec(basePath, ["add", "-u"]);
             return;
         }
         throw new GSDError(GSD_GIT_ERROR, `git add -A with exclusions failed in ${basePath}: ${getErrorMessage(err)}`);

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

@@ -0,0 +1,224 @@
+// GSD Extension — Notification History Overlay
+// Scrollable panel showing all persisted notifications with severity filtering.
+// Toggled with Ctrl+Alt+N or opened from /gsd notifications.
+import { truncateToWidth, visibleWidth, matchesKey, Key } from "@gsd/pi-tui";
+import { readNotifications, markAllRead, clearNotifications, } from "./notification-store.js";
+import { padRight, joinColumns } from "../shared/mod.js";
+const FILTER_CYCLE = ["all", "error", "warning", "info"];
+function severityIcon(severity) {
+    switch (severity) {
+        case "error": return "✗";
+        case "warning": return "⚠";
+        case "success": return "✓";
+        case "info":
+        default: return "●";
+    }
+}
+function formatTimestamp(ts) {
+    try {
+        const d = new Date(ts);
+        const now = Date.now();
+        const diffMs = now - d.getTime();
+        if (diffMs < 60_000)
+            return "just now";
+        if (diffMs < 3600_000)
+            return `${Math.floor(diffMs / 60_000)}m ago`;
+        if (diffMs < 86400_000)
+            return `${Math.floor(diffMs / 3600_000)}h ago`;
+        return `${Math.floor(diffMs / 86400_000)}d ago`;
+    }
+    catch {
+        return ts.slice(11, 19); // fallback: HH:MM:SS
+    }
+}
+export class GSDNotificationOverlay {
+    tui;
+    theme;
+    onClose;
+    cachedWidth;
+    cachedLines;
+    scrollOffset = 0;
+    filterIndex = 0;
+    entries = [];
+    refreshTimer;
+    disposed = false;
+    resizeHandler = null;
+    constructor(tui, theme, onClose) {
+        this.tui = tui;
+        this.theme = theme;
+        this.onClose = onClose;
+        // Mark all as read on open
+        markAllRead();
+        this.entries = readNotifications();
+        // Resize handler
+        this.resizeHandler = () => {
+            if (this.disposed)
+                return;
+            this.invalidate();
+            this.tui.requestRender();
+        };
+        process.stdout.on("resize", this.resizeHandler);
+        // Refresh every 3s for new notifications
+        this.refreshTimer = setInterval(() => {
+            if (this.disposed)
+                return;
+            const fresh = readNotifications();
+            if (fresh.length !== this.entries.length) {
+                this.entries = fresh;
+                markAllRead();
+                this.invalidate();
+                this.tui.requestRender();
+            }
+        }, 3000);
+    }
+    get filter() {
+        return FILTER_CYCLE[this.filterIndex];
+    }
+    get filteredEntries() {
+        if (this.filter === "all")
+            return this.entries;
+        return this.entries.filter((e) => e.severity === this.filter);
+    }
+    handleInput(data) {
+        if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c")) || matchesKey(data, Key.ctrlAlt("n"))) {
+            this.dispose();
+            this.onClose();
+            return;
+        }
+        // Scroll
+        if (matchesKey(data, Key.down) || matchesKey(data, "j")) {
+            this.scrollOffset++;
+            this.invalidate();
+            this.tui.requestRender();
+            return;
+        }
+        if (matchesKey(data, Key.up) || matchesKey(data, "k")) {
+            this.scrollOffset = Math.max(0, this.scrollOffset - 1);
+            this.invalidate();
+            this.tui.requestRender();
+            return;
+        }
+        if (data === "g") {
+            this.scrollOffset = 0;
+            this.invalidate();
+            this.tui.requestRender();
+            return;
+        }
+        if (data === "G") {
+            this.scrollOffset = 999;
+            this.invalidate();
+            this.tui.requestRender();
+            return;
+        }
+        // Filter cycle
+        if (data === "f") {
+            this.filterIndex = (this.filterIndex + 1) % FILTER_CYCLE.length;
+            this.scrollOffset = 0;
+            this.invalidate();
+            this.tui.requestRender();
+            return;
+        }
+        // Clear all
+        if (data === "c") {
+            clearNotifications();
+            this.entries = [];
+            this.scrollOffset = 0;
+            this.invalidate();
+            this.tui.requestRender();
+            return;
+        }
+    }
+    render(width) {
+        if (this.cachedLines && this.cachedWidth === width) {
+            return this.cachedLines;
+        }
+        const content = this.buildContentLines(width);
+        const viewportHeight = Math.max(5, process.stdout.rows ? process.stdout.rows - 8 : 24);
+        const chromeHeight = 2; // top + bottom border
+        const visibleContentRows = Math.max(1, viewportHeight - chromeHeight);
+        const maxScroll = Math.max(0, content.length - visibleContentRows);
+        this.scrollOffset = Math.min(this.scrollOffset, maxScroll);
+        const visibleContent = content.slice(this.scrollOffset, this.scrollOffset + visibleContentRows);
+        const lines = this.wrapInBox(visibleContent, width);
+        this.cachedWidth = width;
+        this.cachedLines = lines;
+        return lines;
+    }
+    invalidate() {
+        this.cachedLines = undefined;
+        this.cachedWidth = undefined;
+    }
+    dispose() {
+        this.disposed = true;
+        clearInterval(this.refreshTimer);
+        if (this.resizeHandler) {
+            process.stdout.removeListener("resize", this.resizeHandler);
+            this.resizeHandler = null;
+        }
+    }
+    wrapInBox(inner, width) {
+        const th = this.theme;
+        const border = (s) => th.fg("borderAccent", s);
+        const innerWidth = width - 4;
+        const lines = [];
+        lines.push(border("╭" + "─".repeat(width - 2) + "╮"));
+        for (const line of inner) {
+            const truncated = truncateToWidth(line, innerWidth);
+            const padWidth = Math.max(0, innerWidth - visibleWidth(truncated));
+            lines.push(border("│") + " " + truncated + " ".repeat(padWidth) + " " + border("│"));
+        }
+        lines.push(border("╰" + "─".repeat(width - 2) + "╯"));
+        return lines;
+    }
+    buildContentLines(width) {
+        const th = this.theme;
+        const shellWidth = width - 4;
+        const contentWidth = Math.min(shellWidth, 128);
+        const sidePad = Math.max(0, Math.floor((shellWidth - contentWidth) / 2));
+        const leftMargin = " ".repeat(sidePad);
+        const lines = [];
+        const row = (content = "") => {
+            const truncated = truncateToWidth(content, contentWidth);
+            return leftMargin + padRight(truncated, contentWidth);
+        };
+        const blank = () => row("");
+        const hr = () => row(th.fg("dim", "─".repeat(contentWidth)));
+        // Header
+        const title = th.fg("accent", th.bold("Notifications"));
+        const filterLabel = this.filter === "all"
+            ? th.fg("dim", "all")
+            : th.fg(this.filter === "error" ? "error" : this.filter === "warning" ? "warning" : "dim", this.filter);
+        const count = `${this.filteredEntries.length} entries`;
+        lines.push(row(joinColumns(`${title}  ${th.fg("dim", "filter:")} ${filterLabel}`, th.fg("dim", count), contentWidth)));
+        lines.push(hr());
+        // Controls
+        lines.push(row(th.fg("dim", "↑/↓ scroll  f filter  c clear  Esc close")));
+        lines.push(blank());
+        // Entries
+        const filtered = this.filteredEntries;
+        if (filtered.length === 0) {
+            lines.push(blank());
+            lines.push(row(th.fg("dim", this.entries.length === 0
+                ? "No notifications yet."
+                : `No ${this.filter} notifications.`)));
+            lines.push(blank());
+            return lines;
+        }
+        for (const entry of filtered) {
+            const icon = severityIcon(entry.severity);
+            const coloredIcon = entry.severity === "error" ? th.fg("error", icon)
+                : entry.severity === "warning" ? th.fg("warning", icon)
+                    : entry.severity === "success" ? th.fg("success", icon)
+                        : th.fg("dim", icon);
+            const time = th.fg("dim", formatTimestamp(entry.ts));
+            const source = entry.source === "workflow-logger" ? th.fg("dim", " [engine]") : "";
+            // First line: icon + timestamp + source
+            const msgMaxWidth = contentWidth - 20;
+            const msg = entry.message.length > msgMaxWidth
+                ? entry.message.slice(0, msgMaxWidth - 1) + "…"
+                : entry.message;
+            lines.push(row(`${coloredIcon} ${time}${source}  ${msg}`));
+        }
+        return lines;
+    }
+}