gsd-pi 2.80.0 → 2.81.0-dev.3cddbbba2

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

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

@@ -0,0 +1,131 @@
+// Project/App: GSD-2
+// File Purpose: Shared capped workflow protocol and doctor-heal prompt payload helpers.
+const DEFAULT_WORKFLOW_PROTOCOL_EXCERPT_CHARS = 4_000;
+const MIN_WORKFLOW_PROTOCOL_EXCERPT_CHARS = 1_000;
+const DEFAULT_DOCTOR_SUMMARY_CHARS = 2_400;
+const DEFAULT_DOCTOR_ISSUE_CHARS = 300;
+const DEFAULT_DOCTOR_MAX_ISSUES = 12;
+const DEFAULT_DOCTOR_ISSUES_CHARS = 4_000;
+export function buildWorkflowProtocolExcerpt(workflow, workflowPath, opts = {}) {
+    const limit = opts.maxChars ?? getWorkflowProtocolExcerptLimit();
+    const trimmed = workflow.trim();
+    const excerpt = buildPrioritizedWorkflowExcerpt(trimmed, limit);
+    const truncated = trimmed.length > limit;
+    const lines = [
+        "## GSD Workflow Protocol Excerpt",
+        `Source: \`${workflowPath}\``,
+        "",
+        excerpt,
+    ];
+    if (truncated) {
+        lines.push("", "[Workflow Protocol Truncated]", "The full workflow protocol remains available at the source path above. Read it only if this excerpt lacks a rule required for the dispatched task.");
+    }
+    return lines.join("\n");
+}
+export function buildWorkflowDispatchContent(opts) {
+    return [
+        "Read the following GSD workflow protocol excerpt and execute exactly. Use the source path for a full protocol read only if the excerpt lacks a required rule.",
+        "",
+        buildWorkflowProtocolExcerpt(opts.workflow, opts.workflowPath, { maxChars: opts.maxProtocolChars }),
+        "",
+        "## Your Task",
+        "",
+        opts.task.trim(),
+    ].join("\n");
+}
+export function buildDoctorHealSummary(reportText, opts = {}) {
+    const limit = opts.maxChars ?? DEFAULT_DOCTOR_SUMMARY_CHARS;
+    const lines = reportText.split(/\r?\n/).map((line) => line.trimEnd());
+    const summaryLines = lines.filter((line) => line.length > 0 && (/^#/.test(line) ||
+        /^(scope|status|summary|checks?|errors?|warnings?|fixes?|issues?)\b/i.test(line) ||
+        /doctor/i.test(line)));
+    const selected = summaryLines.length > 0 ? summaryLines : lines.filter((line) => line.trim()).slice(0, 24);
+    return capText(selected.join("\n"), limit, "Full doctor report is available in the command output; use the structured issue list below for repairs.");
+}
+export function buildDoctorHealIssuePayload(structuredIssues, opts = {}) {
+    const maxIssues = opts.maxIssues ?? DEFAULT_DOCTOR_MAX_ISSUES;
+    const maxIssueChars = opts.maxIssueChars ?? DEFAULT_DOCTOR_ISSUE_CHARS;
+    const maxChars = opts.maxChars ?? DEFAULT_DOCTOR_ISSUES_CHARS;
+    const blocks = splitIssueBlocks(structuredIssues);
+    const topBlocks = blocks.slice(0, maxIssues).map((block) => capText(block, maxIssueChars, "Issue details truncated; inspect the relevant artifact before editing."));
+    if (blocks.length > maxIssues) {
+        topBlocks.push(`[${blocks.length - maxIssues} additional actionable issue(s) omitted from prompt. Re-run /gsd doctor heal after this repair pass.]`);
+    }
+    return capText(topBlocks.join("\n\n"), maxChars, "Structured issue list truncated; repair top actionable issues first and re-run doctor heal.");
+}
+function getWorkflowProtocolExcerptLimit() {
+    const raw = process.env.PI_GSD_WORKFLOW_PROTOCOL_MAX_CHARS;
+    if (!raw)
+        return DEFAULT_WORKFLOW_PROTOCOL_EXCERPT_CHARS;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed < MIN_WORKFLOW_PROTOCOL_EXCERPT_CHARS) {
+        return DEFAULT_WORKFLOW_PROTOCOL_EXCERPT_CHARS;
+    }
+    return Math.floor(parsed);
+}
+function buildPrioritizedWorkflowExcerpt(workflow, limit) {
+    if (workflow.length <= limit)
+        return workflow;
+    const sections = splitMarkdownSections(workflow);
+    const wanted = [
+        /^# /,
+        /^## Quick Start\b/i,
+        /^## The Hierarchy\b/i,
+        /^## The Phases\b/i,
+        /^### Phase 4: Execute\b/i,
+        /^### Phase 5: Verify\b/i,
+        /^### Observable Truths\b/i,
+        /^### Artifacts\b/i,
+        /^### Key Links\b/i,
+        /^### Phase 6: Summarize\b/i,
+        /^### Phase 7: Advance\b/i,
+    ];
+    const selected = [];
+    const used = new Set();
+    for (const pattern of wanted) {
+        const index = sections.findIndex((section, sectionIndex) => !used.has(sectionIndex) && pattern.test(section.heading));
+        if (index >= 0) {
+            used.add(index);
+            selected.push(sections[index].text);
+        }
+    }
+    const body = selected.length > 0 ? selected.join("\n\n") : workflow;
+    return capText(body, limit, "Workflow protocol excerpt capped; read the source path for omitted details.");
+}
+function splitMarkdownSections(markdown) {
+    const lines = markdown.split(/\r?\n/);
+    const sections = [];
+    let currentHeading = lines[0]?.startsWith("#") ? lines[0] : "# Preamble";
+    let current = [];
+    for (const line of lines) {
+        if (/^#{1,3}\s+/.test(line) && current.length > 0) {
+            sections.push({ heading: currentHeading, text: current.join("\n").trim() });
+            currentHeading = line;
+            current = [line];
+            continue;
+        }
+        if (/^#{1,3}\s+/.test(line))
+            currentHeading = line;
+        current.push(line);
+    }
+    if (current.length > 0) {
+        sections.push({ heading: currentHeading, text: current.join("\n").trim() });
+    }
+    return sections.filter((section) => section.text.length > 0);
+}
+function splitIssueBlocks(structuredIssues) {
+    const trimmed = structuredIssues.trim();
+    if (!trimmed)
+        return ["No structured issue details were provided."];
+    const split = trimmed.split(/\n(?=(?:#{2,6}\s+|\d+\.\s+|- \*\*|- \[[ x]\]))/i)
+        .map((block) => block.trim())
+        .filter(Boolean);
+    return split.length > 0 ? split : [trimmed];
+}
+function capText(text, limit, notice) {
+    if (text.length <= limit)
+        return text;
+    const suffix = `\n\n[Truncated]\n${notice}`;
+    const headBudget = Math.max(0, limit - suffix.length);
+    return `${text.slice(0, headBudget).trimEnd()}${suffix}`;
+}

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Workflow template registry loading, matching, and display helpers.
 /**
  * GSD Workflow Templates — Registry & Resolution
  *
@@ -8,6 +10,7 @@ import { readFileSync, existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { gsdHome } from "./gsd-home.js";
+import { formatRecommendedProcessPaths } from "./process-task-path.js";
 const __extensionDir = resolveGsdExtensionDir();
 const registryPath = join(__extensionDir, "workflow-templates", "registry.json");
 /** Resolve the GSD extension dir with fallback to ~/.gsd/agent/extensions/gsd/. */
@@ -20,6 +23,9 @@ function resolveGsdExtensionDir() {
         return agentGsdDir;
     return moduleDir;
 }
+export function isLegacyWorkflowMode(mode) {
+    return (mode ?? "markdown-phase") !== "auto-milestone";
+}
 // ─── Registry Cache ──────────────────────────────────────────────────────────
 let cachedRegistry = null;
 /**
@@ -159,6 +165,9 @@ export function listTemplates() {
     }
     lines.push("Usage: /gsd start <template> [description]");
     lines.push("       /gsd templates info <name>");
+    lines.push("");
+    lines.push("Recommended Task Paths:");
+    lines.push(formatRecommendedProcessPaths());
     return lines.join("\n");
 }
 /**

package/dist/resources/extensions/gsd/working-output-messages.js

@@ -0,0 +1,64 @@
+// GSD-2 + src/resources/extensions/gsd/working-output-messages.ts - Formats and audits user-facing working-state messages.
+const ACTION_RE = /\b(?:wait|pause|paused|retry|retrying|recover|recovering|resume|stop|stopped|run|press|type|configure|restart)\b/i;
+export function formatAutoUnitWorkingMessage(unitType, unitId) {
+    switch (unitType) {
+        case "research-milestone":
+        case "research-slice":
+            return `Researching ${unitId}: waiting for provider response`;
+        case "plan-milestone":
+        case "plan-slice":
+            return `Planning ${unitId}: waiting for provider response`;
+        case "execute-task":
+            return `Executing ${unitId}: waiting for provider response`;
+        case "complete-slice":
+        case "complete-milestone":
+            return `Completing ${unitId}: waiting for provider response`;
+        default:
+            return `${unitType} ${unitId}: waiting for provider response`;
+    }
+}
+export function evaluateWorkingOutputMessage(item) {
+    const findings = [];
+    const message = item.message.trim();
+    const health = item.context?.health;
+    if (!message) {
+        findings.push({
+            code: "empty-message",
+            severity: "error",
+            detail: `${item.surface} message is empty`,
+        });
+        return findings;
+    }
+    if (/^Working(?:\.\.\.)?(?:\s|\(|$)/i.test(message)) {
+        findings.push({
+            code: "generic-working-message",
+            severity: "warning",
+            detail: `${item.surface} message should say what work is running`,
+        });
+    }
+    if (/Progressing well/i.test(message) && health && health !== "healthy") {
+        findings.push({
+            code: "misleading-healthy-message",
+            severity: "error",
+            detail: `${item.surface} says progress is healthy while runtime health is ${health}`,
+        });
+    }
+    if (/\b0\s*\/\s*0\s+slices\b/i.test(message)) {
+        findings.push({
+            code: "fake-zero-progress",
+            severity: "warning",
+            detail: `${item.surface} should hide roadmap progress before roadmap slices exist`,
+        });
+    }
+    if ((health === "stalled" || health === "provider-error" || health === "timeout") && !ACTION_RE.test(message)) {
+        findings.push({
+            code: "missing-action",
+            severity: "warning",
+            detail: `${item.surface} should give the user a next action for ${health}`,
+        });
+    }
+    return findings;
+}
+export function evaluateWorkingOutputMessages(items) {
+    return items.flatMap(evaluateWorkingOutputMessage);
+}