@opengsd/gsd-pi 1.3.0 → 1.4.0

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

@@ -3,13 +3,28 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
+import { createRequire } from "node:module";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+
+const _require = createRequire(import.meta.url);
 
 import {
   formatValidationBlockedMessage,
+  getValidationBlockMessageForBase,
   isValidationBlockAllowedCommand,
   isValidationBlockedState,
 } from "../validation-block-guard.ts";
+import {
+  _getAdapter,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  openDatabase,
+} from "../gsd-db.ts";
+import { invalidateStateCache } from "../state.ts";
 import type { GSDState } from "../types.ts";
+import { cleanup, makeTempDir } from "./test-utils.ts";
 
 function blockedState(): GSDState {
   return {
@@ -38,6 +53,24 @@ function blockedState(): GSDState {
   };
 }
 
+function makeBase(): string {
+  const base = makeTempDir("gsd-validation-block-");
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function openRawSqliteForTest(dbPath: string): { exec(sql: string): void; close(): void } {
+  try {
+    const mod = _require("node:sqlite") as { DatabaseSync: new (path: string) => { exec(sql: string): void; close(): void } };
+    return new mod.DatabaseSync(dbPath);
+  } catch {
+    type SqliteCtor = new (path: string) => { exec(sql: string): void; close(): void };
+    const mod = _require("better-sqlite3") as SqliteCtor | { default: SqliteCtor };
+    const DatabaseCtor: SqliteCtor = typeof mod === "function" ? mod : mod.default;
+    return new DatabaseCtor(dbPath);
+  }
+}
+
 test("validation block detection only matches validation blockers", () => {
   assert.equal(isValidationBlockedState(blockedState()), true);
   assert.equal(isValidationBlockedState({
@@ -80,6 +113,19 @@ test("validation block allows recovery, diagnostics, and unrelated commands", ()
     "parallel stop M007",
     "parallel pause M007",
     "parallel watch",
+    "progress",
+    "progress --forensic",
+    // code-review is allowed when not applying fixes
+    "code-review",
+    "code-review --depth deep",
+    // audit-fix is allowed in dry-run mode (read-only review, no commits)
+    "audit-fix --dry-run",
+    // docs-update is allowed in verify-only mode (read-only check, no writes)
+    "docs-update --verify-only",
+    // phase read-only subcommands are fine while validation-blocked
+    "phase",
+    "phase list",
+    "phase status",
   ];
 
   for (const command of allowed) {
@@ -95,7 +141,19 @@ test("validation block rejects workflow-start and advancing commands", () => {
     "next",
     "next M006",
     "do mark all complete",
+    "progress --next",
+    'progress --do "mark all complete"',
     "start bugfix",
+    "plan-phase",
+    "execute-phase --milestone M009",
+    "autonomous --from 1",
+    "spec-phase M009",
+    "mvp-phase --milestone M009",
+    "ui-phase M009",
+    "ai-integration-phase M009",
+    "ultraplan-phase M009",
+    "plan-review-convergence M009",
+    "resume-work",
     "workflow resume",
     "workflow run release-checklist",
     "workflow release-checklist",
@@ -107,6 +165,32 @@ test("validation block rejects workflow-start and advancing commands", () => {
     "dispatch uat",
     "complete-milestone",
     "ship",
+    // code-review --fix applies changes and should be blocked
+    "code-review --fix",
+    "code-review --depth deep --fix",
+    // audit-fix without --dry-run applies fixes and commits
+    "audit-fix",
+    "audit-fix --verbose",
+    // mutating workflow-advancing commands added in v2
+    "discuss-phase",
+    "discuss-phase M006",
+    "import",
+    "import milestones.json",
+    "ingest-docs",
+    "ingest-docs --path docs/",
+    "review-backlog",
+    "secure-phase",
+    "secure-phase --milestone M006",
+    // docs-update without --verify-only applies writes
+    "docs-update",
+    "docs-update --milestone M006",
+    // phase mutating subcommands change milestone queue state and must be blocked
+    "phase add M009",
+    "phase create M009",
+    "phase new",
+    "phase insert M009 after M008",
+    "phase remove M008",
+    "phase edit M008",
   ];
 
   for (const command of blocked) {
@@ -143,3 +227,49 @@ test("validation block message can guide remediation through dispatch reassess",
   assert.match(message, /\/gsd dispatch reassess/);
   assert.doesNotMatch(message, /gsd_reassess_roadmap/);
 });
+
+test("validation block guard refreshes from disk and sees external validation blocks", async () => {
+  const base = makeBase();
+  const dbPath = join(base, ".gsd", "gsd.db");
+  const validationPath = join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md");
+  try {
+    openDatabase(dbPath);
+    insertMilestone({ id: "M001", title: "Active Milestone", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Done Slice",
+      status: "complete",
+      risk: "low",
+      depends: [],
+    });
+    invalidateStateCache();
+
+    const adapterBefore = _getAdapter();
+    assert.ok(adapterBefore);
+
+    const externalDb = openRawSqliteForTest(dbPath);
+    try {
+      externalDb.exec(`
+        INSERT OR REPLACE INTO assessments (path, milestone_id, slice_id, task_id, status, scope, full_content, created_at)
+        VALUES (
+          '${validationPath.replace(/'/g, "''")}',
+          'M001', NULL, NULL, 'needs-attention', 'milestone-validation',
+          '---\nverdict: needs-attention\n---', datetime('now')
+        )
+      `);
+    } finally {
+      externalDb.close();
+    }
+
+    const message = await getValidationBlockMessageForBase(base, "next");
+
+    assert.ok(message);
+    assert.match(message, /cannot run because the active milestone is blocked by validation/);
+    assert.notEqual(_getAdapter(), adapterBefore, "guard must refresh stale database handle");
+  } finally {
+    closeDatabase();
+    invalidateStateCache();
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/validation-gate-patterns.test.ts

@@ -1,11 +1,11 @@
 /**
  * Unit tests for the milestone completion validation gate pattern matching.
  *
- * The gate in auto-dispatch accepts two evidence formats:
- *   1. Structured template: content contains "Operational" AND ("MET" or "N/A")
- *   2. Prose evidence: matches /[Oo]perational[\s:][^\n]*(?:pass|verified|...)/i
+ * The milestone closeout gate accepts two evidence formats:
+ *   1. Structured template: content contains "Operational" AND an accepted verdict
+ *   2. Prose evidence: matches an Operational-local accepted verdict
  *
- * These tests exercise the exact same expressions used in auto-dispatch.ts
+ * These tests exercise the exact same expressions used in milestone-closeout.ts
  * to ensure both formats are correctly recognized, and that content without
  * operational evidence is properly rejected.
  */
@@ -23,9 +23,9 @@ import assert from "node:assert/strict";
 function hasOperationalEvidence(validationContent: string): boolean {
   const structuredMatch =
     validationContent.includes("Operational") &&
-    (validationContent.includes("MET") || validationContent.includes("N/A") || validationContent.includes("SATISFIED") || validationContent.includes("DEFERRED"));
+    (validationContent.includes("MET") || validationContent.includes("N/A") || validationContent.includes("SATISFIED") || validationContent.includes("DEFERRED") || validationContent.includes("PASS") || validationContent.includes("COVERED"));
   const proseMatch =
-    /[Oo]perational[\s\S]{0,500}?(?:✅|pass|verified|confirmed|met|complete|true|yes|addressed|covered|satisfied|partially|deferred|n\/a|not[\s-]+applicable)/i.test(
+    /[Oo]perational[\s\S]{0,2000}?(?:✅|pass|verified|confirmed|met|complete|true|yes|addressed|covered|satisfied|partially|deferred|n\/a|not[\s-]+applicable)/i.test(
       validationContent,
     );
   return structuredMatch || proseMatch;
@@ -116,6 +116,34 @@ test("structured: Operational + DEFERRED passes", () => {
   assert.ok(hasOperationalEvidence(content));
 });
 
+test("structured: Operational + PASS passes", () => {
+  const content = `| Class | Planned Check | Evidence | Verdict |
+| --- | --- | --- | --- |
+| Operational | Process lifecycle proof | Validation command exited cleanly. | PASS |`;
+  assert.ok(content.includes("PASS"));
+  assert.ok(hasOperationalEvidence(content));
+});
+
+test("structured: Operational + COVERED passes", () => {
+  const content = `| Class | Planned Check | Evidence | Verdict |
+| --- | --- | --- | --- |
+| Operational | Process lifecycle proof | Validation command exited cleanly. | COVERED |`;
+  assert.ok(content.includes("COVERED"));
+  assert.ok(hasOperationalEvidence(content));
+});
+
+test("prose: evidence-rich Operational row can place verdict after 500 characters", () => {
+  const evidence = "Lifecycle evidence from restart, reconnect, supervision, cleanup, and operator notification checks. ".repeat(7);
+  const content = `| Class | Planned Check | Evidence | Verdict |
+| --- | --- | --- | --- |
+| Operational | Headless process exits cleanly without orphaned subprocesses and preserves operator-visible state through restart. | ${evidence} | pass |`;
+  assert.ok(
+    content.toLowerCase().indexOf("pass", content.indexOf("Operational")) > content.indexOf("Operational") + 500,
+    "test fixture should place pass beyond the old 500-character window",
+  );
+  assert.ok(hasOperationalEvidence(content));
+});
+
 // ─── Issue #2862: checkmark emoji ────────────────────────────────────────────
 
 test('prose: "Operational: ✅" checkmark emoji passes (issue #2862)', () => {

package/src/resources/extensions/gsd/tests/verification-retry-policy.test.ts

@@ -11,6 +11,8 @@ import {
   verificationRetryKey,
   VERIFICATION_RETRY_MAX_DELAY_MS,
 } from "../auto/verification-retry-policy.ts";
+import { formatFailureContext, formatFailureSignature } from "../verification-gate.ts";
+import type { VerificationResult } from "../types.ts";
 
 test("verificationRetryDelayMs uses exponential backoff with cap", () => {
   assert.deepEqual(verificationRetryDelayMs(1, () => 0.5), {
@@ -31,9 +33,22 @@ test("verificationRetryDelayMs uses exponential backoff with cap", () => {
   });
 });
 
-test("decideVerificationRetry pauses on duplicate failure context", () => {
+test("decideVerificationRetry pauses on repeated failure context across attempts", () => {
   const failureContext = "lint failed\n";
-  const failureHash = hashVerificationFailureContext(failureContext);
+  const firstDecision = decideVerificationRetry({
+    unitType: "execute-task",
+    retryInfo: {
+      unitId: "M001/S01/T01",
+      failureContext,
+      attempt: 1,
+    },
+    previousFailureHash: undefined,
+    random: () => 0.5,
+  });
+
+  assert.equal(firstDecision.action, "delay");
+  assert.equal(firstDecision.failureHash, hashVerificationFailureContext(failureContext));
+
   const decision = decideVerificationRetry({
     unitType: "execute-task",
     retryInfo: {
@@ -41,7 +56,7 @@ test("decideVerificationRetry pauses on duplicate failure context", () => {
       failureContext,
       attempt: 2,
     },
-    previousFailureHash: failureHash,
+    previousFailureHash: firstDecision.failureHash,
     random: () => 0.5,
   });
 
@@ -49,7 +64,7 @@ test("decideVerificationRetry pauses on duplicate failure context", () => {
     action: "pause",
     reason: "duplicate-failure-context",
     key: verificationRetryKey("execute-task", "M001/S01/T01"),
-    failureHash,
+    failureHash: firstDecision.failureHash,
   });
 });
 
@@ -71,6 +86,56 @@ test("decideVerificationRetry delays changed failure context", () => {
   assert.equal(decision.baseDelayMs, 4_000);
 });
 
+test("decideVerificationRetry pauses duplicate host-check failures with volatile stderr", () => {
+  const makeResult = (stderr: string): VerificationResult => ({
+    passed: false,
+    discoverySource: "package-json",
+    timestamp: Date.now(),
+    checks: [
+      {
+        command: "npm test",
+        exitCode: 1,
+        stdout: "",
+        stderr,
+        durationMs: 100,
+      },
+    ],
+  });
+  const first = makeResult("failed after 120ms in /tmp/gsd-a worker pid 101");
+  const second = makeResult("failed after 133ms in /tmp/gsd-b worker pid 202");
+  const firstContext = formatFailureContext(first);
+  const secondContext = formatFailureContext(second);
+
+  assert.notEqual(
+    hashVerificationFailureContext(firstContext),
+    hashVerificationFailureContext(secondContext),
+  );
+
+  const signature = formatFailureSignature(first);
+  assert.equal(signature, "npm test#1");
+  assert.equal(formatFailureSignature(second), signature);
+
+  const failureHash = hashVerificationFailureContext(signature);
+  const decision = decideVerificationRetry({
+    unitType: "execute-task",
+    retryInfo: {
+      unitId: "M001/S01/T01",
+      failureContext: secondContext,
+      signature: formatFailureSignature(second),
+      attempt: 2,
+    },
+    previousFailureHash: failureHash,
+    random: () => 0.5,
+  });
+
+  assert.deepEqual(decision, {
+    action: "pause",
+    reason: "duplicate-failure-context",
+    key: verificationRetryKey("execute-task", "M001/S01/T01"),
+    failureHash,
+  });
+});
+
 test("decideVerificationRetry pauses when retry context is missing", () => {
   assert.deepEqual(
     decideVerificationRetry({

package/src/resources/extensions/gsd/tests/verify-artifact-tightened.test.ts

@@ -202,3 +202,159 @@ test("execute-task DB lag branch — summary without checked plan still fails",
     "pending DB status plus summary is insufficient without a checked task checkbox",
   );
 });
+
+// ── #852 follow-up: worktree→project-root artifact fallback ──────────────────
+//
+// A milestone running in a worktree may not have its CONTEXT projected into the
+// worktree (the worktree only has the META dir until planning writes its
+// projections). When verifyExpectedArtifact can't find the artifact at the
+// worktree base, it must fall back to the project root — where the artifact
+// genuinely lives. Without this, discuss-milestone verification returned false
+// ("resolveExpectedArtifactPath returned null") and trapped the unit in a
+// finalize-retry loop.
+
+test("#852: discuss-milestone falls back to project root when CONTEXT not in worktree", () => {
+  closeDatabase();
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-wt-fallback-proj-"));
+  try {
+    // Flat-phase CONTEXT lives at the project root.
+    const phaseDir = join(projectRoot, ".gsd", "phases", "15-m015");
+    mkdirSync(phaseDir, { recursive: true });
+    writeFileSync(join(phaseDir, "15-CONTEXT.md"), "# M015 context\n");
+
+    // Simulate the worktree: exists, registered with git (.git file), but has
+    // NO phases/ dir and no real CONTEXT — only the META dir git-service.ts
+    // created. resolveCanonicalMilestoneRoot redirects here.
+    const wtRoot = join(projectRoot, ".gsd", "worktrees", "M015");
+    const wtGsd = join(wtRoot, ".gsd");
+    mkdirSync(join(wtGsd, "milestones", "M015"), { recursive: true });
+    writeFileSync(join(wtGsd, "milestones", "M015", "M015-META.json"), '{"branch":"milestone/M015"}');
+    writeFileSync(join(wtRoot, ".git"), "gitdir: /fake/path");
+
+    // Verification with the worktree as base must fall back to the project root
+    // and find 15-CONTEXT.md there.
+    assert.equal(
+      verifyExpectedArtifact("discuss-milestone", "M015", projectRoot),
+      true,
+      "must fall back to project root when CONTEXT is not in the worktree",
+    );
+  } finally {
+    closeDatabase();
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test("#852: discuss-milestone passes when CONTEXT is in the worktree (no fallback needed)", () => {
+  closeDatabase();
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-wt-present-"));
+  try {
+    // CONTEXT lives in BOTH the project root AND the worktree.
+    const projPhase = join(projectRoot, ".gsd", "phases", "15-m015");
+    mkdirSync(projPhase, { recursive: true });
+    writeFileSync(join(projPhase, "15-CONTEXT.md"), "# project context\n");
+
+    const wtRoot = join(projectRoot, ".gsd", "worktrees", "M015");
+    const wtGsd = join(wtRoot, ".gsd");
+    const wtPhase = join(wtGsd, "phases", "15-m015");
+    mkdirSync(wtPhase, { recursive: true });
+    writeFileSync(join(wtPhase, "15-CONTEXT.md"), "# worktree context\n");
+    writeFileSync(join(wtRoot, ".git"), "gitdir: /fake/path");
+
+    assert.equal(
+      verifyExpectedArtifact("discuss-milestone", "M015", projectRoot),
+      true,
+      "must pass when CONTEXT is in the worktree",
+    );
+  } finally {
+    closeDatabase();
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test("#852: discuss-milestone fails when CONTEXT is in neither worktree nor project root", () => {
+  // If the artifact genuinely doesn't exist anywhere, verification must still
+  // fail (fail-closed) — the fallback must not mask a real absence.
+  closeDatabase();
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-wt-absent-"));
+  try {
+    const wtRoot = join(projectRoot, ".gsd", "worktrees", "M015");
+    mkdirSync(join(wtRoot, ".gsd", "milestones", "M015"), { recursive: true });
+    writeFileSync(join(wtRoot, ".git"), "gitdir: /fake/path");
+    // No phases/ anywhere, no CONTEXT anywhere.
+
+    assert.equal(
+      verifyExpectedArtifact("discuss-milestone", "M015", projectRoot),
+      false,
+      "must fail when CONTEXT exists in neither root",
+    );
+  } finally {
+    closeDatabase();
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+// ---------------------------------------------------------------------------
+// #870: discuss-milestone verify-fail when the unit runs IN the worktree.
+//
+// The #852 tests above all pass `projectRoot` as the base. But the real call
+// site (auto-post-unit.ts:1726) passes `s.currentUnit.workspaceRoot ?? s.basePath`
+// — i.e. the WORKTREE path when the unit executed in a worktree. In the
+// canonical layout (`<root>/.gsd-worktrees/<MID>/`) resolveCanonicalMilestoneRoot
+// round-trips the worktree path back to itself, so `artifactBase === base` and
+// the worktree→project-root fallback (guarded by `artifactBase !== base`) is
+// skipped. CONTEXT is written to the project root, not projected into the
+// worktree, so verification finds nothing → "existsSync false" → re-dispatch
+// 3× → stuck-loop stop. These tests pin the real call site.
+// ---------------------------------------------------------------------------
+
+test("#870: discuss-milestone falls back to project root when base IS the canonical-layout worktree", () => {
+  closeDatabase();
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-canonical-wt-"));
+  try {
+    // CONTEXT lives ONLY at the project root (flat-phase layout).
+    const phaseDir = join(projectRoot, ".gsd", "phases", "15-m015");
+    mkdirSync(phaseDir, { recursive: true });
+    writeFileSync(join(phaseDir, "15-CONTEXT.md"), "# M015 context\n");
+
+    // Canonical-layout worktree: <root>/.gsd-worktrees/<MID>/. Registered
+    // with git (.git file) so resolveCanonicalMilestoneRoot treats it as the
+    // canonical milestone root — but it has NO phases/ projection.
+    const wtRoot = join(projectRoot, ".gsd-worktrees", "M015");
+    mkdirSync(join(wtRoot, ".gsd", "milestones", "M015"), { recursive: true });
+    writeFileSync(join(wtRoot, ".gsd", "milestones", "M015", "M015-META.json"), '{"branch":"milestone/M015"}');
+    writeFileSync(join(wtRoot, ".git"), "gitdir: /fake/path");
+
+    // Real call site: base = worktree path (workspaceRoot).
+    assert.equal(
+      verifyExpectedArtifact("discuss-milestone", "M015", wtRoot),
+      true,
+      "must fall back to project root when base is the canonical-layout worktree",
+    );
+  } finally {
+    closeDatabase();
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test("#870: discuss-milestone also falls back when base is the legacy-layout worktree", () => {
+  closeDatabase();
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-legacy-wt-"));
+  try {
+    const phaseDir = join(projectRoot, ".gsd", "phases", "15-m015");
+    mkdirSync(phaseDir, { recursive: true });
+    writeFileSync(join(phaseDir, "15-CONTEXT.md"), "# M015 context\n");
+
+    const wtRoot = join(projectRoot, ".gsd", "worktrees", "M015");
+    mkdirSync(join(wtRoot, ".gsd", "milestones", "M015"), { recursive: true });
+    writeFileSync(join(wtRoot, ".git"), "gitdir: /fake/path");
+
+    assert.equal(
+      verifyExpectedArtifact("discuss-milestone", "M015", wtRoot),
+      true,
+      "must fall back to project root when base is the legacy-layout worktree",
+    );
+  } finally {
+    closeDatabase();
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
+});

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

@@ -11,6 +11,8 @@ import {
   loadVisualizerData,
   type VisualizerMilestone,
 } from "../visualizer-data.ts";
+import { _getAdapter, closeDatabase, openDatabase } from "../gsd-db.ts";
+import { createMemory } from "../memory-store.ts";
 
 test("computeCriticalPath follows milestone dependencies", () => {
   const milestones: VisualizerMilestone[] = [
@@ -82,3 +84,88 @@ test("loadVisualizerData hydrates milestones, captures, stats, and health fields
     rmSync(base, { recursive: true, force: true });
   }
 });
+
+test("loadVisualizerData includes active memory-store entries", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-visualizer-memories-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(":memory:");
+
+    createMemory({
+      category: "gotcha",
+      content: "Visualizer memory rows must come from the memory store",
+      confidence: 0.92,
+      scope: "M001/S01",
+      tags: ["visualizer", "memory"],
+    });
+    createMemory({
+      category: "pattern",
+      content: "Superseded rows should stay out of the visualizer",
+      confidence: 0.2,
+    });
+
+    const adapter = _getAdapter();
+    adapter?.prepare("UPDATE memories SET superseded_by = 'MEM999' WHERE id = 'MEM002'").run();
+
+    const data = await loadVisualizerData(base);
+
+    assert.equal(data.memories.totalCount, 1);
+    assert.equal(data.memories.entries[0]?.id, "MEM001");
+    assert.equal(data.memories.entries[0]?.category, "gotcha");
+    assert.equal(data.memories.entries[0]?.content, "Visualizer memory rows must come from the memory store");
+    assert.equal(data.memories.entries[0]?.scope, "M001/S01");
+    assert.deepEqual(data.memories.entries[0]?.tags, ["visualizer", "memory"]);
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("loadVisualizerData opens the project DB for memory entries when none is open", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-visualizer-memories-db-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    createMemory({
+      category: "gotcha",
+      content: "Browser visualizer child processes must open the project DB",
+      confidence: 0.88,
+      tags: ["browser", "visualizer"],
+    });
+    closeDatabase();
+
+    const data = await loadVisualizerData(base);
+
+    assert.equal(data.memories.totalCount, 1);
+    assert.equal(data.memories.entries[0]?.id, "MEM001");
+    assert.equal(data.memories.entries[0]?.content, "Browser visualizer child processes must open the project DB");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("loadVisualizerData caps memory content for visualizer payloads", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-visualizer-memory-cap-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(":memory:");
+    const largeContent = "A".repeat(2500);
+    createMemory({
+      category: "gotcha",
+      content: largeContent,
+      confidence: 0.9,
+    });
+
+    const data = await loadVisualizerData(base);
+
+    const content = data.memories.entries[0]?.content ?? "";
+    assert.equal(data.memories.totalCount, 1);
+    assert.ok(content.length < largeContent.length);
+    assert.ok(content.length <= 2003);
+    assert.ok(content.endsWith("..."));
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/visualizer-views.test.ts

@@ -49,6 +49,7 @@ function makeVisualizerData(overrides: Partial<VisualizerData> = {}): Visualizer
     changelog: { entries: [] },
     sliceVerifications: [],
     knowledge: { rules: [], patterns: [], lessons: [], exists: false },
+    memories: { entries: [], totalCount: 0 },
     captures: { entries: [], pendingCount: 0, totalCount: 0 },
     health: {
       budgetCeiling: undefined,
@@ -617,6 +618,32 @@ console.log("\n=== renderKnowledgeView ===");
   assert.ok(lines.some(l => l.includes("No KNOWLEDGE.md found")), "shows no-knowledge message");
 }
 
+{
+  const data = makeVisualizerData({
+    memories: {
+      totalCount: 1,
+      entries: [
+        {
+          id: "MEM001",
+          category: "gotcha",
+          content: "Use memory store rows for durable project facts",
+          confidence: 0.91,
+          hitCount: 3,
+          scope: "M001/S01",
+          tags: ["visualizer"],
+          updatedAt: "2026-06-21T12:00:00.000Z",
+        },
+      ],
+    },
+  });
+  const lines = renderKnowledgeView(data, mockTheme, 100);
+  assert.ok(lines.some(l => l.includes("Memories")), "shows memories section");
+  assert.ok(lines.some(l => l.includes("MEM001")), "shows memory ID");
+  assert.ok(lines.some(l => l.includes("(gotcha")), "shows memory category");
+  assert.ok(lines.some(l => l.includes("Use memory store rows")), "shows memory content");
+  assert.ok(lines.some(l => l.includes("M001/S01")), "shows memory scope");
+}
+
 // ─── renderCapturesView ─────────────────────────────────────────────────────
 
 console.log("\n=== renderCapturesView ===");