gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

package/src/resources/extensions/gsd/undo.ts

@@ -1,5 +1,7 @@
-// GSD Extension — Undo Last Unit
-// Rollback the most recent completed unit: revert git, remove state, uncheck plans.
+// GSD Extension — Undo Last Unit + Targeted State Reset
+// handleUndo: Rollback the most recent completed unit (revert git, remove state, uncheck plans).
+// handleUndoTask: Reset a single task's DB status to "pending" and re-render markdown.
+// handleResetSlice: Reset a slice and all its tasks, re-rendering plan + roadmap.
 
 import type { ExtensionCommandContext, ExtensionAPI } from "@gsd/pi-coding-agent";
 import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from "node:fs";
@@ -7,8 +9,10 @@ import { join } from "node:path";
 import { nativeRevertCommit, nativeRevertAbort } from "./native-git-bridge.js";
 import { deriveState } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
-import { gsdRoot, resolveTasksDir, resolveSlicePath, buildTaskFileName } from "./paths.js";
+import { gsdRoot, resolveTasksDir, resolveSlicePath, resolveTaskFile, buildTaskFileName, buildSliceFileName } from "./paths.js";
 import { sendDesktopNotification } from "./notifications.js";
+import { getTask, getSlice, getSliceTasks, updateTaskStatus, updateSliceStatus } from "./gsd-db.js";
+import { renderPlanCheckboxes, renderRoadmapCheckboxes } from "./markdown-renderer.js";
 
 /**
  * Undo the last completed unit: revert git commits,
@@ -131,6 +135,246 @@ export async function handleUndo(args: string, ctx: ExtensionCommandContext, _pi
   sendDesktopNotification("GSD", `Undone: ${unitType} (${unitId})`, "info", "complete");
 }
 
+// ─── Targeted State Reset ────────────────────────────────────────────────────
+
+/**
+ * Parse a task identifier from args. Accepts:
+ *   T01, S01/T01, M001/S01/T01
+ * Resolves missing parts from current state via deriveState().
+ */
+async function parseTaskId(
+  raw: string,
+  basePath: string,
+): Promise<{ mid: string; sid: string; tid: string } | string> {
+  const parts = raw.split("/");
+  if (parts.length === 3) {
+    return { mid: parts[0], sid: parts[1], tid: parts[2] };
+  }
+  // Need to resolve from state
+  const state = await deriveState(basePath);
+  if (parts.length === 2) {
+    // S01/T01 — resolve milestone
+    const mid = state.activeMilestone?.id;
+    if (!mid) return "Cannot resolve milestone — no active milestone in state.";
+    return { mid, sid: parts[0], tid: parts[1] };
+  }
+  if (parts.length === 1) {
+    // T01 — resolve milestone + slice
+    const mid = state.activeMilestone?.id;
+    const sid = state.activeSlice?.id;
+    if (!mid) return "Cannot resolve milestone — no active milestone in state.";
+    if (!sid) return "Cannot resolve slice — no active slice in state.";
+    return { mid, sid, tid: parts[0] };
+  }
+  return "Invalid task ID format. Use T01, S01/T01, or M001/S01/T01.";
+}
+
+/**
+ * Parse a slice identifier from args. Accepts:
+ *   S01, M001/S01
+ * Resolves missing milestone from current state.
+ */
+async function parseSliceId(
+  raw: string,
+  basePath: string,
+): Promise<{ mid: string; sid: string } | string> {
+  const parts = raw.split("/");
+  if (parts.length === 2) {
+    return { mid: parts[0], sid: parts[1] };
+  }
+  if (parts.length === 1) {
+    const state = await deriveState(basePath);
+    const mid = state.activeMilestone?.id;
+    if (!mid) return "Cannot resolve milestone — no active milestone in state.";
+    return { mid, sid: parts[0] };
+  }
+  return "Invalid slice ID format. Use S01 or M001/S01.";
+}
+
+/**
+ * Reset a single task's completion state:
+ * - Set DB status to "pending"
+ * - Delete the task summary file
+ * - Re-render plan checkboxes
+ */
+export async function handleUndoTask(
+  args: string,
+  ctx: ExtensionCommandContext,
+  _pi: ExtensionAPI,
+  basePath: string,
+): Promise<void> {
+  const force = args.includes("--force");
+  const rawId = args.replace("--force", "").trim();
+
+  if (!rawId) {
+    ctx.ui.notify(
+      "Usage: /gsd undo-task <taskId> [--force]\n\n" +
+      "Accepts: T01, S01/T01, or M001/S01/T01\n" +
+      "Resets the task's DB status to pending and re-renders plan checkboxes.",
+      "warning",
+    );
+    return;
+  }
+
+  const parsed = await parseTaskId(rawId, basePath);
+  if (typeof parsed === "string") {
+    ctx.ui.notify(parsed, "error");
+    return;
+  }
+
+  const { mid, sid, tid } = parsed;
+
+  // Validate task exists in DB
+  const task = getTask(mid, sid, tid);
+  if (!task) {
+    ctx.ui.notify(`Task ${mid}/${sid}/${tid} not found in database.`, "error");
+    return;
+  }
+
+  if (!force) {
+    ctx.ui.notify(
+      `Will reset: task ${mid}/${sid}/${tid}\n` +
+      `  Current status: ${task.status}\n` +
+      `This will:\n` +
+      `  - Set task status to "pending" in DB\n` +
+      `  - Delete task summary file (if exists)\n` +
+      `  - Re-render plan checkboxes\n\n` +
+      `Run /gsd undo-task ${rawId} --force to confirm.`,
+      "warning",
+    );
+    return;
+  }
+
+  // Reset DB status
+  updateTaskStatus(mid, sid, tid, "pending");
+
+  // Delete summary file
+  let summaryDeleted = false;
+  const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
+  if (summaryPath && existsSync(summaryPath)) {
+    unlinkSync(summaryPath);
+    summaryDeleted = true;
+  }
+
+  // Re-render plan checkboxes
+  await renderPlanCheckboxes(basePath, mid, sid);
+
+  // Invalidate caches
+  invalidateAllCaches();
+
+  const results: string[] = [`Reset task ${mid}/${sid}/${tid} to "pending".`];
+  if (summaryDeleted) results.push("  - Deleted task summary file");
+  results.push("  - Plan checkboxes re-rendered");
+
+  ctx.ui.notify(results.join("\n"), "success");
+}
+
+/**
+ * Reset a slice and all its tasks:
+ * - Set all task DB statuses to "pending"
+ * - Set slice DB status to "active"
+ * - Delete task summary files, slice summary, and UAT files
+ * - Re-render plan + roadmap checkboxes
+ */
+export async function handleResetSlice(
+  args: string,
+  ctx: ExtensionCommandContext,
+  _pi: ExtensionAPI,
+  basePath: string,
+): Promise<void> {
+  const force = args.includes("--force");
+  const rawId = args.replace("--force", "").trim();
+
+  if (!rawId) {
+    ctx.ui.notify(
+      "Usage: /gsd reset-slice <sliceId> [--force]\n\n" +
+      "Accepts: S01 or M001/S01\n" +
+      "Resets the slice and all its tasks, re-renders plan + roadmap checkboxes.",
+      "warning",
+    );
+    return;
+  }
+
+  const parsed = await parseSliceId(rawId, basePath);
+  if (typeof parsed === "string") {
+    ctx.ui.notify(parsed, "error");
+    return;
+  }
+
+  const { mid, sid } = parsed;
+
+  // Validate slice exists in DB
+  const slice = getSlice(mid, sid);
+  if (!slice) {
+    ctx.ui.notify(`Slice ${mid}/${sid} not found in database.`, "error");
+    return;
+  }
+
+  const tasks = getSliceTasks(mid, sid);
+
+  if (!force) {
+    ctx.ui.notify(
+      `Will reset: slice ${mid}/${sid}\n` +
+      `  Current status: ${slice.status}\n` +
+      `  Tasks to reset: ${tasks.length}\n` +
+      `This will:\n` +
+      `  - Set all task statuses to "pending" in DB\n` +
+      `  - Set slice status to "active" in DB\n` +
+      `  - Delete task summary files, slice summary, and UAT files\n` +
+      `  - Re-render plan + roadmap checkboxes\n\n` +
+      `Run /gsd reset-slice ${rawId} --force to confirm.`,
+      "warning",
+    );
+    return;
+  }
+
+  // Reset all tasks
+  let tasksReset = 0;
+  let summariesDeleted = 0;
+  for (const t of tasks) {
+    updateTaskStatus(mid, sid, t.id, "pending");
+    tasksReset++;
+    const summaryPath = resolveTaskFile(basePath, mid, sid, t.id, "SUMMARY");
+    if (summaryPath && existsSync(summaryPath)) {
+      unlinkSync(summaryPath);
+      summariesDeleted++;
+    }
+  }
+
+  // Reset slice status
+  updateSliceStatus(mid, sid, "active");
+
+  // Delete slice summary and UAT files
+  let sliceFilesDeleted = 0;
+  const slicePath = resolveSlicePath(basePath, mid, sid);
+  if (slicePath) {
+    for (const suffix of ["SUMMARY", "UAT"]) {
+      const filePath = join(slicePath, buildSliceFileName(sid, suffix));
+      if (existsSync(filePath)) {
+        unlinkSync(filePath);
+        sliceFilesDeleted++;
+      }
+    }
+  }
+
+  // Re-render plan + roadmap checkboxes
+  await renderPlanCheckboxes(basePath, mid, sid);
+  await renderRoadmapCheckboxes(basePath, mid);
+
+  // Invalidate caches
+  invalidateAllCaches();
+
+  const results: string[] = [
+    `Reset slice ${mid}/${sid} to "active".`,
+    `  - ${tasksReset} task(s) reset to "pending"`,
+  ];
+  if (summariesDeleted > 0) results.push(`  - ${summariesDeleted} task summary file(s) deleted`);
+  if (sliceFilesDeleted > 0) results.push(`  - ${sliceFilesDeleted} slice file(s) deleted (summary/UAT)`);
+  results.push("  - Plan + roadmap checkboxes re-rendered");
+
+  ctx.ui.notify(results.join("\n"), "success");
+}
+
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
 export function uncheckTaskInPlan(basePath: string, mid: string, sid: string, tid: string): boolean {

package/src/resources/extensions/gsd/visualizer-data.ts

@@ -3,7 +3,9 @@
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { deriveState } from './state.js';
-import { parseRoadmap, parsePlan, parseSummary, loadFile } from './files.js';
+import { parseSummary, loadFile } from './files.js';
+import { isDbAvailable, getMilestoneSlices, getSliceTasks } from './gsd-db.js';
+import { parseRoadmap, parsePlan } from './parsers-legacy.js';
 import { findMilestoneIds } from './milestone-ids.js';
 import { resolveMilestoneFile, resolveSliceFile, resolveGsdRootFile, gsdRoot } from './paths.js';
 import {
@@ -796,10 +798,24 @@ export async function loadVisualizerData(basePath: string): Promise<VisualizerDa
     const roadmapFile = resolveMilestoneFile(basePath, mid, 'ROADMAP');
     const roadmapContent = roadmapFile ? readFileCached(roadmapFile) : null;
 
-    if (roadmapContent) {
-      const roadmap = parseRoadmap(roadmapContent);
+    if (roadmapContent || isDbAvailable()) {
+      // Normalize slices from DB, fall back to file-based parsing when DB has no data
+      type NormSlice = { id: string; done: boolean; title: string; risk: string; depends: string[]; demo: string };
+      let normSlices: NormSlice[] | null = null;
+      if (isDbAvailable()) {
+        const dbSlices = getMilestoneSlices(mid);
+        if (dbSlices.length > 0) {
+          normSlices = dbSlices.map(s => ({ id: s.id, done: s.status === 'complete', title: s.title, risk: s.risk || 'medium', depends: s.depends, demo: s.demo }));
+        }
+      }
+      if (!normSlices && roadmapContent) {
+        // File-based fallback: parse roadmap for slice entries
+        const parsed = parseRoadmap(roadmapContent);
+        normSlices = parsed.slices.map(s => ({ id: s.id, done: s.done, title: s.title, risk: s.risk || 'medium', depends: s.depends, demo: '' }));
+      }
+      if (!normSlices) normSlices = [];
 
-      for (const s of roadmap.slices) {
+      for (const s of normSlices) {
         const isActiveSlice =
           state.activeMilestone?.id === mid &&
           state.activeSlice?.id === s.id;
@@ -807,19 +823,40 @@ export async function loadVisualizerData(basePath: string): Promise<VisualizerDa
         const tasks: VisualizerTask[] = [];
 
         if (isActiveSlice) {
-          const planFile = resolveSliceFile(basePath, mid, s.id, 'PLAN');
-          const planContent = planFile ? readFileCached(planFile) : null;
-
-          if (planContent) {
-            const plan = parsePlan(planContent);
-            for (const t of plan.tasks) {
-              tasks.push({
-                id: t.id,
-                title: t.title,
-                done: t.done,
-                active: state.activeTask?.id === t.id,
-                estimate: t.estimate || undefined,
-              });
+          // Normalize tasks from DB, fall back to file parsing when DB has no data
+          let usedDbTasks = false;
+          if (isDbAvailable()) {
+            const dbTasks = getSliceTasks(mid, s.id);
+            if (dbTasks.length > 0) {
+              usedDbTasks = true;
+              for (const t of dbTasks) {
+                tasks.push({
+                  id: t.id,
+                  title: t.title,
+                  done: t.status === 'complete' || t.status === 'done',
+                  active: state.activeTask?.id === t.id,
+                  estimate: t.estimate || undefined,
+                });
+              }
+            }
+          }
+          if (!usedDbTasks) {
+            // File-based fallback: parse slice plan for task entries
+            const slicePlanFile = resolveSliceFile(basePath, mid, s.id, 'PLAN');
+            if (slicePlanFile) {
+              const planContent = readFileCached(slicePlanFile);
+              if (planContent) {
+                const parsed = parsePlan(planContent);
+                for (const t of parsed.tasks) {
+                  tasks.push({
+                    id: t.id,
+                    title: t.title,
+                    done: t.done,
+                    active: state.activeTask?.id === t.id,
+                    estimate: t.estimate || undefined,
+                  });
+                }
+              }
             }
           }
         }

package/src/resources/extensions/gsd/workspace-index.ts

@@ -1,6 +1,8 @@
 import { join } from "node:path";
 
-import { loadFile, parsePlan, parseRoadmap } from "./files.js";
+import { loadFile } from "./files.js";
+import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
+import { parseRoadmap, parsePlan } from "./parsers-legacy.js";
 import {
   resolveMilestoneFile,
   resolveSliceFile,
@@ -11,7 +13,6 @@ import {
 import { deriveState } from "./state.js";
 import { milestoneIdSort, findMilestoneIds } from "./guided-flow.js";
 import type { RiskLevel } from "./types.js";
-import { type ValidationIssue, validateCompleteBoundary, validatePlanBoundary } from "./observability-validator.js";
 import { getSliceBranchName, detectWorktreeName } from "./worktree.js";
 
 export interface WorkspaceTaskTarget {
@@ -59,13 +60,15 @@ export interface GSDWorkspaceIndex {
     phase: string;
   };
   scopes: WorkspaceScopeTarget[];
-  validationIssues: ValidationIssue[];
+  validationIssues: Array<Record<string, unknown>>;
 }
 
-
+// Extract milestone title from roadmap header without using parsers.
+// Falls back to the milestone ID if no title line found.
 function titleFromRoadmapHeader(content: string, fallbackId: string): string {
-  const roadmap = parseRoadmap(content);
-  return roadmap.title.replace(/^M\d+(?:-[a-z0-9]{6})?[^:]*:\s*/, "") || fallbackId;
+  // Parse the "# M001: Title" header directly
+  const match = content.match(/^#\s+M\d+(?:-[a-z0-9]{6})?[^:]*:\s*(.+)/m);
+  return match?.[1]?.trim() || fallbackId;
 }
 
 async function indexSlice(basePath: string, milestoneId: string, sliceId: string, fallbackTitle: string, done: boolean, roadmapMeta?: { risk?: RiskLevel; depends?: string[]; demo?: string }): Promise<WorkspaceSliceTarget> {
@@ -77,12 +80,30 @@ async function indexSlice(basePath: string, milestoneId: string, sliceId: string
   const tasks: WorkspaceTaskTarget[] = [];
   let title = fallbackTitle;
 
-  if (planPath) {
-    const content = await loadFile(planPath);
-    if (content) {
-      const plan = parsePlan(content);
-      title = plan.title || fallbackTitle;
-      for (const task of plan.tasks) {
+  // Prefer DB for task data, fall back to file parsing when DB has no data
+  let usedDb = false;
+  if (isDbAvailable()) {
+    const dbTasks = getSliceTasks(milestoneId, sliceId);
+    if (dbTasks.length > 0) {
+      usedDb = true;
+      for (const task of dbTasks) {
+        title = fallbackTitle; // title comes from slice-level data, not plan
+        tasks.push({
+          id: task.id,
+          title: task.title,
+          done: task.status === "complete" || task.status === "done",
+          planPath: resolveTaskFile(basePath, milestoneId, sliceId, task.id, "PLAN") ?? undefined,
+          summaryPath: resolveTaskFile(basePath, milestoneId, sliceId, task.id, "SUMMARY") ?? undefined,
+        });
+      }
+    }
+  }
+  if (!usedDb && planPath) {
+    // File-based fallback: parse slice plan for task entries
+    const planContent = await loadFile(planPath);
+    if (planContent) {
+      const parsed = parsePlan(planContent);
+      for (const task of parsed.tasks) {
         tasks.push({
           id: task.id,
           title: task.title,
@@ -111,53 +132,52 @@ async function indexSlice(basePath: string, milestoneId: string, sliceId: string
 }
 
 export interface IndexWorkspaceOptions {
-  /**
-   * When true, run validatePlanBoundary and validateCompleteBoundary for each slice.
-   * Skipped by default — validation is expensive (content analysis) and only needed
-   * for explicit doctor/audit flows. The /gsd status dashboard and scope pickers
-   * don't need the full issue list.
-   */
   validate?: boolean;
 }
 
 export async function indexWorkspace(basePath: string, opts: IndexWorkspaceOptions = {}): Promise<GSDWorkspaceIndex> {
   const milestoneIds = findMilestoneIds(basePath);
   const milestones: WorkspaceMilestoneTarget[] = [];
-  const validationIssues: ValidationIssue[] = [];
-  const runValidation = opts.validate === true;
 
   for (const milestoneId of milestoneIds) {
     const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP") ?? undefined;
     let title = milestoneId;
     const slices: WorkspaceSliceTarget[] = [];
 
-    if (roadmapPath) {
-      const roadmapContent = await loadFile(roadmapPath);
-      if (roadmapContent) {
-        const roadmap = parseRoadmap(roadmapContent);
-        title = titleFromRoadmapHeader(roadmapContent, milestoneId);
+    if (roadmapPath || isDbAvailable()) {
+      // Normalize slices from DB, fall back to file-based parsing when DB has no data
+      type NormSlice = { id: string; done: boolean; title: string; risk: string; depends: string[]; demo: string };
+      let normSlices: NormSlice[] | null = null;
+      if (isDbAvailable()) {
+        const dbSlices = getMilestoneSlices(milestoneId);
+        if (dbSlices.length > 0) {
+          normSlices = dbSlices.map(s => ({ id: s.id, done: s.status === "complete", title: s.title, risk: s.risk || "medium", depends: s.depends, demo: s.demo }));
+        }
+        // Get title from roadmap header
+        if (roadmapPath) {
+          const roadmapContent = await loadFile(roadmapPath);
+          if (roadmapContent) title = titleFromRoadmapHeader(roadmapContent, milestoneId);
+        }
+      }
+      if (!normSlices && roadmapPath) {
+        // File-based fallback: parse roadmap for slice entries
+        const roadmapContent = await loadFile(roadmapPath);
+        if (roadmapContent) {
+          title = titleFromRoadmapHeader(roadmapContent, milestoneId);
+          const parsed = parseRoadmap(roadmapContent);
+          normSlices = parsed.slices.map(s => ({ id: s.id, done: s.done, title: s.title, risk: s.risk || "medium", depends: s.depends, demo: s.demo || "" }));
+        }
+      }
+      if (!normSlices) normSlices = [];
 
-        // Parallelise all per-slice I/O: indexSlice + (optional) validation calls run concurrently.
-        // Order is preserved via Promise.all on an array built from roadmap.slices.
+      if (normSlices.length > 0) {
         const sliceResults = await Promise.all(
-          roadmap.slices.map(async (slice) => {
-            if (runValidation) {
-              const [indexedSlice, planIssues, completeIssues] = await Promise.all([
-                indexSlice(basePath, milestoneId, slice.id, slice.title, slice.done, { risk: slice.risk, depends: slice.depends, demo: slice.demo }),
-                validatePlanBoundary(basePath, milestoneId, slice.id),
-                validateCompleteBoundary(basePath, milestoneId, slice.id),
-              ]);
-              return { indexedSlice, issues: [...planIssues, ...completeIssues] };
-            }
-            const indexedSlice = await indexSlice(basePath, milestoneId, slice.id, slice.title, slice.done, { risk: slice.risk, depends: slice.depends, demo: slice.demo });
-            return { indexedSlice, issues: [] as ValidationIssue[] };
+          normSlices.map(async (slice) => {
+            return indexSlice(basePath, milestoneId, slice.id, slice.title, slice.done, { risk: slice.risk as RiskLevel, depends: slice.depends, demo: slice.demo });
           }),
         );
 
-        for (const { indexedSlice, issues } of sliceResults) {
-          slices.push(indexedSlice);
-          validationIssues.push(...issues);
-        }
+        slices.push(...sliceResults);
       }
     }
 
@@ -187,7 +207,7 @@ export async function indexWorkspace(basePath: string, opts: IndexWorkspaceOptio
     }
   }
 
-  return { milestones, active, scopes, validationIssues };
+  return { milestones, active, scopes, validationIssues: [] };
 }
 
 export async function listDoctorScopeSuggestions(basePath: string): Promise<Array<{ value: string; label: string }>> {
@@ -207,8 +227,7 @@ export async function listDoctorScopeSuggestions(basePath: string): Promise<Arra
 }
 
 export async function getSuggestedNextCommands(basePath: string): Promise<string[]> {
-  // Run validation here since we surface a /gsd doctor audit hint when issues exist.
-  const index = await indexWorkspace(basePath, { validate: true });
+  const index = await indexWorkspace(basePath);
   const scope = index.active.milestoneId && index.active.sliceId
     ? `${index.active.milestoneId}/${index.active.sliceId}`
     : index.active.milestoneId;
@@ -218,7 +237,6 @@ export async function getSuggestedNextCommands(basePath: string): Promise<string
   if (index.active.phase === "executing" || index.active.phase === "summarizing") commands.add("/gsd auto");
   if (scope) commands.add(`/gsd doctor ${scope}`);
   if (scope) commands.add(`/gsd doctor fix ${scope}`);
-  if (index.validationIssues.length > 0 && scope) commands.add(`/gsd doctor audit ${scope}`);
   commands.add("/gsd status");
   return [...commands];
 }

package/dist/resources/extensions/gsd/auto-observability.js

@@ -1,56 +0,0 @@
-/**
- * Pre-dispatch observability checks for auto-mode units.
- * Validates plan/summary file quality and builds repair instructions
- * for the agent to fix gaps before proceeding with the unit.
- */
-import { validatePlanBoundary, validateExecuteBoundary, validateCompleteBoundary, formatValidationIssues, } from "./observability-validator.js";
-export async function collectObservabilityWarnings(ctx, basePath, unitType, unitId) {
-    // Hook units have custom artifacts — skip standard observability checks
-    if (unitType.startsWith("hook/"))
-        return [];
-    const parts = unitId.split("/");
-    const mid = parts[0];
-    const sid = parts[1];
-    const tid = parts[2];
-    if (!mid || !sid)
-        return [];
-    let issues = [];
-    if (unitType === "plan-slice") {
-        issues = await validatePlanBoundary(basePath, mid, sid);
-    }
-    else if (unitType === "execute-task" && tid) {
-        issues = await validateExecuteBoundary(basePath, mid, sid, tid);
-    }
-    else if (unitType === "complete-slice") {
-        issues = await validateCompleteBoundary(basePath, mid, sid);
-    }
-    if (issues.length > 0) {
-        ctx.ui.notify(`Observability check (${unitType}) found ${issues.length} warning${issues.length === 1 ? "" : "s"}:\n${formatValidationIssues(issues)}`, "warning");
-    }
-    return issues;
-}
-export function buildObservabilityRepairBlock(issues) {
-    if (issues.length === 0)
-        return "";
-    const items = issues.map(issue => {
-        const fileName = issue.file.split("/").pop() || issue.file;
-        let line = `- **${fileName}**: ${issue.message}`;
-        if (issue.suggestion)
-            line += ` → ${issue.suggestion}`;
-        return line;
-    });
-    return [
-        "",
-        "---",
-        "",
-        "## Pre-flight: Observability gaps to fix FIRST",
-        "",
-        "The following issues were detected in plan/summary files for this unit.",
-        "**Read each flagged file, apply the fix described, then proceed with the unit.**",
-        "",
-        ...items,
-        "",
-        "---",
-        "",
-    ].join("\n");
-}