@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.c18009cd

package/src/resources/extensions/gsd/tests/doctor-workspace.test.ts

@@ -0,0 +1,207 @@
+/**
+ * doctor-workspace.test.ts — Parent-workspace declared-repository probe (#818).
+ *
+ * Covers:
+ *   - declared child repo path missing on disk → workspace_repo_path_missing
+ *   - declared child repo path exists but is not a git repo → workspace_repo_not_a_repo
+ *   - valid child repos → no workspace issues
+ *   - single-repo (project-mode) project → probe is a no-op
+ *   - non-git parent root is handled gracefully (the common layout)
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { chmodSync, mkdtempSync, mkdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { delimiter, join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import { runGSDDoctor } from "../doctor.ts";
+import { GIT_NO_PROMPT_ENV } from "../git-constants.ts";
+
+function gitInit(cwd: string): void {
+  execFileSync("git", ["init"], { cwd, stdio: "ignore" });
+}
+
+function writeParentPrefs(base: string, repos: Record<string, { path: string }>): void {
+  const repoLines = Object.entries(repos)
+    .map(([id, cfg]) => `    ${id}:\n      path: ${cfg.path}`)
+    .join("\n");
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    `---\nversion: 1\nworkspace:\n  mode: parent\n  repositories:\n${repoLines}\n---\n`,
+    "utf-8",
+  );
+}
+
+test("doctor flags a declared child repo whose path is missing on disk", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-ws-missing-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    gitInit(base);
+    // `frontend` is declared but never created on disk.
+    writeParentPrefs(base, { frontend: { path: "frontend" } });
+
+    const report = await runGSDDoctor(base);
+    const issue = report.issues.find((i) => i.code === "workspace_repo_path_missing");
+    assert.ok(issue, "expected a workspace_repo_path_missing issue");
+    assert.equal(issue?.unitId, "workspace.repositories.frontend");
+    assert.match(issue?.message ?? "", /does not exist on disk/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("doctor flags a declared child repo path that is not a git repository", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-ws-notrepo-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    gitInit(base);
+    // `backend` exists as a plain directory but is not a git repo.
+    mkdirSync(join(base, "backend"), { recursive: true });
+    writeParentPrefs(base, { backend: { path: "backend" } });
+
+    const report = await runGSDDoctor(base);
+    const issue = report.issues.find((i) => i.code === "workspace_repo_not_a_repo");
+    assert.ok(issue, "expected a workspace_repo_not_a_repo issue");
+    assert.equal(issue?.unitId, "workspace.repositories.backend");
+    assert.match(issue?.message ?? "", /not a git repository/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("doctor reports no workspace issues when declared child repos are valid", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-ws-valid-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    gitInit(base);
+    mkdirSync(join(base, "frontend"), { recursive: true });
+    gitInit(join(base, "frontend"));
+    writeParentPrefs(base, { frontend: { path: "frontend" } });
+
+    const report = await runGSDDoctor(base);
+    const wsIssues = report.issues.filter(
+      (i) => i.code === "workspace_repo_path_missing" || i.code === "workspace_repo_not_a_repo",
+    );
+    assert.deepEqual(wsIssues, []);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("doctor workspace git probe uses safe env and canonical toplevel comparison", async (t) => {
+  if (process.platform === "win32") {
+    t.skip("POSIX-only git shim regression");
+    return;
+  }
+
+  const originalProcessGitDir = process.env.GIT_DIR;
+  const originalProcessGitWorkTree = process.env.GIT_WORK_TREE;
+  const originalGitEnvPath = GIT_NO_PROMPT_ENV.PATH;
+  const originalGitEnvRealGit = GIT_NO_PROMPT_ENV.GSD_REAL_GIT;
+  const originalGitEnvFakeCwd = GIT_NO_PROMPT_ENV.GSD_FAKE_TOPLEVEL_CWD;
+  const originalGitEnvFakeToplevel = GIT_NO_PROMPT_ENV.GSD_FAKE_TOPLEVEL;
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-ws-safeenv-"));
+
+  t.after(() => {
+    if (originalProcessGitDir === undefined) delete process.env.GIT_DIR;
+    else process.env.GIT_DIR = originalProcessGitDir;
+    if (originalProcessGitWorkTree === undefined) delete process.env.GIT_WORK_TREE;
+    else process.env.GIT_WORK_TREE = originalProcessGitWorkTree;
+    if (originalGitEnvPath === undefined) delete GIT_NO_PROMPT_ENV.PATH;
+    else GIT_NO_PROMPT_ENV.PATH = originalGitEnvPath;
+    if (originalGitEnvRealGit === undefined) delete GIT_NO_PROMPT_ENV.GSD_REAL_GIT;
+    else GIT_NO_PROMPT_ENV.GSD_REAL_GIT = originalGitEnvRealGit;
+    if (originalGitEnvFakeCwd === undefined) delete GIT_NO_PROMPT_ENV.GSD_FAKE_TOPLEVEL_CWD;
+    else GIT_NO_PROMPT_ENV.GSD_FAKE_TOPLEVEL_CWD = originalGitEnvFakeCwd;
+    if (originalGitEnvFakeToplevel === undefined) delete GIT_NO_PROMPT_ENV.GSD_FAKE_TOPLEVEL;
+    else GIT_NO_PROMPT_ENV.GSD_FAKE_TOPLEVEL = originalGitEnvFakeToplevel;
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  const realChild = join(base, "frontend-real");
+  const linkedChild = join(base, "frontend");
+  mkdirSync(realChild, { recursive: true });
+  gitInit(realChild);
+  symlinkSync(realChild, linkedChild, "dir");
+  writeParentPrefs(base, { frontend: { path: "frontend" } });
+
+  const shimDir = join(base, "bin");
+  mkdirSync(shimDir, { recursive: true });
+  const realGit = execFileSync("which", ["git"], { encoding: "utf-8" }).trim();
+  const shim = join(shimDir, "git");
+  writeFileSync(
+    shim,
+    [
+      "#!/usr/bin/env bash",
+      "set -euo pipefail",
+      "if [ -n \"${GIT_DIR:-}\" ] || [ -n \"${GIT_WORK_TREE:-}\" ]; then",
+      "  echo \"leaked git env\" >&2",
+      "  exit 97",
+      "fi",
+      "if [ \"${1:-}\" = \"rev-parse\" ] && [ \"${2:-}\" = \"--show-toplevel\" ] && [ \"$(pwd -P)\" = \"$GSD_FAKE_TOPLEVEL_CWD\" ]; then",
+      "  printf '%s\\n' \"$GSD_FAKE_TOPLEVEL\"",
+      "  exit 0",
+      "fi",
+      "exec \"$GSD_REAL_GIT\" \"$@\"",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+  chmodSync(shim, 0o755);
+
+  process.env.GIT_DIR = join(base, ".git");
+  process.env.GIT_WORK_TREE = base;
+  GIT_NO_PROMPT_ENV.PATH = `${shimDir}${delimiter}${process.env.PATH ?? ""}`;
+  GIT_NO_PROMPT_ENV.GSD_REAL_GIT = realGit;
+  GIT_NO_PROMPT_ENV.GSD_FAKE_TOPLEVEL_CWD = realChild;
+  GIT_NO_PROMPT_ENV.GSD_FAKE_TOPLEVEL = linkedChild;
+
+  const report = await runGSDDoctor(base);
+  const wsIssues = report.issues.filter(
+    (i) => i.code === "workspace_repo_path_missing" || i.code === "workspace_repo_not_a_repo",
+  );
+  assert.deepEqual(wsIssues, []);
+});
+
+test("doctor workspace probe is a no-op for single-repo (project-mode) projects", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-ws-noproj-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    gitInit(base);
+    // No workspace config → project mode (default).
+    const report = await runGSDDoctor(base);
+    const wsIssues = report.issues.filter(
+      (i) => i.code === "workspace_repo_path_missing" || i.code === "workspace_repo_not_a_repo",
+    );
+    assert.deepEqual(wsIssues, []);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("doctor runs cleanly when the parent root is itself not a git repo (common layout)", async () => {
+  // Regression guard (#818 cross-cutting): a parent folder holding child git
+  // repos need not be a git repo itself. Doctor must not crash and must not
+  // treat the parent as a missing/non-repo child.
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-ws-nongitparent-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    // NOTE: no gitInit(base) — parent is a plain folder.
+    mkdirSync(join(base, "frontend"), { recursive: true });
+    gitInit(join(base, "frontend"));
+    writeParentPrefs(base, { frontend: { path: "frontend" } });
+
+    const report = await runGSDDoctor(base);
+    // The declared child repo is valid; the non-git parent must not produce a
+    // child-repo issue or crash the run.
+    const wsIssues = report.issues.filter(
+      (i) => i.code === "workspace_repo_path_missing" || i.code === "workspace_repo_not_a_repo",
+    );
+    assert.deepEqual(wsIssues, []);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/ensure-preconditions-guard-4996.test.ts

@@ -14,12 +14,13 @@ import {
   closeDatabase,
   insertMilestone,
 } from "../gsd-db.ts";
+import { canonicalPhaseDirName } from "../paths.ts";
 
 import type { GSDState } from "../types.ts";
 
 function makeBase(prefix = "gsd-precond-"): string {
   const base = mkdtempSync(join(tmpdir(), prefix));
-  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "phases"), { recursive: true });
   return base;
 }
 
@@ -50,7 +51,8 @@ describe("ensurePreconditions phantom-dir guard (#4996)", () => {
 
     ensurePreconditions("execute-task", "M003/S01", base, state);
 
-    const milestoneDir = join(base, ".gsd", "milestones", "M003");
+    // Flat-phase: phantom guard must not create any phase dir for an unrecognised milestone.
+    const milestoneDir = join(base, ".gsd", "phases", canonicalPhaseDirName("M003"));
     assert.ok(!existsSync(milestoneDir), "M003 dir must not be created for phantom slice dispatch");
   });
 
@@ -63,22 +65,26 @@ describe("ensurePreconditions phantom-dir guard (#4996)", () => {
 
     ensurePreconditions("execute-task", "M003/S01", base, state);
 
-    const milestoneDir = join(base, ".gsd", "milestones", "M003");
-    assert.ok(existsSync(milestoneDir), "M003 dir must be created when DB row exists");
+    // Flat-phase: dir is created under phases/ using the canonical phase dir name.
+    const milestoneDir = join(base, ".gsd", "phases", canonicalPhaseDirName("M003"));
+    assert.ok(existsSync(milestoneDir), "M003 phase dir must be created when DB row exists");
   });
 
-  it("(c) slice unit ID for existing milestone dir with CONTEXT.md content file uses normal scaffolding", () => {
+  it("(c) slice unit ID for existing milestone dir with CONTEXT.md content file does not clobber it", () => {
     base = makeBase();
     const mid = "M003";
-    const milestoneDir = join(base, ".gsd", "milestones", mid);
+    // Use canonicalPhaseDirName so the dir is found by resolveMilestonePath.
+    const milestoneDir = join(base, ".gsd", "phases", canonicalPhaseDirName(mid));
     mkdirSync(milestoneDir, { recursive: true });
     writeFileSync(join(milestoneDir, `${mid}-CONTEXT.md`), "# Context\n");
     const state = makeMinimalState();
 
     ensurePreconditions("execute-task", "M003/S01", base, state);
 
-    const slicesDir = join(milestoneDir, "slices");
-    assert.ok(existsSync(slicesDir), "existing milestone dir should allow slice scaffolding");
+    // Flat-phase: ensurePreconditions returns early when the phase dir already exists.
+    // Tasks are checkboxes in plan files — no slices/ subdir is created.
+    assert.ok(existsSync(milestoneDir), "existing milestone dir must survive ensurePreconditions");
+    assert.ok(!existsSync(join(milestoneDir, "slices")), "flat-phase must not scaffold slices/ subdir");
   });
 
   it("(d) milestone-only unit ID (no slice) still creates dir even with no DB row", () => {
@@ -87,7 +93,8 @@ describe("ensurePreconditions phantom-dir guard (#4996)", () => {
 
     ensurePreconditions("discuss-milestone", "M003", base, state);
 
-    const milestoneDir = join(base, ".gsd", "milestones", "M003");
-    assert.ok(existsSync(milestoneDir), "M003 dir must be created for milestone-only dispatch");
+    // Flat-phase: dir is created under phases/ using the canonical phase dir name.
+    const milestoneDir = join(base, ".gsd", "phases", canonicalPhaseDirName("M003"));
+    assert.ok(existsSync(milestoneDir), "M003 phase dir must be created for milestone-only dispatch");
   });
 });

package/src/resources/extensions/gsd/tests/evidence-cross-ref.test.ts

@@ -86,6 +86,101 @@ test("stale verification evidence batches are ignored when a newer completion ba
   assert.deepEqual(mismatches, []);
 });
 
+test("WSL bash-spawn failure is not flagged as a falsified passing verification", () => {
+  // Issue #814: on Windows, `gsd_exec runtime=bash` resolves to a WSL with no
+  // /bin/bash. The bash-runtime verification call exits 1 with a spawn-failure
+  // banner (the command never ran); the LLM re-ran via a node runtime (exit 0)
+  // that findMatches does not capture. The infra failure must not block.
+  const command = "npx playwright test e2e/m039-s05-comparison-legibility.spec.ts";
+  const mismatches = crossReferenceEvidence(
+    [{ command, exitCode: 0, verdict: "passed" }],
+    [
+      {
+        kind: "bash",
+        toolCallId: "call-1",
+        command: `${command} --reporter=line 2>&1 | tail -40`,
+        exitCode: 1,
+        outputSnippet:
+          "<3>WSL (12 - Relay) ERROR: CreateProcessCommon:800: execvpe(/bin/bash) failed: No such file or directory",
+        timestamp: 1,
+      },
+    ] as EvidenceEntry[],
+  );
+
+  assert.equal(mismatches.length, 1);
+  assert.equal(mismatches[0].severity, "warning");
+  assert.match(mismatches[0].reason, /inconclusive/);
+});
+
+test("missing tool failure (command not found: eslint) is a real error, not an infra spawn failure", () => {
+  // Regression for overly-broad spawn signature: `command not found: eslint`
+  // is a genuine verification failure (eslint not installed), not a missing
+  // shell interpreter. It must produce a blocking error, not a warning.
+  const command = "eslint src/";
+  const mismatches = crossReferenceEvidence(
+    [{ command, exitCode: 0, verdict: "passed" }],
+    [
+      {
+        kind: "bash",
+        toolCallId: "call-1",
+        command,
+        exitCode: 1,
+        outputSnippet: "zsh: command not found: eslint",
+        timestamp: Date.now(),
+      },
+    ] as EvidenceEntry[],
+  );
+
+  assert.equal(mismatches.length, 1);
+  assert.equal(mismatches[0].severity, "error");
+  assert.match(mismatches[0].reason, /Claimed exitCode=0/);
+});
+
+test("missing tool failure (command not found: node) is a real error, not an infra spawn failure", () => {
+  // node is not a shell interpreter; its absence is a genuine env problem,
+  // not a shell-spawn infra failure.
+  const command = "node --test tests/verify.test.js";
+  const mismatches = crossReferenceEvidence(
+    [{ command, exitCode: 0, verdict: "passed" }],
+    [
+      {
+        kind: "bash",
+        toolCallId: "call-1",
+        command,
+        exitCode: 127,
+        outputSnippet: "bash: command not found: node",
+        timestamp: Date.now(),
+      },
+    ] as EvidenceEntry[],
+  );
+
+  assert.equal(mismatches.length, 1);
+  assert.equal(mismatches[0].severity, "error");
+  assert.match(mismatches[0].reason, /Claimed exitCode=0/);
+});
+
+test("missing shell interpreter (command not found: bash) is treated as an infra spawn failure", () => {
+  // bash itself missing is the shell-spawn infra case; must remain a warning.
+  const command = "npm test";
+  const mismatches = crossReferenceEvidence(
+    [{ command, exitCode: 0, verdict: "passed" }],
+    [
+      {
+        kind: "bash",
+        toolCallId: "call-1",
+        command,
+        exitCode: 1,
+        outputSnippet: "command not found: bash",
+        timestamp: Date.now(),
+      },
+    ] as EvidenceEntry[],
+  );
+
+  assert.equal(mismatches.length, 1);
+  assert.equal(mismatches[0].severity, "warning");
+  assert.match(mismatches[0].reason, /inconclusive/);
+});
+
 test("missing recorded bash evidence remains a warning", () => {
   const mismatches = crossReferenceEvidence(
     [{ command: "npm test", exitCode: 0, verdict: "passed" }],

package/src/resources/extensions/gsd/tests/exec-graceful-kill.test.ts

@@ -63,6 +63,44 @@ function wallClockGuard<T>(promise: Promise<T>, ms: number): Promise<T> {
   ]);
 }
 
+test(
+  'runExecSandbox: aborted signal terminates promptly without waiting for timeout',
+  { timeout: 10_000 },
+  async (t) => {
+    const base = freshBase();
+    t.after(() => cleanup(base));
+
+    const controller = new AbortController();
+    controller.abort();
+    const TIMEOUT_MS = 10_000;
+
+    const start = Date.now();
+    const result = await wallClockGuard(
+      runExecSandbox(
+        { runtime: 'node', script: 'setTimeout(() => {}, 30_000);', timeout_ms: TIMEOUT_MS },
+        baseOpts(base, {
+          signal: controller.signal,
+          kill_grace_ms: 500,
+          force_resolve_delay_ms: 2_000,
+        }),
+      ),
+      5_000,
+    );
+    const elapsed = Date.now() - start;
+
+    assert.equal(result.aborted, true, 'aborted signal must be recorded on the sandbox result');
+    assert.equal(result.timed_out, false, 'client abort must not be reported as a sandbox timeout');
+    assert.ok(elapsed < TIMEOUT_MS, `expected abort before ${TIMEOUT_MS}ms timeout, took ${elapsed}ms`);
+    assert.ok(
+      result.duration_ms < TIMEOUT_MS,
+      `expected result duration before timeout, got ${result.duration_ms}ms`,
+    );
+    const meta = JSON.parse(readFileSync(result.meta_path, 'utf-8'));
+    assert.equal(meta.aborted, true, 'meta.json must persist the aborted marker');
+    assert.equal(meta.timed_out, false, 'meta.json must not report timed_out when abort caused the kill');
+  },
+);
+
 // Clean up a detached child (and its process group) that a large kill_grace_ms
 // intentionally leaves alive past the force-resolve deadline.
 function cleanupByPidFile(pidFile: string): void {

package/src/resources/extensions/gsd/tests/exec-sandbox.test.ts

@@ -7,6 +7,7 @@ import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync } from 'node:f
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
+import { getShellConfig } from '@gsd/pi-coding-agent';
 import { EXEC_DEFAULTS, runExecSandbox, type ExecSandboxOptions } from '../exec-sandbox.ts';
 import { buildExecOptions, executeGsdExec } from '../tools/exec-tool.ts';
 import { isContextModeEnabled } from '../preferences-types.ts';
@@ -53,6 +54,21 @@ test('runExecSandbox: captures stdout, persists artifacts, returns digest', asyn
   }
 });
 
+test('runExecSandbox: bash runtime uses resolved shell config', async () => {
+  const base = freshBase();
+  try {
+    const { shell } = getShellConfig();
+    const result = await runExecSandbox(
+      { runtime: 'bash', script: 'printf "%s" "$0"' },
+      baseOpts(base),
+    );
+    assert.equal(result.exit_code, 0);
+    assert.equal(readFileSync(result.stdout_path, 'utf-8'), shell);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('runExecSandbox: persists optional request metadata', async () => {
   const base = freshBase();
   try {

package/src/resources/extensions/gsd/tests/exec-tool.test.ts

@@ -3,7 +3,7 @@ import assert from "node:assert/strict";
 
 import { registerExecTools } from "../bootstrap/exec-tools.ts";
 import { executeGsdExec, executeUatExec } from "../tools/exec-tool.ts";
-import type { ExecSandboxRequest, ExecSandboxResult } from "../exec-sandbox.ts";
+import type { ExecSandboxOptions, ExecSandboxRequest, ExecSandboxResult } from "../exec-sandbox.ts";
 
 function makeExecResult(request: ExecSandboxRequest): ExecSandboxResult {
   return {
@@ -12,6 +12,7 @@ function makeExecResult(request: ExecSandboxRequest): ExecSandboxResult {
     exit_code: 0,
     signal: null,
     timed_out: false,
+    aborted: false,
     force_resolved: false,
     duration_ms: 1,
     stdout_bytes: 12,
@@ -52,6 +53,49 @@ test("executeUatExec accepts evidence-mode aliases for intent", async () => {
   assert.equal(requests[0]?.metadata?.intent, "uat-artifact-check");
 });
 
+test("executeGsdExec passes AbortSignal into sandbox options", async () => {
+  const controller = new AbortController();
+  let capturedSignal: AbortSignal | undefined;
+
+  const result = await executeGsdExec(
+    { runtime: "bash", script: "sleep 60" },
+    {
+      baseDir: "/tmp/gsd-exec-abort-signal-test",
+      preferences: null,
+      signal: controller.signal,
+      run: async (request, opts: ExecSandboxOptions) => {
+        capturedSignal = opts.signal;
+        return makeExecResult(request);
+      },
+    },
+  );
+
+  assert.equal(result.isError, false);
+  assert.equal(capturedSignal, controller.signal);
+});
+
+test("gsd_exec surfaces aborted child termination distinctly from a clean exit", async () => {
+  const result = await executeGsdExec(
+    { runtime: "bash", script: "trap 'exit 0' TERM; sleep 60" },
+    {
+      baseDir: "/tmp/gsd-exec-aborted-test",
+      preferences: null,
+      run: async (request) => ({
+        ...makeExecResult(request),
+        aborted: true,
+        exit_code: 0,
+        signal: null,
+        digest: "[no stdout — aborted]",
+      }),
+    },
+  );
+
+  assert.equal(result.isError, true, "an aborted run must be an error even if the child exits 0");
+  assert.equal(result.details?.aborted, true, "details must expose aborted");
+  const text = result.content.map((c) => c.text ?? "").join("\n");
+  assert.match(text, /exit=aborted/, "summary must distinguish an aborted result");
+});
+
 test("gsd_exec surfaces a force-resolved (D-state) kill distinctly from a clean exit", async () => {
   // A hard-deadline force-resolve sets force_resolved=true with a synthetic SIGKILL
   // signal and null exit code. The tool result must carry that flag in details and

package/src/resources/extensions/gsd/tests/export-html-enhancements.test.ts

@@ -108,6 +108,7 @@ function mockData(overrides: Partial<VisualizerData> = {}): VisualizerData {
     changelog: { entries: [] },
     sliceVerifications: [],
     knowledge: { rules: [], patterns: [], lessons: [], exists: false },
+    memories: { entries: [], totalCount: 0 },
     captures: { entries: [], pendingCount: 0, totalCount: 0 },
     health: {
       budgetCeiling: undefined,
@@ -149,6 +150,30 @@ test("report uses the shared GSD HTML shell", () => {
   assert.ok(html.includes('<main>'), "should render content inside shared shell main");
 });
 
+test("knowledge section renders active memories", () => {
+  const html = generateHtmlReport(mockData({
+    memories: {
+      totalCount: 1,
+      entries: [
+        {
+          id: "MEM001",
+          category: "gotcha",
+          content: "Memory rows must be visible in exported visualizer reports",
+          confidence: 0.9,
+          hitCount: 2,
+          scope: "project",
+          tags: ["visualizer"],
+          updatedAt: "2026-06-21T12:00:00.000Z",
+        },
+      ],
+    },
+  }), mockOpts());
+
+  assert.ok(html.includes("Memories"), "should render memories heading");
+  assert.ok(html.includes("MEM001"), "should render memory ID");
+  assert.ok(html.includes("Memory rows must be visible"), "should render memory content");
+});
+
 test("Feature 1: executive summary includes budget context when set", () => {
   const data = mockData({ health: { ...mockData().health, budgetCeiling: 10.00 } });
   const html = generateHtmlReport(data, mockOpts());