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

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

@@ -3,10 +3,11 @@
 import { ensureDbOpen } from "../bootstrap/dynamic-tools.js";
 import { sanitizeCompleteMilestoneParams } from "../bootstrap/sanitize-complete-milestone.js";
 import { loadWriteGateSnapshot, shouldBlockContextArtifactSaveInSnapshot, shouldBlockRootArtifactSaveInSnapshot } from "../bootstrap/write-gate.js";
-import { getActiveRequirements, getAllMilestones, getMilestone, getSliceStatusSummary, getSliceTaskCounts, insertMilestone, insertAssessment, insertGateRun, readTransaction, saveGateResult, upsertQualityGate, } from "../gsd-db.js";
+import { getActiveRequirements, getAllMilestones, getMilestone, getSliceStatusSummary, getSliceTaskCounts, insertMilestone, insertAssessment, 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";
@@ -80,7 +81,35 @@ function milestoneLeaseConflictResult(milestoneId, byWorker, expiresAt) {
 function registerProjectMilestoneSequence(content) {
     const parsed = parseProject(content);
     const registered = [];
+    // 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();
+    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,
@@ -270,13 +299,23 @@ export async function executeSummarySave(params, basePath = process.cwd()) {
             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"
             ? getActiveRequirements()

package/dist/resources/extensions/gsd/triage-resolution.js

@@ -13,7 +13,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 { loadAllCaptures, loadActionableCaptures, markCaptureExecuted, stampCaptureMilestone, } from "./captures.js";
 // ─── Resolution Executors ─────────────────────────────────────────────────────
@@ -149,8 +149,9 @@ export function executeBacktrack(basePath, currentMilestoneId, capture) {
         // 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`);
@@ -270,9 +271,14 @@ export function detectFileOverlap(affectedFiles, planContent) {
 export function ensureDeferMilestoneDir(basePath, targetMilestone, captures) {
     if (!MILESTONE_ID_RE.test(targetMilestone))
         return false;
-    const msDir = join(milestonesDir(basePath), targetMilestone);
-    if (existsSync(msDir))
+    // 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 });
         // Seed CONTEXT-DRAFT.md with deferred capture context
@@ -389,8 +395,9 @@ export function executeTriageResolutions(basePath, mid, sid) {
             }
         }
         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/dist/resources/extensions/gsd/tui/render-kit.js

@@ -1,6 +1,6 @@
 // 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 function safeLine(text, width, ellipsis = "…") {
     if (width <= 0)
         return "";
@@ -73,18 +73,43 @@ export function renderPanel(theme, title, inner, width, options = {}) {
         return [safeLine(title, width), ...inner.map((line) => safeLine(line, width))];
     }
     const ruleColor = options.ruleColor ?? "borderAccent";
-    const indent = Math.max(0, options.indent ?? 2);
-    const rule = (text) => theme.fg(ruleColor, text);
-    // 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, "");
-    // 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, ""));
-    return [header, "", ...body, rule("─".repeat(width))];
+    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);
+    const body = inner.length > 0 ? inner : [""];
+    return surface.render(body, width);
+}
+/**
+ * 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, width, statusLine, bodyLines, options) {
+    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 = [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));
+        }
+    }
+    if (options?.footerRight) {
+        out.push(rightAlign("", options.footerRight, width));
+    }
+    if (out.length === 1 && !options?.footerRight) {
+        return [header, ""];
+    }
+    return [...out, ""];
 }
 export function renderFrame(theme, inner, width, options = {}) {
     if (width < 4)

package/dist/resources/extensions/gsd/undo.js

@@ -9,7 +9,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 } 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";
@@ -291,15 +291,14 @@ export async function handleResetSlice(args, ctx, _pi, basePath) {
         }
     }
     // 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"]) {
+        const filePath = resolveSliceFile(basePath, mid, sid, suffix);
+        if (filePath && existsSync(filePath)) {
+            unlinkSync(filePath);
+            sliceFilesDeleted++;
         }
     }
     // Re-render plan + roadmap checkboxes

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

@@ -136,7 +136,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"],
         },
     },
@@ -145,7 +152,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"],
         },
     },
@@ -154,7 +169,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"],
         },
     },
@@ -173,6 +195,7 @@ export const UNIT_REGISTRY = {
         phaseChain: ["completion"],
         toolContract: {
             allowedGsdTools: [
+                "gsd_milestone_status",
                 "gsd_exec",
                 "gsd_slice_complete",
                 "gsd_task_reopen",
@@ -184,6 +207,7 @@ export const UNIT_REGISTRY = {
                 "subagent",
             ],
             requiredWorkflowTools: [
+                "gsd_milestone_status",
                 "gsd_exec",
                 "gsd_capture_thought",
                 "gsd_slice_complete",

package/dist/resources/extensions/gsd/unmerged-milestone-guard.js

@@ -1,6 +1,6 @@
 // Project/App: gsd-pi
 // File Purpose: Block new workflow entry when completed milestone branches are still unmerged.
-import { nativeBranchExists, nativeDetectMainBranch, nativeDiffNumstat, } from "./native-git-bridge.js";
+import { nativeBranchExists, nativeDetectMainBranch, nativeDiffNumstat, nativeIsAncestor, } from "./native-git-bridge.js";
 import { autoWorktreeBranch } from "./auto-worktree.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
 import { getAllMilestones } from "./gsd-db.js";
@@ -11,12 +11,28 @@ import { isClosedStatus } from "./status-guards.js";
 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",
@@ -26,6 +42,10 @@ const BLOCKED_COMMANDS = new Set([
     "validate-milestone",
     "complete-milestone",
 ]);
+const UNMERGED_SAFE_PARALLEL_SUBCOMMANDS = new Set([
+    "status",
+    "watch",
+]);
 function isRuntimePath(path) {
     return path === ".gsd" || path.startsWith(".gsd/");
 }
@@ -33,6 +53,15 @@ function formatCommandLabel(attemptedCommand) {
     const trimmed = attemptedCommand.trim();
     return trimmed ? `/gsd ${trimmed}` : "/gsd";
 }
+function hasFlag(command, flag) {
+    const escaped = flag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(?:^|\\s)${escaped}(?=\\s|$)`).test(command);
+}
+function isMutatingPhaseCommand(subcommand) {
+    if (!subcommand)
+        return false;
+    return ["add", "create", "new", "insert", "remove", "edit"].includes(subcommand);
+}
 function resolveIntegrationBranch(base, milestoneId) {
     const prefs = loadEffectiveGSDPreferences(base)?.preferences?.git ?? {};
     const resolution = resolveMilestoneIntegrationBranch(base, milestoneId, prefs);
@@ -57,6 +86,24 @@ export function isUnmergedMilestoneAllowedCommand(trimmed) {
     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);
 }
 export async function findUnmergedCompletedMilestones(base) {
@@ -72,6 +119,15 @@ export async function findUnmergedCompletedMilestones(base) {
         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/dist/resources/extensions/gsd/validation-block-guard.js

@@ -21,6 +21,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([
     "",
@@ -38,6 +59,15 @@ const VALIDATION_SAFE_WORKFLOW_SUBCOMMANDS = new Set([
     "install",
     "uninstall",
 ]);
+function hasFlag(command, flag) {
+    const escaped = flag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(?:^|\\s)${escaped}(?=\\s|$)`).test(command);
+}
+function isMutatingPhaseCommand(subcommand) {
+    if (!subcommand)
+        return false;
+    return ["add", "create", "new", "insert", "remove", "edit"].includes(subcommand);
+}
 export function isValidationBlockedState(state) {
     if (state.phase !== "blocked")
         return false;
@@ -57,6 +87,21 @@ export function isValidationBlockAllowedCommand(trimmed) {
     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);
 }
 export function formatValidationBlockedMessage(state, attemptedCommand = "") {

package/dist/resources/extensions/gsd/visualizer-data.js

@@ -4,6 +4,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';
@@ -15,6 +16,7 @@ import { generateSkillHealthReport } from './skill-health.js';
 import { runEnvironmentChecks } from './doctor-environment.js';
 import { computeProgressScore } from './progress-score.js';
 import { getHealthHistory } from './doctor-proactive.js';
+import { getActiveMemories, getActiveMemoriesRanked } from './memory-store.js';
 // ─── Critical Path ────────────────────────────────────────────────────────────
 export function computeCriticalPath(milestones) {
     const empty = {
@@ -351,6 +353,36 @@ function loadKnowledge(basePath) {
     }
     return { rules, patterns, lessons, exists: true };
 }
+// ─── Memory Loader ────────────────────────────────────────────────────────────
+const VISUALIZER_MEMORY_LIMIT = 20;
+const VISUALIZER_MEMORY_CONTENT_LIMIT = 2000;
+function ensureVisualizerDb(basePath) {
+    if (isDbAvailable())
+        return;
+    openExistingWorkflowDatabase(basePath);
+}
+function loadMemories() {
+    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) {
+    if (content.length <= VISUALIZER_MEMORY_CONTENT_LIMIT)
+        return content;
+    return `${content.slice(0, VISUALIZER_MEMORY_CONTENT_LIMIT).trimEnd()}...`;
+}
 // ─── Health Loader ────────────────────────────────────────────────────────────
 function loadHealth(units, totals, basePath) {
     const prefs = loadEffectiveGSDPreferences();
@@ -524,6 +556,7 @@ function readFileCached(filePath) {
 }
 // ─── Loader ───────────────────────────────────────────────────────────────────
 export async function loadVisualizerData(basePath) {
+    ensureVisualizerDb(basePath);
     const state = await deriveState(basePath);
     const milestoneIds = findMilestoneIds(basePath);
     const milestones = [];
@@ -640,6 +673,7 @@ export async function loadVisualizerData(basePath) {
     const agentActivity = loadAgentActivity(units, milestones);
     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 = {
@@ -666,6 +700,7 @@ export async function loadVisualizerData(basePath) {
         changelog,
         sliceVerifications,
         knowledge,
+        memories,
         captures,
         health,
         discussion,

package/dist/resources/extensions/gsd/visualizer-views.js

@@ -705,11 +705,16 @@ export function renderExportView(_data, th, _width, lastExportPath) {
 export function renderKnowledgeView(data, th, width) {
     const lines = [];
     const knowledge = data.knowledge;
-    if (!knowledge.exists) {
+    const memories = data.memories;
+    if (!knowledge.exists && memories.entries.length === 0) {
         lines.push(th.fg("dim", "No KNOWLEDGE.md found"));
         return lines;
     }
-    if (knowledge.rules.length === 0 && knowledge.patterns.length === 0 && knowledge.lessons.length === 0) {
+    if (knowledge.exists &&
+        knowledge.rules.length === 0 &&
+        knowledge.patterns.length === 0 &&
+        knowledge.lessons.length === 0 &&
+        memories.entries.length === 0) {
         lines.push(th.fg("dim", "KNOWLEDGE.md exists but is empty"));
         return lines;
     }
@@ -740,6 +745,20 @@ export function renderKnowledgeView(data, th, width) {
         }
         lines.push("");
     }
+    if (memories.entries.length > 0) {
+        const countLabel = memories.totalCount > memories.entries.length
+            ? `${memories.entries.length}/${memories.totalCount}`
+            : `${memories.totalCount}`;
+        lines.push(th.fg("accent", th.bold(`Memories (${countLabel})`)));
+        lines.push("");
+        for (const memory of memories.entries) {
+            const scope = memory.scope && memory.scope !== "project" ? ` ${th.fg("dim", `[${memory.scope}]`)}` : "";
+            const tags = memory.tags.length > 0 ? ` ${th.fg("dim", `#${memory.tags.join(" #")}`)}` : "";
+            lines.push(truncateToWidth(`  ${th.fg("accent", memory.id)}  (${memory.category}, ${memory.confidence.toFixed(2)}, hits ${memory.hitCount})${scope}${tags}`, width));
+            lines.push(truncateToWidth(`    ${memory.content}`, width));
+        }
+        lines.push("");
+    }
     return lines;
 }
 // ─── Captures View ───────────────────────────────────────────────────────────

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

@@ -42,6 +42,10 @@ export function setStderrLoggingEnabled(enabled) {
     _stderrEnabled = enabled;
     return previous;
 }
+/** Whether GSD extension diagnostics may write directly to process.stderr. */
+export function isGsdExtensionStderrEnabled() {
+    return _stderrEnabled;
+}
 // ─── Public API ─────────────────────────────────────────────────────────
 /**
  * Record a warning. Warnings are persisted to notifications and buffered for

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

@@ -54,6 +54,7 @@ function lookupCommand(command, platform = process.platform) {
         return null;
     }
 }
+const gsdPiRepoRootCache = new Map();
 function findGsdPiRepoRoot(startPath) {
     let current;
     try {
@@ -62,15 +63,22 @@ function findGsdPiRepoRoot(startPath) {
     catch {
         current = resolve(startPath);
     }
+    const cacheKey = current;
+    if (gsdPiRepoRootCache.has(cacheKey)) {
+        return gsdPiRepoRootCache.get(cacheKey) ?? null;
+    }
     while (true) {
         const distCli = resolve(current, "packages", "mcp-server", "dist", "cli.js");
-        if (existsSync(distCli))
+        if (existsSync(distCli)) {
+            gsdPiRepoRootCache.set(cacheKey, current);
             return current;
+        }
         const parent = dirname(current);
         if (parent === current)
             break;
         current = parent;
     }
+    gsdPiRepoRootCache.set(cacheKey, null);
     return null;
 }
 function findWorkflowCliFromAncestorPath(startPath) {