gsd-pi 2.80.0 → 2.81.0-dev.72a81bdf3

package/dist/resources/extensions/gsd/tools/plan-slice.js

@@ -8,6 +8,7 @@ import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
+import { validatePlanningPathScope } from "../planning-path-scope.js";
 function validateTasks(value) {
     if (!Array.isArray(value) || value.length === 0) {
         throw new Error("tasks must be a non-empty array");
@@ -91,6 +92,14 @@ export async function handlePlanSlice(rawParams, basePath) {
     catch (err) {
         return { error: `validation failed: ${err.message}` };
     }
+    const pathScopeError = validatePlanningPathScope(basePath, params.tasks.flatMap((task, index) => [
+        { field: `tasks[${index}].files`, values: task.files },
+        { field: `tasks[${index}].inputs`, values: task.inputs },
+        { field: `tasks[${index}].expectedOutput`, values: task.expectedOutput },
+    ]));
+    if (pathScopeError) {
+        return { error: `validation failed: ${pathScopeError}` };
+    }
     // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
     // Guards must be inside the transaction so the state they check cannot
     // change between the read and the write (#2723).

package/dist/resources/extensions/gsd/tools/plan-task.js

@@ -8,6 +8,7 @@ import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
+import { validatePlanningPathScope } from "../planning-path-scope.js";
 function validateParams(params) {
     if (!isNonEmptyString(params?.milestoneId))
         throw new Error("milestoneId is required");
@@ -41,6 +42,14 @@ export async function handlePlanTask(rawParams, basePath) {
     catch (err) {
         return { error: `validation failed: ${err.message}` };
     }
+    const pathScopeError = validatePlanningPathScope(basePath, [
+        { field: "files", values: params.files },
+        { field: "inputs", values: params.inputs },
+        { field: "expectedOutput", values: params.expectedOutput },
+    ]);
+    if (pathScopeError) {
+        return { error: `validation failed: ${pathScopeError}` };
+    }
     // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
     // Guards must be inside the transaction so the state they check cannot
     // change between the read and the write (#2723).

package/dist/resources/extensions/gsd/tools/resume-tool.js

@@ -2,7 +2,12 @@
 // agents can re-orient after compaction or session resume without
 // re-deriving project memory state.
 import { readCompactionSnapshot } from "../compaction-snapshot.js";
+import { isContextModeEnabled } from "../preferences-types.js";
+import { contextModeDisabledResult } from "./context-mode-tool-result.js";
 export function executeResume(_params, opts) {
+    if (!isContextModeEnabled(opts.preferences)) {
+        return contextModeDisabledResult("gsd_resume");
+    }
     const snapshot = readCompactionSnapshot(opts.baseDir);
     if (snapshot == null) {
         return {

package/dist/resources/extensions/gsd/tools/workflow-tool-executors.js

@@ -376,12 +376,17 @@ export async function executeCompleteMilestone(params, basePath = process.cwd())
                 isError: true,
             };
         }
+        const message = result.alreadyComplete
+            ? `Milestone ${result.milestoneId} is already complete. Summary available at ${result.summaryPath}`
+            : `Completed milestone ${result.milestoneId}. Summary written to ${result.summaryPath}`;
         return {
-            content: [{ type: "text", text: `Completed milestone ${result.milestoneId}. Summary written to ${result.summaryPath}` }],
+            content: [{ type: "text", text: message }],
             details: {
                 operation: "complete_milestone",
                 milestoneId: result.milestoneId,
                 summaryPath: result.summaryPath,
+                ...(result.alreadyComplete ? { alreadyComplete: true } : {}),
+                ...(result.stale ? { stale: true } : {}),
             },
         };
     }
@@ -675,7 +680,7 @@ export async function executeMilestoneStatus(params, basePath = process.cwd()) {
             };
             return {
                 content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-                details: { operation: "milestone_status", milestoneId: milestone.id, sliceCount: slices.length },
+                details: { operation: "milestone_status", ...result },
             };
         });
     }

package/dist/resources/extensions/gsd/tui/render-kit.js

@@ -0,0 +1,74 @@
+// Project/App: GSD-2
+// File Purpose: Shared terminal rendering helpers for GSD extension TUI surfaces.
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@gsd/pi-tui";
+export function safeLine(text, width, ellipsis = "…") {
+    if (width <= 0)
+        return "";
+    return truncateToWidth(text, width, ellipsis);
+}
+export function padRightVisible(text, width) {
+    if (width <= 0)
+        return "";
+    const truncated = safeLine(text, width);
+    const pad = Math.max(0, width - visibleWidth(truncated));
+    return truncated + " ".repeat(pad);
+}
+export function rightAlign(left, right, width) {
+    if (width <= 0)
+        return "";
+    if (!right)
+        return safeLine(left, width);
+    if (!left)
+        return safeLine(" ".repeat(Math.max(0, width - visibleWidth(right))) + right, width);
+    const gap = Math.max(1, width - visibleWidth(left) - visibleWidth(right));
+    return safeLine(left + " ".repeat(gap) + right, width);
+}
+export function wrapVisibleText(text, width) {
+    if (width <= 0)
+        return [text];
+    return wrapTextWithAnsi(text, width).map((line) => visibleWidth(line) > width ? truncateToWidth(line, width, "…") : line);
+}
+export function renderBar(theme, width, color = "muted") {
+    return safeLine(theme.fg(color, "─".repeat(Math.max(0, width))), width, "");
+}
+export function renderKeyHints(theme, hints, width) {
+    return safeLine(theme.fg("dim", hints.filter(Boolean).join("  │  ")), width);
+}
+export function renderProgressBar(theme, done, total, width, options = {}) {
+    const barWidth = Math.max(0, width);
+    const pct = total > 0 ? Math.max(0, Math.min(1, done / total)) : 0;
+    const filled = Math.round(pct * barWidth);
+    const filledChar = options.filledChar ?? "█";
+    const emptyChar = options.emptyChar ?? "░";
+    return (theme.fg(options.filledColor ?? "success", filledChar.repeat(filled)) +
+        theme.fg(options.emptyColor ?? "dim", emptyChar.repeat(barWidth - filled)));
+}
+export function statusGlyph(theme, level) {
+    switch (level) {
+        case "active": return theme.fg("success", "●");
+        case "success": return theme.fg("success", "✓");
+        case "warning": return theme.fg("warning", "!");
+        case "error": return theme.fg("error", "x");
+        case "idle":
+        default: return theme.fg("dim", "○");
+    }
+}
+export function renderFrame(theme, inner, width, options = {}) {
+    if (width < 4)
+        return inner.map((line) => safeLine(line, width));
+    const borderColor = options.borderColor ?? "borderAccent";
+    const paddingX = Math.max(0, options.paddingX ?? 1);
+    const contentWidth = Math.max(0, width - 2 - paddingX * 2);
+    const border = (text) => theme.fg(borderColor, text);
+    const pad = " ".repeat(paddingX);
+    const lines = [border("╭" + "─".repeat(width - 2) + "╮")];
+    for (const line of inner) {
+        lines.push(border("│") +
+            pad +
+            padRightVisible(line, contentWidth) +
+            pad +
+            border("│"));
+    }
+    lines.push(border("╰" + "─".repeat(width - 2) + "╯"));
+    return lines.map((line) => safeLine(line, width, ""));
+}

package/dist/resources/extensions/gsd/unit-context-composer.js

@@ -80,7 +80,15 @@ const CONTEXT_MODE_LANE_LABELS = {
     orchestration: "orchestration",
     docs: "documentation",
 };
-const CONTEXT_MODE_GUIDANCE = "Use `gsd_exec` for noisy scans, builds, and tests so full output stays out of prompt context; call `gsd_exec_search` before repeating prior runs; call `gsd_resume` after compaction or resume to recover stored execution context.";
+const CONTEXT_MODE_GUIDANCE_BY_LANE = {
+    interview: "Use `gsd_resume` to restore prior discussion, `gsd_exec` for noisy discovery, and `gsd_exec_search` before repeating scans.",
+    research: "Use `gsd_exec` for noisy research scans, `gsd_exec_search` before reruns, and `gsd_resume` to restore prior findings.",
+    planning: "Use `gsd_resume` for planning continuity, `gsd_exec` for noisy checks, and `gsd_exec_search` before rerunning diagnostics.",
+    execution: "Use `gsd_exec` for builds, tests, and diagnostics, `gsd_exec_search` before reruns, and `gsd_resume` after compaction or resume.",
+    verification: "Use `gsd_exec` for verification commands, `gsd_exec_search` to reuse prior evidence, and `gsd_resume` after compaction or resume.",
+    orchestration: "Use `gsd_resume` before resuming orchestration, `gsd_exec_search` to reuse prior runs, and `gsd_exec` for noisy coordination checks.",
+    docs: "Use `gsd_resume` for prior context, `gsd_exec_search` for saved evidence, and `gsd_exec` for noisy doc validation commands.",
+};
 /**
  * Render the Context Mode instruction lane for a unit type. Unknown unit
  * types, disabled config, and explicit `contextMode: "none"` all omit the
@@ -93,14 +101,15 @@ export function composeContextModeInstructions(unitType, opts) {
     if (!manifest || manifest.contextMode === "none")
         return "";
     const lane = CONTEXT_MODE_LANE_LABELS[manifest.contextMode];
+    const guidance = CONTEXT_MODE_GUIDANCE_BY_LANE[manifest.contextMode];
     if (opts.renderMode === "nested") {
-        return `Context Mode (${lane} lane): ${CONTEXT_MODE_GUIDANCE}`;
+        return `Context Mode (${lane} lane): ${guidance}`;
     }
     return [
         "## Context Mode",
         "",
         `Lane: **${lane} lane**.`,
-        CONTEXT_MODE_GUIDANCE,
+        guidance,
     ].join("\n");
 }
 const SECTION_SEPARATOR = "\n\n---\n\n";

package/dist/resources/extensions/gsd/unit-runtime.js

@@ -4,6 +4,8 @@ import { atomicWriteSync } from "./atomic-write.js";
 import { gsdRoot, relSliceFile, relTaskFile, resolveSliceFile, resolveTaskFile, } from "./paths.js";
 import { loadFile, parseTaskPlanMustHaves, countMustHavesMentionedInSummary } from "./files.js";
 import { parseUnitId } from "./unit-id.js";
+import { getTask, isDbAvailable, refreshOpenDatabaseFromDisk } from "./gsd-db.js";
+import { isClosedStatus } from "./status-guards.js";
 // Per-record advisory lock — prevents read-modify-write races between
 // concurrent writers updating disjoint fields of the same runtime record.
 // Within a single Node process this is moot (writeUnitRuntimeRecord is sync),
@@ -67,6 +69,17 @@ function withRecordLock(recordPath, fn) {
         catch { /* best-effort */ }
     }
 }
+export const IN_FLIGHT_RUNTIME_PHASES = new Set([
+    "dispatched",
+    "wrapup-warning-sent",
+    "timeout",
+    "finalize-timeout",
+    "crashed",
+    "paused",
+]);
+export function isInFlightRuntimePhase(phase) {
+    return IN_FLIGHT_RUNTIME_PHASES.has(phase);
+}
 function runtimeDir(basePath) {
     return join(gsdRoot(basePath), "runtime", "units");
 }
@@ -154,6 +167,12 @@ export async function inspectExecuteTaskDurability(basePath, unitId) {
     const escapedTid = tid.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const taskChecked = !!planContent && new RegExp(`^- \\[[xX]\\] \\*\\*${escapedTid}:`, "m").test(planContent);
     const nextActionAdvanced = !new RegExp(`Execute ${tid}\\b`).test(stateContent);
+    let dbComplete = false;
+    if (isDbAvailable()) {
+        refreshOpenDatabaseFromDisk();
+        const task = getTask(mid, sid, tid);
+        dbComplete = !!task && isClosedStatus(task.status);
+    }
     // Must-have coverage: load task plan and count mentions in summary
     let mustHaveCount = 0;
     let mustHavesMentionedInSummary = 0;
@@ -177,11 +196,14 @@ export async function inspectExecuteTaskDurability(basePath, unitId) {
         summaryExists,
         taskChecked,
         nextActionAdvanced,
+        dbComplete,
         mustHaveCount,
         mustHavesMentionedInSummary,
     };
 }
 export function formatExecuteTaskRecoveryStatus(status) {
+    if (status.dbComplete)
+        return "DB task status is closed";
     const missing = [];
     if (!status.summaryExists)
         missing.push(`summary missing (${status.summaryPath})`);

package/dist/resources/extensions/gsd/uok/kernel.js

@@ -5,6 +5,7 @@ import { buildAuditEnvelope, emitUokAuditEvent } from "./audit.js";
 import { setUnifiedAuditEnabled } from "./audit-toggle.js";
 import { resolveUokFlags } from "./flags.js";
 import { createTurnObserver } from "./loop-adapter.js";
+import { incrementLegacyTelemetry } from "../legacy-telemetry.js";
 function parityLogPath(basePath) {
     return join(gsdRoot(basePath), "runtime", "uok-parity.jsonl");
 }
@@ -27,9 +28,13 @@ export async function runAutoLoopWithUok(args) {
     const prefs = deps.loadEffectiveGSDPreferences()?.preferences;
     const flags = resolveUokFlags(prefs);
     setUnifiedAuditEnabled(flags.auditUnified);
+    const pathLabel = resolveKernelPathLabel(flags);
+    if (pathLabel !== "uok-kernel") {
+        incrementLegacyTelemetry("legacy.uokFallbackUsed");
+    }
     writeParityEvent(s.basePath, {
         ts: new Date().toISOString(),
-        path: resolveKernelPathLabel(flags),
+        path: pathLabel,
         flags,
         phase: "enter",
     });
@@ -65,7 +70,7 @@ export async function runAutoLoopWithUok(args) {
         }
         writeParityEvent(s.basePath, {
             ts: new Date().toISOString(),
-            path: resolveKernelPathLabel(flags),
+            path: pathLabel,
             flags,
             phase: "exit",
             status: "ok",
@@ -74,7 +79,7 @@ export async function runAutoLoopWithUok(args) {
     catch (err) {
         writeParityEvent(s.basePath, {
             ts: new Date().toISOString(),
-            path: resolveKernelPathLabel(flags),
+            path: pathLabel,
             flags,
             phase: "exit",
             status: "error",

package/dist/resources/extensions/gsd/uok/plan-v2.js

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: UOK plan v2 graph compilation from GSD workflow state.
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot, resolveMilestoneFile, resolveSliceFile } from "../paths.js";

package/dist/resources/extensions/gsd/watch/header-renderer.js

@@ -1,5 +1,5 @@
-// GSD Watch — Header renderer: ASCII logo, session info, MCP status, remote questions
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+// Project/App: GSD-2
+// File Purpose: Watch-mode terminal header and splash renderer for GSD project status.
 import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -7,25 +7,57 @@ import { join } from "node:path";
 import { visibleWidth, truncateToWidth } from "@gsd/pi-tui";
 import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { gsdHome } from "../gsd-home.js";
+import { splashPalette } from "./splash-palette.js";
 // ─── Constants ────────────────────────────────────────────────────────────────
-/**
- * GSD ASCII logo — inlined here because the canonical src/logo.ts is outside
- * the resources rootDir and cannot be imported directly.
- */
 const GSD_LOGO = [
-    '   ██████╗ ███████╗██████╗ ',
-    '  ██╔════╝ ██╔════╝██╔══██╗',
-    '  ██║  ███╗███████╗██║  ██║',
-    '  ██║   ██║╚════██║██║  ██║',
-    '  ╚██████╔╝███████║██████╔╝',
-    '   ╚═════╝ ╚══════╝╚═════╝ ',
+    "   ██████╗ ███████╗██████╗ ",
+    "  ██╔════╝ ██╔════╝██╔══██╗",
+    "  ██║  ███╗███████╗██║  ██║",
+    "  ██║   ██║╚════██║██║  ██║",
+    "  ╚██████╔╝███████║██████╔╝",
+    "   ╚═════╝ ╚══════╝╚═════╝ ",
 ];
-/** Separator character for the horizontal divider line. */
-const SEPARATOR_CHAR = "─";
-/** Vertical bar between logo and info panel. */
-const PANEL_DIVIDER = "│";
 /** Label column width for Model/Provider/Directory/Branch rows. */
 const LABEL_COL_WIDTH = 10;
+const ANSI_RESET = "\x1b[0m";
+const ANSI_BOLD = "\x1b[1m";
+function rgb(hex) {
+    const cleaned = hex.replace("#", "");
+    const r = Number.parseInt(cleaned.slice(0, 2), 16);
+    const g = Number.parseInt(cleaned.slice(2, 4), 16);
+    const b = Number.parseInt(cleaned.slice(4, 6), 16);
+    return `\x1b[38;2;${r};${g};${b}m`;
+}
+const colors = {
+    accent: rgb(splashPalette.accent),
+    border: rgb(splashPalette.border),
+    muted: rgb(splashPalette.muted),
+    dim: rgb(splashPalette.dim),
+    text: rgb(splashPalette.text),
+    success: rgb(splashPalette.success),
+};
+function color(text, colorCode) {
+    return `${colorCode}${text}${ANSI_RESET}`;
+}
+function bold(text) {
+    return `${ANSI_BOLD}${text}${ANSI_RESET}`;
+}
+function padVisible(text, width) {
+    const clipped = truncateToWidth(text, Math.max(0, width), "");
+    return clipped + " ".repeat(Math.max(0, width - visibleWidth(clipped)));
+}
+function rightAlign(left, right, width) {
+    if (!right)
+        return truncateToWidth(left, width, "");
+    const gap = Math.max(1, width - visibleWidth(left) - visibleWidth(right));
+    return truncateToWidth(left + " ".repeat(gap) + right, width, "");
+}
+function frameLine(content, width) {
+    if (width < 3)
+        return truncateToWidth(content, Math.max(0, width), "");
+    const innerWidth = Math.max(0, width - 2);
+    return `${color("│", colors.border)}${padVisible(content, innerWidth)}${color("│", colors.border)}`;
+}
 // ─── Data Readers ─────────────────────────────────────────────────────────────
 /**
  * Read the configured execution model from GSD preferences.
@@ -147,12 +179,11 @@ export function gatherHeaderData(projectRoot) {
  * Returns empty string if value is empty.
  */
 function formatInfoLine(label, value, availableWidth) {
-    const bold = `\x1b[1m${label}\x1b[0m`;
-    const labelVis = visibleWidth(bold);
-    const padding = " ".repeat(Math.max(1, LABEL_COL_WIDTH - labelVis));
+    const labelText = bold(color(label, colors.text));
+    const padding = " ".repeat(Math.max(1, LABEL_COL_WIDTH - label.length));
     const maxValueWidth = Math.max(1, availableWidth - LABEL_COL_WIDTH);
     const truncValue = truncateToWidth(value, maxValueWidth, "…");
-    return bold + padding + truncValue;
+    return labelText + padding + color(truncValue, colors.muted);
 }
 /**
  * Format MCP server names as a dot-separated row with checkmarks.
@@ -164,7 +195,7 @@ export function formatMcpRow(servers, width) {
     // Capitalize first letter of each server name
     const items = servers.map(s => {
         const cap = s.charAt(0).toUpperCase() + s.slice(1);
-        return `${cap} ✓`;
+        return `${color(cap, colors.accent)} ${color("✓", colors.success)}`;
     });
     const full = items.join("  ·  ");
     if (visibleWidth(full) <= width)
@@ -175,70 +206,62 @@ export function formatMcpRow(servers, width) {
 /**
  * Render the full header as an array of terminal-safe strings.
  *
- * Layout: GSD ASCII logo on the left, info panel on the right separated by │.
- * Below: MCP server row, remote questions row, separator line.
+ * Layout: compact GSD mark on the left with a command-center status panel on
+ * the right. This keeps the splash visual while making the actionable command
+ * and workspace state easier to scan.
  */
 export function renderHeaderLines(data, width) {
-    const lines = [];
-    // Logo is 6 lines tall. Info panel has: title + blank + model + provider + directory + branch = 6 lines
+    if (width < 40)
+        return renderStackedHeader(data, width);
+    const outerWidth = width;
+    const innerWidth = Math.max(0, outerWidth - 2);
     const logoLines = GSD_LOGO;
-    const logoWidth = Math.max(...logoLines.map(l => visibleWidth(l)));
-    // Calculate available width for the info panel
-    // Layout: logo + " " + "│" + " " = logoWidth + 3
-    const dividerOverhead = 3; // " │ "
-    const infoPanelWidth = width - logoWidth - dividerOverhead;
-    // If terminal is too narrow for side-by-side, fall back to stacked layout
-    if (infoPanelWidth < 20) {
+    const logoWidth = Math.max(...logoLines.map((line) => visibleWidth(line)));
+    const gap = ` ${color("│", colors.dim)} `;
+    const panelWidth = innerWidth - logoWidth - visibleWidth(gap);
+    if (panelWidth < 44) {
         return renderStackedHeader(data, width);
     }
-    // Build info panel lines (6 lines to match logo height)
-    const infoLines = [
-        `\x1b[1mGet Shit Done\x1b[0m`,
-        "",
-        formatInfoLine("Model", data.model, infoPanelWidth),
-        formatInfoLine("Provider", data.provider, infoPanelWidth),
-        formatInfoLine("Directory", data.directory, infoPanelWidth),
-        formatInfoLine("Branch", data.branch, infoPanelWidth),
+    const mcpRow = formatMcpRow(data.mcpServers, Math.max(1, panelWidth - 9)) || color("none configured", colors.dim);
+    const panelLines = [
+        rightAlign(`${color("GSD", colors.accent)} ${bold(color("Project Console", colors.text))}`, color("idle", colors.muted), panelWidth),
+        rightAlign(`${color("Project", colors.muted)} ${color(data.directory, colors.text)}`, `${color("Command", colors.muted)} ${color("/gsd start", colors.accent)}`, panelWidth),
+        rightAlign(`${color("Branch", colors.muted)} ${color(data.branch, colors.text)}`, `${color("Mode", colors.muted)} ${color("manual", colors.text)}`, panelWidth),
+        rightAlign(`${color("MCP", colors.muted)} ${mcpRow}`, `${color("Model", colors.muted)} ${color(data.model, colors.text)}`, panelWidth),
+        rightAlign(`${color("Provider", colors.muted)} ${color(data.provider, colors.text)}`, `${color("Workspace", colors.muted)} ${color(data.directory, colors.text)}`, panelWidth),
+        rightAlign(color("/gsd to begin", colors.accent), `${color("/gsd templates", colors.muted)}  ${color("/gsd help", colors.muted)}`, panelWidth),
     ];
-    // Merge logo and info panel side by side
-    const maxLines = Math.max(logoLines.length, infoLines.length);
-    for (let i = 0; i < maxLines; i++) {
-        const logoLine = i < logoLines.length ? logoLines[i] : "";
-        const infoLine = i < infoLines.length ? infoLines[i] : "";
-        // Pad logo line to consistent width
-        const logoPad = " ".repeat(Math.max(0, logoWidth - visibleWidth(logoLine)));
-        lines.push(`${logoLine}${logoPad} ${PANEL_DIVIDER} ${infoLine}`);
-    }
-    // Blank line after logo+info block
-    lines.push("");
-    // MCP server row
-    const mcpRow = formatMcpRow(data.mcpServers, width);
-    if (mcpRow) {
-        lines.push(` ${mcpRow}`);
+    const lines = [
+        color("╭" + "─".repeat(Math.max(0, outerWidth - 2)) + "╮", colors.border),
+    ];
+    for (let i = 0; i < logoLines.length; i++) {
+        const logo = padVisible(color(logoLines[i], colors.border), logoWidth);
+        lines.push(frameLine(`${logo}${gap}${panelLines[i] ?? ""}`, outerWidth));
     }
-    // Separator line
-    lines.push(SEPARATOR_CHAR.repeat(width));
+    lines.push(color("╰" + "─".repeat(Math.max(0, outerWidth - 2)) + "╯", colors.border));
     return lines;
 }
 /**
  * Fallback stacked layout for narrow terminals (< 20 cols for info panel).
  */
 function renderStackedHeader(data, width) {
-    const lines = [];
+    const outerWidth = Math.max(0, width);
+    if (outerWidth < 3) {
+        return [color(truncateToWidth("GSD", outerWidth, ""), colors.accent)];
+    }
+    const lines = [color("╭" + "─".repeat(Math.max(0, outerWidth - 2)) + "╮", colors.border)];
     // Title
-    lines.push(`\x1b[1mGet Shit Done\x1b[0m`);
-    lines.push("");
+    lines.push(frameLine(`${color("GSD", colors.accent)} ${bold(color("Project Console", colors.text))}`, outerWidth));
     // Info
-    lines.push(formatInfoLine("Model", data.model, width));
-    lines.push(formatInfoLine("Provider", data.provider, width));
-    lines.push(formatInfoLine("Directory", data.directory, width));
-    lines.push(formatInfoLine("Branch", data.branch, width));
-    lines.push("");
+    lines.push(frameLine(formatInfoLine("Project", data.directory, outerWidth - 2), outerWidth));
+    lines.push(frameLine(formatInfoLine("Command", "/gsd start", outerWidth - 2), outerWidth));
+    lines.push(frameLine(formatInfoLine("Branch", data.branch, outerWidth - 2), outerWidth));
+    lines.push(frameLine(formatInfoLine("Model", data.model, outerWidth - 2), outerWidth));
     // MCP
-    const mcpRow = formatMcpRow(data.mcpServers, width);
+    const mcpRow = formatMcpRow(data.mcpServers, Math.max(1, outerWidth - 7));
     if (mcpRow)
-        lines.push(` ${mcpRow}`);
-    // Separator
-    lines.push(SEPARATOR_CHAR.repeat(width));
+        lines.push(frameLine(`${color("MCP", colors.muted)} ${mcpRow}`, outerWidth));
+    lines.push(frameLine(`${color("/gsd to begin", colors.accent)}  ${color("/gsd help", colors.muted)}`, outerWidth));
+    lines.push(color("╰" + "─".repeat(Math.max(0, outerWidth - 2)) + "╯", colors.border));
     return lines;
 }

package/dist/resources/extensions/gsd/watch/splash-palette.js

@@ -0,0 +1,10 @@
+// Project/App: GSD-2
+// File Purpose: Shared RGB palette for the pre-theme GSD watch splash.
+export const splashPalette = {
+    accent: "#8db7ff",
+    border: "#a7ba78",
+    muted: "#7d889f",
+    dim: "#4d5870",
+    text: "#dce4f2",
+    success: "#a8c978",
+};

package/dist/resources/extensions/gsd/workflow-logger.js

@@ -3,13 +3,12 @@
 // Captures structured entries that the auto-loop can drain after each unit
 // to surface root causes for stuck loops, silent degradation, and blocked writes.
 // Error-severity entries are persisted to .gsd/audit-log.jsonl (sanitized) for
-// post-mortem analysis. Warnings are ephemeral (stderr + buffer only) to avoid
-// log amplification from expected-control-flow catch paths.
+// post-mortem analysis. Warnings persist to notifications and remain available
+// in the in-memory buffer, but are not printed to stderr.
 //
-// Stderr policy: every logWarning/logError call writes immediately to stderr
-// for terminal visibility. This is intentional — unlike debug-logger (which is
-// opt-in and zero-overhead when disabled), workflow-logger covers operational
-// warnings/errors that should always be visible. There is no disable flag.
+// Stderr policy: logError writes immediately to stderr for terminal visibility.
+// logWarning stays out of the TUI/stdout stream and is surfaced through the
+// notification store plus the auto-loop issue buffer.
 //
 // Singleton safety: _buffer is module-level and shared across all calls within
 // a process. The auto-loop must call _resetLogs() (or drainAndSummarize()) at
@@ -45,7 +44,8 @@ export function setStderrLoggingEnabled(enabled) {
 }
 // ─── Public API ─────────────────────────────────────────────────────────
 /**
- * Record a warning. Also writes to stderr for terminal visibility.
+ * Record a warning. Warnings are persisted to notifications and buffered for
+ * auto-loop issue summaries, but they are intentionally not written to stderr.
  */
 export function logWarning(component, message, context) {
     _push("warn", component, message, context);
@@ -189,10 +189,10 @@ function _push(severity, component, message, context) {
         message,
         ...(context ? { context } : {}),
     };
-    // Always forward to stderr so terminal watchers see it (see module header for policy)
-    const prefix = severity === "error" ? "ERROR" : "WARN";
-    const ctxStr = context ? ` ${JSON.stringify(context)}` : "";
-    _writeStderr(`[gsd:${component}] ${prefix}: ${message}${ctxStr}\n`);
+    if (severity === "error") {
+        const ctxStr = context ? ` ${JSON.stringify(context)}` : "";
+        _writeStderr(`[gsd:${component}] ERROR: ${message}${ctxStr}\n`);
+    }
     // Persist to notification store (both warnings and errors)
     try {
         appendNotification(`[${component}] ${message}`, severity === "error" ? "error" : "warning", "workflow-logger");
@@ -226,8 +226,8 @@ function _push(severity, component, message, context) {
         }
     }
     // Persist errors to .gsd/audit-log.jsonl so they survive context resets.
-    // Only error-severity entries are persisted — warnings are ephemeral (stderr + buffer)
-    // to avoid log amplification from expected-control-flow catch paths.
+    // Warnings are already persisted to notifications and buffered for the
+    // current auto-loop unit.
     if (_auditBasePath && severity === "error") {
         try {
             const auditDir = join(_auditBasePath, ".gsd");

package/dist/resources/extensions/gsd/workflow-manifest.js

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: State manifest snapshot and restore orchestration for GSD workflow data.
 import { _getAdapter, readTransaction, restoreManifest, } from "./gsd-db.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { readFileSync, existsSync, mkdirSync } from "node:fs";

package/dist/resources/extensions/gsd/workflow-mcp.js

@@ -266,7 +266,7 @@ export function getRequiredWorkflowToolsForGuidedUnit(unitType) {
         case "execute-task":
             return ["gsd_task_complete"];
         case "complete-slice":
-            return ["gsd_slice_complete"];
+            return ["gsd_slice_complete", "gsd_task_reopen", "gsd_replan_slice"];
         default:
             return [];
     }
@@ -294,7 +294,7 @@ export function getRequiredWorkflowToolsForAutoUnit(unitType) {
         case "reactive-execute":
             return ["gsd_task_complete"];
         case "complete-slice":
-            return ["gsd_slice_complete"];
+            return ["gsd_slice_complete", "gsd_task_reopen", "gsd_replan_slice"];
         case "replan-slice":
             return ["gsd_replan_slice"];
         case "reassess-roadmap":

package/dist/resources/extensions/gsd/workflow-projections.js

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Projection renderers for GSD workflow database rows.
 // GSD Extension — Projection Renderers (DB -> Markdown)
 // Renders PLAN.md, ROADMAP.md, SUMMARY.md, and STATE.md from database rows.
 // Projections are read-only views of engine state (Layer 3 of the architecture).