@opengsd/gsd-pi 1.2.0-dev.fbdca60b → 1.3.0-dev.65546769

package/src/resources/extensions/gsd/tools/validate-milestone.ts

@@ -20,7 +20,7 @@ import {
   getMilestoneSlices,
   getMilestone,
 } from "../gsd-db.js";
-import { gsdProjectionRoot, clearPathCache } from "../paths.js";
+import { gsdProjectionRoot, clearPathCache, relMilestoneFile } from "../paths.js";
 import { resolveCanonicalMilestoneRoot } from "../worktree-manager.js";
 import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { saveFile, clearParseCache } from "../files.js";
@@ -160,12 +160,11 @@ export async function handleValidateMilestone(
   // worktree exists for this milestone, validation reads/writes the
   // worktree's artifacts instead of stale project-root state.
   const validationMd = renderValidationMarkdown(effectiveParams);
-  const validationPath = join(
-    gsdProjectionRoot(artifactBasePath),
-    "milestones",
-    effectiveParams.milestoneId,
-    `${effectiveParams.milestoneId}-VALIDATION.md`,
-  );
+  // Layout-aware: flat-phase → phases/NN-slug/NN-VALIDATION.md;
+  // legacy → milestones/MID/MID-VALIDATION.md.
+  // join(artifactBasePath, relMilestoneFile) gives the absolute path; relMilestoneFile
+  // returns ".gsd/..."-relative so joining with basePath (project/worktree root) is correct.
+  const validationPath = join(artifactBasePath, relMilestoneFile(artifactBasePath, effectiveParams.milestoneId, "VALIDATION"));
 
   // ── DB write first — matches complete-task/complete-slice pattern ───
   // Write DB before disk so a crash between the two leaves a recoverable
@@ -204,12 +203,8 @@ export async function handleValidateMilestone(
     await saveFile(validationPath, validationMd);
     const projectRoot = resolveWorktreeProjectRoot(basePath);
     if (projectRoot !== artifactBasePath) {
-      const projectValidationPath = join(
-        gsdProjectionRoot(projectRoot),
-        "milestones",
-        effectiveParams.milestoneId,
-        `${effectiveParams.milestoneId}-VALIDATION.md`,
-      );
+      // Mirror to project root using the project root's layout (same logic as above).
+      const projectValidationPath = join(projectRoot, relMilestoneFile(projectRoot, effectiveParams.milestoneId, "VALIDATION"));
       try {
         await saveFile(projectValidationPath, validationMd);
       } catch (mirrorErr) {

package/src/resources/extensions/gsd/tools/workflow-tool-executors.ts

@@ -15,11 +15,13 @@ import {
   insertGateRun,
   readTransaction,
   saveGateResult,
+  upsertMilestonePlanning,
   upsertQualityGate,
 } from "../gsd-db.js";
+import { extractMilestoneSeq } from "../milestone-ids.js";
 import { GATE_REGISTRY } from "../gate-registry.js";
 import { generateRequirementsMd, saveArtifactToDb } from "../db-writer.js";
-import { clearPathCache, normalizeRealPath, relSliceFile, resolveGsdPathContract, resolveMilestoneFile, resolveSliceFile } from "../paths.js";
+import { clearPathCache, normalizeRealPath, relMilestoneFile, relSliceFile, relSlicePath, resolveGsdPathContract, resolveMilestoneFile, resolveSliceFile } from "../paths.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { unlinkSync } from "node:fs";
 import { hostname } from "node:os";
@@ -143,7 +145,34 @@ export interface SummarySaveParams {
 function registerProjectMilestoneSequence(content: string): string[] {
   const parsed = parseProject(content);
   const registered: string[] = [];
+  // Reconcile parsed IDs against existing DB milestones before inserting (#807).
+  // Under unique_milestone_ids the planner mints suffixed IDs (e.g. "M001-b1nole"),
+  // while PROJECT.md's template uses bare sequence IDs (e.g. "M001"). Inserting the
+  // bare ID verbatim mints a phantom milestone row that collides with the planner's
+  // canonical one: the bare row gets its own git worktree, and at dispatch time the
+  // worktree/session scope ("M001") disagrees with ctx.mid ("M001-b1nole"), pausing
+  // auto-mode with "Dispatch milestone mismatch". A project DB holds at most one
+  // milestone per sequence number, so map each parsed line onto the existing row
+  // that shares its sequence number instead of minting a duplicate bare-ID row.
+  const existingBySeq = new Map<number, string>();
+  for (const existing of getAllMilestones()) {
+    const seq = extractMilestoneSeq(existing.id);
+    if (seq > 0 && !existingBySeq.has(seq)) existingBySeq.set(seq, existing.id);
+  }
   for (const milestone of parsed.milestones) {
+    const canonicalId = existingBySeq.get(extractMilestoneSeq(milestone.id));
+    if (canonicalId && canonicalId !== milestone.id) {
+      // An existing milestone already owns this sequence number. Treat the markdown
+      // line as referring to it: refresh the human title, and promote to complete
+      // when the line is checked — but never demote an in-flight milestone back to
+      // "queued" (the planner's row stays the single source of truth).
+      upsertMilestonePlanning(canonicalId, {
+        title: milestone.title,
+        ...(milestone.done ? { status: "complete" } : {}),
+      });
+      registered.push(canonicalId);
+      continue;
+    }
     insertMilestone({
       id: milestone.id,
       title: milestone.title,
@@ -353,11 +382,21 @@ export async function executeSummarySave(
     } else if (params.artifact_type === "REQUIREMENTS-DRAFT") {
       relativePath = "REQUIREMENTS-DRAFT.md";
     } else if (params.task_id && params.slice_id) {
-      relativePath = `milestones/${params.milestone_id}/slices/${params.slice_id}/tasks/${params.task_id}-${params.artifact_type}.md`;
+      // Layout-aware path for task-scoped artifacts.
+      // Flat-phase: <phaseDir>/TID-TYPE.md  Legacy: milestones/MID/slices/SID/tasks/TID-TYPE.md
+      // relSlicePath returns ".gsd/phases/NN-slug" (flat) or ".gsd/milestones/MID/slices/SID" (legacy).
+      const sRel = relSlicePath(basePath, params.milestone_id!, params.slice_id).replace(/^\.gsd\//, "");
+      relativePath = sRel.startsWith("milestones/")
+        ? `${sRel}/tasks/${params.task_id}-${params.artifact_type}.md`
+        : `${sRel}/${params.task_id}-${params.artifact_type}.md`;
     } else if (params.slice_id) {
-      relativePath = `milestones/${params.milestone_id}/slices/${params.slice_id}/${params.slice_id}-${params.artifact_type}.md`;
+      // Layout-aware path for slice-scoped artifacts.
+      // relSliceFile returns ".gsd/..." prefix — strip it to get the DB-relative path.
+      relativePath = relSliceFile(basePath, params.milestone_id!, params.slice_id, params.artifact_type).replace(/^\.gsd\//, "");
     } else {
-      relativePath = `milestones/${params.milestone_id}/${params.milestone_id}-${params.artifact_type}.md`;
+      // Layout-aware path for milestone-scoped artifacts.
+      // relMilestoneFile returns ".gsd/..." prefix — strip it to get the DB-relative path.
+      relativePath = relMilestoneFile(basePath, params.milestone_id!, params.artifact_type).replace(/^\.gsd\//, "");
     }
 
     const activeRequirements = params.artifact_type === "REQUIREMENTS"

package/src/resources/extensions/gsd/triage-resolution.ts

@@ -14,7 +14,7 @@ import { existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
 import { atomicWriteSync } from "./atomic-write.js";
 import { join } from "node:path";
 import { createRequire } from "node:module";
-import { gsdRoot, milestonesDir } from "./paths.js";
+import { gsdRoot, milestonesDir, legacyMilestonesDir, resolveMilestonePath } from "./paths.js";
 import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import type { Classification, CaptureEntry } from "./captures.js";
 import {
@@ -185,8 +185,9 @@ export function executeBacktrack(
     // so deriveState() will re-enter it as the active milestone.
     if (targetMilestoneId) {
       try {
-        const targetDir = join(milestonesDir(basePath), targetMilestoneId);
-        if (existsSync(targetDir)) {
+        // Use resolveMilestonePath to locate the dir in either legacy or flat-phase layout.
+        const targetDir = resolveMilestonePath(basePath, targetMilestoneId);
+        if (targetDir && existsSync(targetDir)) {
           // Write a regression marker so the state machine knows this milestone
           // needs re-discussion, not just re-execution
           const regressionPath = join(targetDir, `${targetMilestoneId}-REGRESSION.md`);
@@ -334,8 +335,13 @@ export function ensureDeferMilestoneDir(
 ): boolean {
   if (!MILESTONE_ID_RE.test(targetMilestone)) return false;
 
-  const msDir = join(milestonesDir(basePath), targetMilestone);
-  if (existsSync(msDir)) return true;
+  // Check if the milestone dir already exists in either layout.
+  const existingDir = resolveMilestonePath(basePath, targetMilestone);
+  if (existingDir && existsSync(existingDir)) return true;
+  // Create new dir in the layout-appropriate location.
+  const legacyBase = legacyMilestonesDir(basePath);
+  const msBase = existsSync(legacyBase) ? legacyBase : milestonesDir(basePath);
+  const msDir = join(msBase, targetMilestone);
 
   try {
     mkdirSync(msDir, { recursive: true });
@@ -495,8 +501,9 @@ export function executeTriageResolutions(
       }
     }
     for (const [milestoneId, captures] of byMilestone) {
-      const msDir = join(milestonesDir(basePath), milestoneId);
-      if (!existsSync(msDir)) {
+      // Use resolveMilestonePath to check existence in either layout.
+      const existingMs = resolveMilestonePath(basePath, milestoneId);
+      if (!existingMs || !existsSync(existingMs)) {
         const created = ensureDeferMilestoneDir(basePath, milestoneId, captures);
         if (created) {
           result.deferredMilestones++;

package/src/resources/extensions/gsd/tui/render-kit.ts

@@ -1,7 +1,7 @@
 // Project/App: gsd-pi
 // File Purpose: Shared terminal rendering helpers for GSD extension TUI surfaces.
 
-import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@gsd/pi-tui";
+import { style, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@gsd/pi-tui";
 
 export interface ThemeLike {
   fg(color: string, text: string): string;
@@ -107,21 +107,64 @@ export function renderPanel(
   }
 
   const ruleColor = options.ruleColor ?? "borderAccent";
-  const indent = Math.max(0, options.indent ?? 2);
-  const rule = (text: string) => theme.fg(ruleColor, text);
+  const paddingX = Math.max(0, options.indent ?? 0);
+  const surface = style()
+    .border("open")
+    .title(title, (text) => theme.fg(ruleColor, text))
+    .borderColor((text) => theme.fg(ruleColor, text))
+    .paddingX(paddingX)
+    .bottomRule(true);
 
-  // Header rule: "── <title> ───────"
-  const lead = "── ";
-  const headerUsed = visibleWidth(lead) + visibleWidth(title) + 1;
-  const headerFill = Math.max(0, width - headerUsed);
-  const header = safeLine(rule(lead) + title + " " + rule("─".repeat(headerFill)), width, "");
+  const body = inner.length > 0 ? inner : [""];
+  return surface.render(body, width);
+}
+
+export interface PlainOutcomeLayoutOptions {
+  /** Right side of the header row (e.g. elapsed time). */
+  headerRight?: string;
+  /** Full-width body rows with an optional right column. */
+  splitRows?: Array<{ left: string; right?: string }>;
+  /** Footer hints pinned to the bottom-right (e.g. slash commands). */
+  footerRight?: string;
+}
+
+/**
+ * Plain transcript outcome — matches the GSD chat/tool speaker line (no rule box).
+ * Header: `GSD · <status>` with optional right meta; body copy-clean; optional footer right.
+ */
+export function renderPlainOutcome(
+  theme: ThemeLike,
+  width: number,
+  statusLine: string,
+  bodyLines: string[],
+  options?: PlainOutcomeLayoutOptions,
+): string[] {
+  const headerLeft =
+    theme.fg("accent", theme.bold("GSD")) + theme.fg("dim", " · ") + statusLine;
+  const header = options?.headerRight
+    ? rightAlign(headerLeft, options.headerRight, width)
+    : safeLine(headerLeft, width);
+
+  const out: string[] = [header];
+
+  if (options?.splitRows && options.splitRows.length > 0) {
+    for (const row of options.splitRows) {
+      out.push(row.right ? rightAlign(row.left, row.right, width) : safeLine(row.left, width));
+    }
+  } else {
+    for (const line of bodyLines.filter(Boolean)) {
+      out.push(safeLine(line, width));
+    }
+  }
 
-  // Body lines, indented so no chrome sits on copyable text.
-  const pad = " ".repeat(indent);
-  const contentWidth = Math.max(0, width - indent);
-  const body = inner.map((line) => safeLine(pad + safeLine(line, contentWidth), width, ""));
+  if (options?.footerRight) {
+    out.push(rightAlign("", options.footerRight, width));
+  }
 
-  return [header, "", ...body, rule("─".repeat(width))];
+  if (out.length === 1 && !options?.footerRight) {
+    return [header, ""];
+  }
+  return [...out, ""];
 }
 
 export function renderFrame(

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

@@ -11,7 +11,7 @@ import { atomicWriteSync } from "./atomic-write.js";
 import { parseUnitId } from "./unit-id.js";
 import { deriveState } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
-import { gsdRoot, resolveTasksDir, resolveSlicePath, resolveTaskFile, buildTaskFileName, buildSliceFileName } from "./paths.js";
+import { gsdRoot, resolveTasksDir, resolveSlicePath, resolveSliceFile, resolveTaskFile, buildTaskFileName, buildSliceFileName } from "./paths.js";
 import { sendDesktopNotification } from "./notifications.js";
 import { getTask, getSlice, getSliceTasks, updateTaskStatus, resetSliceCascade } from "./gsd-db.js";
 import { renderPlanCheckboxes, renderRoadmapCheckboxes } from "./markdown-renderer.js";
@@ -348,15 +348,14 @@ export async function handleResetSlice(
   }
 
   // Delete slice summary and UAT files
+  // Use resolveSliceFile so the legacy S01-SUMMARY.md filename is found even
+  // when buildSliceFileName now returns the flat-phase 01-SUMMARY.md format.
   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++;
-      }
+  for (const suffix of ["SUMMARY", "UAT"] as const) {
+    const filePath = resolveSliceFile(basePath, mid, sid, suffix);
+    if (filePath && existsSync(filePath)) {
+      unlinkSync(filePath);
+      sliceFilesDeleted++;
     }
   }
 

package/src/resources/extensions/gsd/unit-registry.ts

@@ -183,7 +183,14 @@ export const UNIT_REGISTRY = {
     scopeClass: "standard",
     phaseChain: ["research"],
     toolContract: {
-      allowedGsdTools: ["gsd_summary_save", "gsd_decision_save"],
+      allowedGsdTools: [
+        "gsd_milestone_status",
+        "gsd_summary_save",
+        "gsd_decision_save",
+        "gsd_exec",
+        "gsd_exec_search",
+        "gsd_resume",
+      ],
       requiredWorkflowTools: ["gsd_summary_save"],
     },
   },
@@ -192,7 +199,15 @@ export const UNIT_REGISTRY = {
     scopeClass: "standard",
     phaseChain: ["planning"],
     toolContract: {
-      allowedGsdTools: ["gsd_plan_slice", "gsd_reassess_roadmap", "gsd_decision_save"],
+      allowedGsdTools: [
+        "gsd_milestone_status",
+        "gsd_plan_slice",
+        "gsd_reassess_roadmap",
+        "gsd_decision_save",
+        "gsd_exec",
+        "gsd_exec_search",
+        "gsd_resume",
+      ],
       requiredWorkflowTools: ["gsd_plan_slice", "gsd_reassess_roadmap"],
     },
   },
@@ -201,7 +216,14 @@ export const UNIT_REGISTRY = {
     scopeClass: "standard",
     phaseChain: ["planning"],
     toolContract: {
-      allowedGsdTools: ["gsd_plan_slice", "gsd_decision_save"],
+      allowedGsdTools: [
+        "gsd_milestone_status",
+        "gsd_plan_slice",
+        "gsd_decision_save",
+        "gsd_exec",
+        "gsd_exec_search",
+        "gsd_resume",
+      ],
       requiredWorkflowTools: ["gsd_plan_slice"],
     },
   },
@@ -220,6 +242,7 @@ export const UNIT_REGISTRY = {
     phaseChain: ["completion"],
     toolContract: {
       allowedGsdTools: [
+        "gsd_milestone_status",
         "gsd_exec",
         "gsd_slice_complete",
         "gsd_task_reopen",
@@ -231,6 +254,7 @@ export const UNIT_REGISTRY = {
         "subagent",
       ],
       requiredWorkflowTools: [
+        "gsd_milestone_status",
         "gsd_exec",
         "gsd_capture_thought",
         "gsd_slice_complete",

package/src/resources/extensions/gsd/unmerged-milestone-guard.ts

@@ -5,6 +5,7 @@ import {
   nativeBranchExists,
   nativeDetectMainBranch,
   nativeDiffNumstat,
+  nativeIsAncestor,
 } from "./native-git-bridge.js";
 import { autoWorktreeBranch } from "./auto-worktree.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
@@ -25,12 +26,28 @@ export interface UnmergedMilestoneBlocker {
 const BLOCKED_COMMANDS = new Set([
   "auto",
   "next",
-  "parallel",
   "start",
   "workflow",
   "new-milestone",
   "new-project",
   "do",
+  "discuss-phase",
+  "plan-phase",
+  "execute-phase",
+  "spec-phase",
+  "mvp-phase",
+  "ui-phase",
+  "ai-integration-phase",
+  "ultraplan-phase",
+  "validate-phase",
+  "docs-update",
+  "review-backlog",
+  "import",
+  "ingest-docs",
+  "secure-phase",
+  "plan-review-convergence",
+  "autonomous",
+  "resume-work",
   "execute-task",
   "research-milestone",
   "plan-slice",
@@ -41,6 +58,11 @@ const BLOCKED_COMMANDS = new Set([
   "complete-milestone",
 ]);
 
+const UNMERGED_SAFE_PARALLEL_SUBCOMMANDS = new Set([
+  "status",
+  "watch",
+]);
+
 function isRuntimePath(path: string): boolean {
   return path === ".gsd" || path.startsWith(".gsd/");
 }
@@ -50,6 +72,16 @@ function formatCommandLabel(attemptedCommand: string): string {
   return trimmed ? `/gsd ${trimmed}` : "/gsd";
 }
 
+function hasFlag(command: string, flag: string): boolean {
+  const escaped = flag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`(?:^|\\s)${escaped}(?=\\s|$)`).test(command);
+}
+
+function isMutatingPhaseCommand(subcommand: string | undefined): boolean {
+  if (!subcommand) return false;
+  return ["add", "create", "new", "insert", "remove", "edit"].includes(subcommand);
+}
+
 function resolveIntegrationBranch(base: string, milestoneId: string): string | null {
   const prefs = loadEffectiveGSDPreferences(base)?.preferences?.git ?? {};
   const resolution = resolveMilestoneIntegrationBranch(base, milestoneId, prefs);
@@ -75,6 +107,24 @@ export function isUnmergedMilestoneAllowedCommand(trimmed: string): boolean {
   if (name === "dispatch") {
     return subcommand === "complete" || subcommand === "complete-milestone";
   }
+  if (name === "audit-fix") {
+    return hasFlag(command, "--dry-run");
+  }
+  if (name === "code-review") {
+    return !hasFlag(command, "--fix");
+  }
+  if (name === "docs-update") {
+    return hasFlag(command, "--verify-only");
+  }
+  if (name === "parallel") {
+    return UNMERGED_SAFE_PARALLEL_SUBCOMMANDS.has(subcommand ?? "");
+  }
+  if (name === "phase") {
+    return !isMutatingPhaseCommand(subcommand);
+  }
+  if (name === "progress") {
+    return !hasFlag(command, "--next") && !hasFlag(command, "--do");
+  }
   return !BLOCKED_COMMANDS.has(name);
 }
 
@@ -93,6 +143,15 @@ export async function findUnmergedCompletedMilestones(base: string): Promise<Unm
     const integrationBranch = resolveIntegrationBranch(base, milestone.id);
     if (!integrationBranch || integrationBranch === branch) continue;
 
+    // The milestone is merged when its branch tip is reachable from the
+    // integration branch tip — true for fast-forward, --no-ff, and squash
+    // merges alike. A raw diff is the wrong predicate: a --no-ff merge that
+    // took main's side for some conflicts leaves the branch tip differing from
+    // main, which the diff check would misread as "unmerged" (#825). The diff
+    // below remains the correct fallback only when the branch is NOT yet an
+    // ancestor — i.e. the merge is genuinely still pending.
+    if (nativeIsAncestor(base, branch, integrationBranch)) continue;
+
     const files = nativeDiffNumstat(base, integrationBranch, branch)
       .map((entry) => entry.path)
       .filter((path) => path && !isRuntimePath(path));

package/src/resources/extensions/gsd/validation-block-guard.ts

@@ -28,6 +28,27 @@ const VALIDATION_BLOCKED_COMMANDS = new Set([
   "ship",
   "complete-milestone",
   "do",
+  "discuss-phase",
+  "import",
+  "ingest-docs",
+  "review-backlog",
+  "docs-update",
+  "secure-phase",
+  "plan-phase",
+  "execute-phase",
+  "spec-phase",
+  "mvp-phase",
+  "ui-phase",
+  "ai-integration-phase",
+  "ultraplan-phase",
+  "plan-review-convergence",
+  "autonomous",
+  "resume-work",
+  "discuss-phase",
+  "import",
+  "ingest-docs",
+  "review-backlog",
+  "secure-phase",
 ]);
 
 const VALIDATION_BLOCKED_PARALLEL_SUBCOMMANDS = new Set([
@@ -48,6 +69,16 @@ const VALIDATION_SAFE_WORKFLOW_SUBCOMMANDS = new Set([
   "uninstall",
 ]);
 
+function hasFlag(command: string, flag: string): boolean {
+  const escaped = flag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`(?:^|\\s)${escaped}(?=\\s|$)`).test(command);
+}
+
+function isMutatingPhaseCommand(subcommand: string | undefined): boolean {
+  if (!subcommand) return false;
+  return ["add", "create", "new", "insert", "remove", "edit"].includes(subcommand);
+}
+
 export function isValidationBlockedState(state: GSDState): boolean {
   if (state.phase !== "blocked") return false;
   return state.blockers.some((blocker) => VALIDATION_BLOCK_RE.test(blocker));
@@ -67,6 +98,21 @@ export function isValidationBlockAllowedCommand(trimmed: string): boolean {
   if (name === "workflow") {
     return VALIDATION_SAFE_WORKFLOW_SUBCOMMANDS.has(subcommand ?? "");
   }
+  if (name === "audit-fix") {
+    return hasFlag(command, "--dry-run");
+  }
+  if (name === "code-review") {
+    return !hasFlag(command, "--fix");
+  }
+  if (name === "docs-update") {
+    return hasFlag(command, "--verify-only");
+  }
+  if (name === "phase") {
+    return !isMutatingPhaseCommand(subcommand);
+  }
+  if (name === "progress") {
+    return !hasFlag(command, "--next") && !hasFlag(command, "--do");
+  }
   return !VALIDATION_BLOCKED_COMMANDS.has(name);
 }
 

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

@@ -5,6 +5,7 @@ import { join } from 'node:path';
 import { deriveState } from './state.js';
 import { parseSummary, loadFile } from './files.js';
 import { isDbAvailable, getMilestoneSlices, getSliceTasks } from './gsd-db.js';
+import { openExistingWorkflowDatabase } from './db-workspace.js';
 import { parseRoadmap, parsePlan } from './parsers-legacy.js';
 import { findMilestoneIds } from './milestone-ids.js';
 import { resolveMilestoneFile, resolveSliceFile, resolveGsdRootFile, gsdRoot } from './paths.js';
@@ -26,6 +27,7 @@ import { generateSkillHealthReport } from './skill-health.js';
 import { runEnvironmentChecks, type EnvironmentCheckResult } from './doctor-environment.js';
 import { computeProgressScore } from './progress-score.js';
 import { getHealthHistory } from './doctor-proactive.js';
+import { getActiveMemories, getActiveMemoriesRanked } from './memory-store.js';
 
 import type { Phase } from './types.js';
 import type { CaptureEntry } from './captures.js';
@@ -144,6 +146,22 @@ export interface KnowledgeInfo {
   exists: boolean;
 }
 
+export interface VisualizerMemoryEntry {
+  id: string;
+  category: string;
+  content: string;
+  confidence: number;
+  hitCount: number;
+  scope: string;
+  tags: string[];
+  updatedAt: string;
+}
+
+export interface MemoryInfo {
+  entries: VisualizerMemoryEntry[];
+  totalCount: number;
+}
+
 export interface CapturesInfo {
   entries: CaptureEntry[];
   pendingCount: number;
@@ -222,6 +240,7 @@ export interface VisualizerData {
   changelog: ChangelogInfo;
   sliceVerifications: SliceVerification[];
   knowledge: KnowledgeInfo;
+  memories: MemoryInfo;
   captures: CapturesInfo;
   health: HealthInfo;
   discussion: VisualizerDiscussionState[];
@@ -588,6 +607,39 @@ function loadKnowledge(basePath: string): KnowledgeInfo {
   return { rules, patterns, lessons, exists: true };
 }
 
+// ─── Memory Loader ────────────────────────────────────────────────────────────
+
+const VISUALIZER_MEMORY_LIMIT = 20;
+const VISUALIZER_MEMORY_CONTENT_LIMIT = 2000;
+
+function ensureVisualizerDb(basePath: string): void {
+  if (isDbAvailable()) return;
+  openExistingWorkflowDatabase(basePath);
+}
+
+function loadMemories(): MemoryInfo {
+  const allActive = getActiveMemories();
+  const ranked = getActiveMemoriesRanked(VISUALIZER_MEMORY_LIMIT);
+  return {
+    totalCount: allActive.length,
+    entries: ranked.map((memory) => ({
+      id: memory.id,
+      category: memory.category,
+      content: limitMemoryContent(memory.content),
+      confidence: memory.confidence,
+      hitCount: memory.hit_count,
+      scope: memory.scope,
+      tags: memory.tags,
+      updatedAt: memory.updated_at,
+    })),
+  };
+}
+
+function limitMemoryContent(content: string): string {
+  if (content.length <= VISUALIZER_MEMORY_CONTENT_LIMIT) return content;
+  return `${content.slice(0, VISUALIZER_MEMORY_CONTENT_LIMIT).trimEnd()}...`;
+}
+
 // ─── Health Loader ────────────────────────────────────────────────────────────
 
 function loadHealth(units: UnitMetrics[], totals: ProjectTotals | null, basePath: string): HealthInfo {
@@ -783,6 +835,7 @@ function readFileCached(filePath: string): string | null {
 // ─── Loader ───────────────────────────────────────────────────────────────────
 
 export async function loadVisualizerData(basePath: string): Promise<VisualizerData> {
+  ensureVisualizerDb(basePath);
   const state = await deriveState(basePath);
   const milestoneIds = findMilestoneIds(basePath);
 
@@ -917,6 +970,7 @@ export async function loadVisualizerData(basePath: string): Promise<VisualizerDa
   const { changelog, verifications: sliceVerifications } = await loadChangelogAndVerifications(basePath, milestones);
 
   const knowledge = loadKnowledge(basePath);
+  const memories = loadMemories();
   const allCaptures = loadAllCaptures(basePath);
   const pendingCount = countPendingCaptures(basePath);
   const captures: CapturesInfo = {
@@ -945,6 +999,7 @@ export async function loadVisualizerData(basePath: string): Promise<VisualizerDa
     changelog,
     sliceVerifications,
     knowledge,
+    memories,
     captures,
     health,
     discussion,