gsd-pi 2.79.0 → 2.80.0-dev.96f4d89d5

package/src/resources/extensions/gsd/uok/contracts.ts

@@ -1,3 +1,9 @@
+// GSD2 UOK Contract Types and Versioning
+
+export const CURRENT_UOK_CONTRACT_VERSION = "1" as const;
+
+export type UokContractVersion = "0" | typeof CURRENT_UOK_CONTRACT_VERSION;
+
 export type FailureClass =
   | "none"
   | "policy"
@@ -77,6 +83,7 @@ export interface TurnCloseoutRecord {
 }
 
 export interface TurnResult {
+  version?: UokContractVersion;
   traceId: string;
   turnId: string;
   iteration: number;
@@ -109,6 +116,7 @@ export interface DispatchExplanation {
 }
 
 export interface UokDispatchEnvelope {
+  version?: UokContractVersion;
   action: "dispatch" | "stop" | "skip";
   nodeKind?: UokNodeKind;
   unitType?: string;
@@ -130,6 +138,7 @@ export interface UokDispatchEnvelope {
 }
 
 export interface AuditEventEnvelope {
+  version?: UokContractVersion;
   eventId: string;
   traceId: string;
   turnId?: string;
@@ -199,3 +208,99 @@ export interface UokTurnObserver {
   ): void;
   onTurnResult(result: TurnResult): void;
 }
+
+export interface ContractValidationIssue {
+  path: string;
+  message: string;
+}
+
+export interface ContractValidationResult<T> {
+  ok: boolean;
+  value: T;
+  issues: ContractValidationIssue[];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function normalizeVersion(value: unknown): UokContractVersion {
+  return value === CURRENT_UOK_CONTRACT_VERSION ? CURRENT_UOK_CONTRACT_VERSION : "0";
+}
+
+function requireString(
+  value: Record<string, unknown>,
+  key: string,
+  issues: ContractValidationIssue[],
+): void {
+  if (typeof value[key] !== "string" || value[key] === "") {
+    issues.push({ path: key, message: `${key} must be a non-empty string` });
+  }
+}
+
+function requireRecord(
+  value: Record<string, unknown>,
+  key: string,
+  issues: ContractValidationIssue[],
+): void {
+  if (!isRecord(value[key])) {
+    issues.push({ path: key, message: `${key} must be an object` });
+  }
+}
+
+export function normalizeTurnResult(value: TurnResult): TurnResult {
+  return { ...value, version: normalizeVersion(value.version) };
+}
+
+export function normalizeDispatchEnvelope(value: UokDispatchEnvelope): UokDispatchEnvelope {
+  return { ...value, version: normalizeVersion(value.version) };
+}
+
+export function normalizeAuditEvent(value: AuditEventEnvelope): AuditEventEnvelope {
+  return { ...value, version: normalizeVersion(value.version) };
+}
+
+export function validateTurnResult(value: TurnResult): ContractValidationResult<TurnResult> {
+  const normalized = normalizeTurnResult(value);
+  const record = normalized as unknown as Record<string, unknown>;
+  const issues: ContractValidationIssue[] = [];
+  requireString(record, "traceId", issues);
+  requireString(record, "turnId", issues);
+  if (!Number.isInteger(record.iteration)) {
+    issues.push({ path: "iteration", message: "iteration must be an integer" });
+  }
+  requireString(record, "status", issues);
+  requireString(record, "failureClass", issues);
+  if (!Array.isArray(record.phaseResults)) {
+    issues.push({ path: "phaseResults", message: "phaseResults must be an array" });
+  }
+  requireString(record, "startedAt", issues);
+  requireString(record, "finishedAt", issues);
+  return { ok: issues.length === 0, value: normalized, issues };
+}
+
+export function validateDispatchEnvelope(value: UokDispatchEnvelope): ContractValidationResult<UokDispatchEnvelope> {
+  const normalized = normalizeDispatchEnvelope(value);
+  const record = normalized as unknown as Record<string, unknown>;
+  const issues: ContractValidationIssue[] = [];
+  requireString(record, "action", issues);
+  requireRecord(record, "reason", issues);
+  if (isRecord(record.reason)) {
+    requireString(record.reason, "reasonCode", issues);
+    requireString(record.reason, "summary", issues);
+  }
+  return { ok: issues.length === 0, value: normalized, issues };
+}
+
+export function validateAuditEvent(value: AuditEventEnvelope): ContractValidationResult<AuditEventEnvelope> {
+  const normalized = normalizeAuditEvent(value);
+  const record = normalized as unknown as Record<string, unknown>;
+  const issues: ContractValidationIssue[] = [];
+  requireString(record, "eventId", issues);
+  requireString(record, "traceId", issues);
+  requireString(record, "category", issues);
+  requireString(record, "type", issues);
+  requireString(record, "ts", issues);
+  requireRecord(record, "payload", issues);
+  return { ok: issues.length === 0, value: normalized, issues };
+}

package/src/resources/extensions/gsd/uok/dispatch-envelope.ts

@@ -1,3 +1,5 @@
+// GSD2 UOK Dispatch Envelope Builder
+
 import type {
   DispatchExplanation,
   DispatchReasonCode,
@@ -5,6 +7,7 @@ import type {
   UokDispatchEnvelope,
   UokGraphNode,
 } from "./contracts.js";
+import { CURRENT_UOK_CONTRACT_VERSION } from "./contracts.js";
 
 export interface BuildDispatchEnvelopeInput {
   action: UokDispatchEnvelope["action"];
@@ -22,6 +25,7 @@ export interface BuildDispatchEnvelopeInput {
 
 export function buildDispatchEnvelope(input: BuildDispatchEnvelopeInput): UokDispatchEnvelope {
   return {
+    version: CURRENT_UOK_CONTRACT_VERSION,
     action: input.action,
     nodeKind: input.node?.kind,
     unitType: input.unitType,

package/src/resources/extensions/gsd/uok/kernel.ts

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Selects the UOK kernel path and records parity diagnostics.
 import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
 import { appendFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
@@ -9,6 +11,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";
 
 interface RunAutoLoopWithUokArgs {
   ctx: ExtensionContext;
@@ -54,10 +57,14 @@ export async function runAutoLoopWithUok(args: RunAutoLoopWithUokArgs): Promise<
   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",
   });
@@ -98,7 +105,7 @@ export async function runAutoLoopWithUok(args: RunAutoLoopWithUokArgs): Promise<
     }
     writeParityEvent(s.basePath, {
       ts: new Date().toISOString(),
-      path: resolveKernelPathLabel(flags),
+      path: pathLabel,
       flags,
       phase: "exit",
       status: "ok",
@@ -106,7 +113,7 @@ export async function runAutoLoopWithUok(args: RunAutoLoopWithUokArgs): Promise<
   } catch (err) {
     writeParityEvent(s.basePath, {
       ts: new Date().toISOString(),
-      path: resolveKernelPathLabel(flags),
+      path: pathLabel,
       flags,
       phase: "exit",
       status: "error",

package/src/resources/extensions/gsd/uok/loop-adapter.ts

@@ -1,9 +1,12 @@
+// GSD2 UOK Turn Observer and DB-Backed Lifecycle Emission
+
 import type {
   TurnCloseoutRecord,
   TurnContract,
   TurnResult,
   UokTurnObserver,
 } from "./contracts.js";
+import { CURRENT_UOK_CONTRACT_VERSION, validateTurnResult } from "./contracts.js";
 import { buildAuditEnvelope, emitUokAuditEvent } from "./audit.js";
 import { writeTurnCloseoutGitRecord, writeTurnGitTransaction } from "./gitops.js";
 import { acquireWriterToken, nextWriteRecord, releaseWriterToken } from "./writer.js";
@@ -142,56 +145,68 @@ export function createTurnObserver(options: CreateTurnObserverOptions): UokTurnO
     },
 
     onTurnResult(result): void {
-      const merged: TurnResult = {
-        ...result,
-        phaseResults: result.phaseResults.length > 0 ? result.phaseResults : [...phaseResults],
+      const cleanup = (): void => {
+        if (writerToken) {
+          releaseWriterToken(options.basePath, writerToken);
+        }
+        writerToken = null;
+        current = null;
+        phaseResults.length = 0;
       };
 
-      if (options.enableAudit) {
-        emitUokAuditEvent(
-          options.basePath,
-          buildAuditEnvelope({
-            traceId: merged.traceId,
-            turnId: merged.turnId,
-            category: "orchestration",
-            type: "turn-result",
-            payload: nextSequenceMetadata("audit", "append", {
-              unitType: merged.unitType,
-              unitId: merged.unitId,
-              status: merged.status,
-              failureClass: merged.failureClass,
-              error: merged.error,
-              phaseCount: merged.phaseResults.length,
-            }),
-          }),
-        );
-      }
-
-      if (options.enableGitops) {
-        const closeout: TurnCloseoutRecord = merged.closeout ?? {
-          traceId: merged.traceId,
-          turnId: merged.turnId,
-          unitType: merged.unitType,
-          unitId: merged.unitId,
-          status: merged.status,
-          failureClass: merged.failureClass,
-          gitAction: options.gitAction,
-          gitPushed: options.gitPush,
-          finishedAt: merged.finishedAt,
+      try {
+        const merged: TurnResult = {
+          ...result,
+          version: CURRENT_UOK_CONTRACT_VERSION,
+          phaseResults: Array.isArray(result.phaseResults) && result.phaseResults.length > 0 ? result.phaseResults : [...phaseResults],
         };
-        writeTurnCloseoutGitRecord(
-          options.basePath,
-          closeout,
-          nextSequenceMetadata("gitops", "update", { action: "record" }),
-        );
-      }
+        const validation = validateTurnResult(merged);
+        if (!validation.ok) {
+          throw new Error(`Invalid UOK turn result: ${validation.issues.map((issue) => `${issue.path}: ${issue.message}`).join("; ")}`);
+        }
 
-      if (writerToken) {
-        releaseWriterToken(options.basePath, writerToken);
+        if (options.enableAudit) {
+          emitUokAuditEvent(
+            options.basePath,
+            buildAuditEnvelope({
+              traceId: validation.value.traceId,
+              turnId: validation.value.turnId,
+              category: "orchestration",
+              type: "turn-result",
+              payload: nextSequenceMetadata("audit", "append", {
+                contractVersion: validation.value.version,
+                unitType: validation.value.unitType,
+                unitId: validation.value.unitId,
+                status: validation.value.status,
+                failureClass: validation.value.failureClass,
+                error: validation.value.error,
+                phaseCount: validation.value.phaseResults.length,
+              }),
+            }),
+          );
+        }
+
+        if (options.enableGitops) {
+          const closeout: TurnCloseoutRecord = merged.closeout ?? {
+            traceId: merged.traceId,
+            turnId: merged.turnId,
+            unitType: merged.unitType,
+            unitId: merged.unitId,
+            status: merged.status,
+            failureClass: merged.failureClass,
+            gitAction: options.gitAction,
+            gitPushed: options.gitPush,
+            finishedAt: merged.finishedAt,
+          };
+          writeTurnCloseoutGitRecord(
+            options.basePath,
+            closeout,
+            nextSequenceMetadata("gitops", "update", { action: "record" }),
+          );
+        }
+      } finally {
+        cleanup();
       }
-      writerToken = null;
-      current = null;
-      phaseResults.length = 0;
     },
   };
 }

package/src/resources/extensions/gsd/uok/plan-v2.ts

@@ -1,9 +1,13 @@
+// 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 type { GSDState, Phase } from "../types.js";
 import { gsdRoot, resolveMilestoneFile, resolveSliceFile } from "../paths.js";
-import { isDbAvailable, getMilestoneSlices, getSliceTasks, type SliceRow } from "../gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "../gsd-db.js";
+import type { SliceRow } from "../db-task-slice-rows.js";
 import type { UokGraphNode } from "./contracts.js";
 
 const PLAN_V2_CLARIFY_ROUND_LIMIT = 3;

package/src/resources/extensions/gsd/uok/timeline.ts

@@ -0,0 +1,158 @@
+// GSD2 UOK Timeline Reconstruction from Authoritative DB Records
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { _getAdapter, isDbAvailable } from "../gsd-db.js";
+import { gsdRoot } from "../paths.js";
+
+export interface TurnTimelineFilter {
+  traceId?: string;
+  turnId?: string;
+}
+
+export interface TurnTimelineEntry {
+  source: "audit_events" | "unit_dispatches" | "turn_git_transactions" | "audit_jsonl";
+  ts: string;
+  traceId?: string;
+  turnId?: string | null;
+  type: string;
+  payload: Record<string, unknown>;
+}
+
+export interface TurnTimeline {
+  authoritative: "db" | "degraded-fallback";
+  degraded: boolean;
+  entries: TurnTimelineEntry[];
+}
+
+function parseJsonRecord(value: unknown): Record<string, unknown> {
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    return value as Record<string, unknown>;
+  }
+  if (typeof value !== "string" || value.trim() === "") return {};
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+      ? parsed as Record<string, unknown>
+      : {};
+  } catch {
+    return {};
+  }
+}
+
+function matchesFilter(entry: Pick<TurnTimelineEntry, "traceId" | "turnId">, filter: TurnTimelineFilter): boolean {
+  if (filter.traceId && entry.traceId !== filter.traceId) return false;
+  if (filter.turnId && entry.turnId !== filter.turnId) return false;
+  return true;
+}
+
+function byTimestamp(a: TurnTimelineEntry, b: TurnTimelineEntry): number {
+  return a.ts.localeCompare(b.ts);
+}
+
+function readDbTimeline(filter: TurnTimelineFilter): TurnTimelineEntry[] {
+  const db = _getAdapter();
+  if (!db) return [];
+  const entries: TurnTimelineEntry[] = [];
+  const where: string[] = [];
+  const params: Record<string, string> = {};
+  if (filter.traceId) {
+    where.push("trace_id = :trace_id");
+    params[":trace_id"] = filter.traceId;
+  }
+  if (filter.turnId) {
+    where.push("turn_id = :turn_id");
+    params[":turn_id"] = filter.turnId;
+  }
+  const suffix = where.length > 0 ? ` WHERE ${where.join(" AND ")}` : "";
+
+  const auditRows = db.prepare(
+    `SELECT trace_id, turn_id, type, ts, payload_json FROM audit_events${suffix}`,
+  ).all(params) as Array<{ trace_id: string; turn_id: string | null; type: string; ts: string; payload_json: string }>;
+  for (const row of auditRows) {
+    entries.push({
+      source: "audit_events",
+      ts: row.ts,
+      traceId: row.trace_id,
+      turnId: row.turn_id,
+      type: row.type,
+      payload: parseJsonRecord(row.payload_json),
+    });
+  }
+
+  const dispatchRows = db.prepare(
+    `SELECT trace_id, turn_id, unit_type, unit_id, status, started_at, ended_at, exit_reason,
+            error_summary, retry_after_ms, attempt_n, max_attempts
+     FROM unit_dispatches${suffix}`,
+  ).all(params) as Array<Record<string, unknown>>;
+  for (const row of dispatchRows) {
+    entries.push({
+      source: "unit_dispatches",
+      ts: String(row.ended_at ?? row.started_at ?? ""),
+      traceId: String(row.trace_id ?? ""),
+      turnId: typeof row.turn_id === "string" ? row.turn_id : null,
+      type: `dispatch-${String(row.status ?? "unknown")}`,
+      payload: { ...row },
+    });
+  }
+
+  const gitRows = db.prepare(
+    `SELECT trace_id, turn_id, unit_type, unit_id, stage, action, push, status, error,
+            metadata_json, updated_at
+     FROM turn_git_transactions${suffix}`,
+  ).all(params) as Array<Record<string, unknown>>;
+  for (const row of gitRows) {
+    entries.push({
+      source: "turn_git_transactions",
+      ts: String(row.updated_at ?? ""),
+      traceId: String(row.trace_id ?? ""),
+      turnId: typeof row.turn_id === "string" ? row.turn_id : null,
+      type: `gitops-${String(row.stage ?? "unknown")}`,
+      payload: {
+        ...row,
+        metadata: parseJsonRecord(row.metadata_json),
+      },
+    });
+  }
+
+  return entries.filter((entry) => entry.ts !== "").sort(byTimestamp);
+}
+
+function readJsonlTimeline(basePath: string, filter: TurnTimelineFilter): TurnTimelineEntry[] {
+  const path = join(gsdRoot(basePath), "audit", "events.jsonl");
+  if (!existsSync(path)) return [];
+  return readFileSync(path, "utf-8")
+    .split("\n")
+    .filter(Boolean)
+    .map((line): TurnTimelineEntry | null => {
+      const event = parseJsonRecord(line);
+      const entry: TurnTimelineEntry = {
+        source: "audit_jsonl",
+        ts: String(event.ts ?? ""),
+        traceId: typeof event.traceId === "string" ? event.traceId : undefined,
+        turnId: typeof event.turnId === "string" ? event.turnId : null,
+        type: String(event.type ?? "audit"),
+        payload: parseJsonRecord(event.payload),
+      };
+      return entry.ts && matchesFilter(entry, filter) ? entry : null;
+    })
+    .filter((entry): entry is TurnTimelineEntry => entry !== null)
+    .sort(byTimestamp);
+}
+
+export function buildTurnTimeline(basePath: string, filter: TurnTimelineFilter = {}): TurnTimeline {
+  if (isDbAvailable()) {
+    return {
+      authoritative: "db",
+      degraded: false,
+      entries: readDbTimeline(filter),
+    };
+  }
+
+  return {
+    authoritative: "degraded-fallback",
+    degraded: true,
+    entries: readJsonlTimeline(basePath, filter),
+  };
+}

package/src/resources/extensions/gsd/workflow-logger.ts

@@ -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
@@ -109,7 +108,8 @@ export function setStderrLoggingEnabled(enabled: boolean): boolean {
 // ─── 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: LogComponent,
@@ -271,10 +271,10 @@ function _push(
     ...(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 {
@@ -317,8 +317,8 @@ function _push(
   }
 
   // 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/src/resources/extensions/gsd/workflow-manifest.ts

@@ -1,11 +1,14 @@
+// Project/App: GSD-2
+// File Purpose: State manifest snapshot and restore orchestration for GSD workflow data.
+
 import {
   _getAdapter,
   readTransaction,
   restoreManifest,
-  type MilestoneRow,
-  type SliceRow,
-  type TaskRow,
 } from "./gsd-db.js";
+import type { MilestoneRow } from "./db-milestone-artifact-rows.js";
+import type { SliceRow, TaskRow } from "./db-task-slice-rows.js";
+import type { VerificationEvidenceRow } from "./db-verification-evidence-rows.js";
 import type { Decision } from "./types.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { readFileSync, existsSync, mkdirSync } from "node:fs";
@@ -13,18 +16,6 @@ import { join } from "node:path";
 
 // ─── Manifest Types ──────────────────────────────────────────────────────
 
-export interface VerificationEvidenceRow {
-  id: number;
-  task_id: string;
-  slice_id: string;
-  milestone_id: string;
-  command: string;
-  exit_code: number | null;
-  verdict: string;
-  duration_ms: number | null;
-  created_at: string;
-}
-
 export interface StateManifest {
   version: 1;
   exported_at: string; // ISO 8601

package/src/resources/extensions/gsd/workflow-projections.ts

@@ -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).
@@ -11,7 +13,9 @@ import {
   getSliceTasks,
   getVerificationEvidence,
 } from "./gsd-db.js";
-import type { MilestoneRow, SliceRow, TaskRow, VerificationEvidenceRow } from "./gsd-db.js";
+import type { MilestoneRow } from "./db-milestone-artifact-rows.js";
+import type { SliceRow, TaskRow } from "./db-task-slice-rows.js";
+import type { VerificationEvidenceRow } from "./db-verification-evidence-rows.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { join } from "node:path";
 import { mkdirSync, existsSync } from "node:fs";

package/src/resources/extensions/gsd/workflow-templates.ts

@@ -1,3 +1,6 @@
+// Project/App: GSD-2
+// File Purpose: Workflow template registry loading, matching, and display helpers.
+
 /**
  * GSD Workflow Templates — Registry & Resolution
  *
@@ -9,6 +12,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");
@@ -30,6 +34,10 @@ export type WorkflowMode =
   | "markdown-phase"
   | "auto-milestone";
 
+export function isLegacyWorkflowMode(mode: WorkflowMode | undefined): boolean {
+  return (mode ?? "markdown-phase") !== "auto-milestone";
+}
+
 export interface TemplateEntry {
   name: string;
   description: string;
@@ -213,6 +221,9 @@ export function listTemplates(): string {
 
   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");
 }