gsd-pi 2.33.1 → 2.34.0-dev.6769913

package/dist/resources/extensions/gsd/tests/mechanical-completion.test.ts

@@ -1,356 +0,0 @@
-/**
- * Mechanical Completion — unit tests (ADR-003).
- *
- * Tests deterministic slice/milestone completion using fixture data.
- * Uses node:test + node:assert for consistency with token-profile.test.ts.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdirSync, writeFileSync, readFileSync, rmSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { randomBytes } from "node:crypto";
-
-// ─── Fixture Helpers ──────────────────────────────────────────────────────────
-
-function createTmpBase(): string {
-  const base = join(tmpdir(), `gsd-mech-test-${randomBytes(4).toString("hex")}`);
-  mkdirSync(base, { recursive: true });
-  return base;
-}
-
-function scaffold(base: string, mid: string, sid: string, taskSummaries: Array<{ tid: string; content: string }>) {
-  const gsdRoot = join(base, ".gsd");
-  const mDir = join(gsdRoot, "milestones", mid);
-  const sDir = join(mDir, "slices", sid);
-  const tDir = join(sDir, "tasks");
-  mkdirSync(tDir, { recursive: true });
-
-  for (const { tid, content } of taskSummaries) {
-    writeFileSync(join(tDir, `${tid}-SUMMARY.md`), content, "utf-8");
-  }
-
-  return { gsdRoot, mDir, sDir, tDir };
-}
-
-function makeTaskSummary(tid: string, opts: {
-  oneLiner?: string;
-  provides?: string[];
-  key_files?: string[];
-  key_decisions?: string[];
-  verification_result?: string;
-}): string {
-  const lines: string[] = [
-    "---",
-    `id: ${tid}`,
-    `parent: S01`,
-    `milestone: M001`,
-  ];
-  if (opts.provides?.length) lines.push(`provides:\n${opts.provides.map(p => `  - ${p}`).join("\n")}`);
-  if (opts.key_files?.length) lines.push(`key_files:\n${opts.key_files.map(f => `  - ${f}`).join("\n")}`);
-  if (opts.key_decisions?.length) lines.push(`key_decisions:\n${opts.key_decisions.map(d => `  - ${d}`).join("\n")}`);
-  lines.push(`verification_result: ${opts.verification_result ?? "passed"}`);
-  lines.push("---");
-  lines.push("");
-  lines.push(`# ${tid}: Test Task`);
-  lines.push("");
-  if (opts.oneLiner) lines.push(`**${opts.oneLiner}**`);
-  lines.push("");
-  lines.push("## What Happened");
-  lines.push("");
-  lines.push(`Implemented the feature described in ${tid}. This was a significant change that modified multiple files across the codebase to support the new functionality.`);
-  lines.push("");
-  return lines.join("\n");
-}
-
-// ─── Source-level structural tests ────────────────────────────────────────────
-
-const mechanicalSrc = readFileSync(
-  join(import.meta.dirname!, "..", "mechanical-completion.ts"),
-  "utf-8",
-);
-
-test("mechanical-completion: exports mechanicalSliceCompletion", () => {
-  assert.ok(
-    mechanicalSrc.includes("export async function mechanicalSliceCompletion"),
-    "should export mechanicalSliceCompletion",
-  );
-});
-
-test("mechanical-completion: exports aggregateMilestoneVerification", () => {
-  assert.ok(
-    mechanicalSrc.includes("export async function aggregateMilestoneVerification"),
-    "should export aggregateMilestoneVerification",
-  );
-});
-
-test("mechanical-completion: exports generateMilestoneSummary", () => {
-  assert.ok(
-    mechanicalSrc.includes("export async function generateMilestoneSummary"),
-    "should export generateMilestoneSummary",
-  );
-});
-
-test("mechanical-completion: exports appendNewDecisions", () => {
-  assert.ok(
-    mechanicalSrc.includes("export async function appendNewDecisions"),
-    "should export appendNewDecisions",
-  );
-});
-
-test("mechanical-completion: uses atomicWriteSync for file writes", () => {
-  assert.ok(
-    mechanicalSrc.includes("atomicWriteSync"),
-    "should use atomicWriteSync for safe file writes",
-  );
-});
-
-test("mechanical-completion: quality gate checks summary length for multi-task slices", () => {
-  assert.ok(
-    mechanicalSrc.includes("totalContent.length < 200"),
-    "should have quality gate for summary content length",
-  );
-});
-
-test("mechanical-completion: marks slice [x] in roadmap", () => {
-  assert.ok(
-    mechanicalSrc.includes("markSliceInRoadmap"),
-    "should mark slice done in roadmap",
-  );
-});
-
-test("mechanical-completion: aggregates VERIFY.json files for milestone validation", () => {
-  assert.ok(
-    mechanicalSrc.includes("resolveTaskJsonFiles") && mechanicalSrc.includes("VERIFY"),
-    "should read VERIFY.json files for milestone validation",
-  );
-});
-
-test("mechanical-completion: deduplicates decisions against existing DECISIONS.md", () => {
-  assert.ok(
-    mechanicalSrc.includes("existing.includes(d.trim())"),
-    "should deduplicate decisions against existing content",
-  );
-});
-
-test("mechanical-completion: produces VALIDATION.md with verdict frontmatter", () => {
-  assert.ok(
-    mechanicalSrc.includes("verdict:") && mechanicalSrc.includes("remediation_round: 0"),
-    "VALIDATION.md should have verdict and remediation_round frontmatter",
-  );
-});
-
-// ─── Integration tests with fixture data ──────────────────────────────────────
-
-test("mechanical: slice completion with 2 task summaries produces SUMMARY.md", async () => {
-  const base = createTmpBase();
-  try {
-    const mid = "M001";
-    const sid = "S01";
-
-    // Scaffold task summaries
-    scaffold(base, mid, sid, [
-      {
-        tid: "T01",
-        content: makeTaskSummary("T01", {
-          oneLiner: "Set up project structure",
-          provides: ["project-scaffold"],
-          key_files: ["src/index.ts", "package.json"],
-          verification_result: "passed",
-        }),
-      },
-      {
-        tid: "T02",
-        content: makeTaskSummary("T02", {
-          oneLiner: "Add core API endpoints",
-          provides: ["api-endpoints"],
-          key_files: ["src/api.ts"],
-          key_decisions: ["Used Express over Fastify"],
-          verification_result: "passed",
-        }),
-      },
-    ]);
-
-    // Write a roadmap with the slice unchecked
-    const roadmapPath = join(base, ".gsd", "milestones", mid, `${mid}-ROADMAP.md`);
-    writeFileSync(roadmapPath, `# Roadmap\n\n- [ ] **${sid}: First Slice**\n`, "utf-8");
-
-    // Write a slice plan with Verification section
-    const planPath = join(base, ".gsd", "milestones", mid, "slices", sid, `${sid}-PLAN.md`);
-    writeFileSync(planPath, `# Plan\n\n## Verification\n\n- Run \`npm test\`\n- Check output\n`, "utf-8");
-
-    // Dynamic import to get the actual module
-    const { mechanicalSliceCompletion } = await import("../mechanical-completion.js");
-    const ok = await mechanicalSliceCompletion(base, mid, sid);
-
-    assert.ok(ok, "should return true for valid slice completion");
-
-    // Check SUMMARY.md was written
-    const summaryPath = join(base, ".gsd", "milestones", mid, "slices", sid, `${sid}-SUMMARY.md`);
-    assert.ok(existsSync(summaryPath), "SUMMARY.md should exist");
-
-    const summaryContent = readFileSync(summaryPath, "utf-8");
-    assert.ok(summaryContent.includes("T01"), "summary should reference T01");
-    assert.ok(summaryContent.includes("T02"), "summary should reference T02");
-    assert.ok(summaryContent.includes("verification_result: passed"), "should have passed verification");
-
-    // Check roadmap was updated
-    const updatedRoadmap = readFileSync(roadmapPath, "utf-8");
-    assert.ok(updatedRoadmap.includes("[x]"), "roadmap should have [x] checkbox");
-
-    // Check UAT was written
-    const uatPath = join(base, ".gsd", "milestones", mid, "slices", sid, `${sid}-UAT.md`);
-    assert.ok(existsSync(uatPath), "UAT.md should exist");
-    const uatContent = readFileSync(uatPath, "utf-8");
-    assert.ok(uatContent.includes("npm test"), "UAT should contain verification content");
-  } finally {
-    rmSync(base, { recursive: true, force: true });
-  }
-});
-
-test("mechanical: returns false for empty task summaries", async () => {
-  const base = createTmpBase();
-  try {
-    const mid = "M001";
-    const sid = "S01";
-    scaffold(base, mid, sid, []);
-
-    const { mechanicalSliceCompletion } = await import("../mechanical-completion.js");
-    const ok = await mechanicalSliceCompletion(base, mid, sid);
-    assert.ok(!ok, "should return false when no summaries exist");
-  } finally {
-    rmSync(base, { recursive: true, force: true });
-  }
-});
-
-test("mechanical: returns false for insufficient summary content in multi-task slice", async () => {
-  const base = createTmpBase();
-  try {
-    const mid = "M001";
-    const sid = "S01";
-
-    // Two tasks but with very short content (under 200 chars)
-    scaffold(base, mid, sid, [
-      { tid: "T01", content: "---\nid: T01\nparent: S01\nmilestone: M001\n---\n\n# T01: A\n\n**Short**\n" },
-      { tid: "T02", content: "---\nid: T02\nparent: S01\nmilestone: M001\n---\n\n# T02: B\n\n**Brief**\n" },
-    ]);
-
-    const { mechanicalSliceCompletion } = await import("../mechanical-completion.js");
-    const ok = await mechanicalSliceCompletion(base, mid, sid);
-    assert.ok(!ok, "should return false when summaries are too short");
-  } finally {
-    rmSync(base, { recursive: true, force: true });
-  }
-});
-
-test("mechanical: milestone verification aggregates VERIFY.json files", async () => {
-  const base = createTmpBase();
-  try {
-    const mid = "M001";
-    const sid = "S01";
-    const { tDir } = scaffold(base, mid, sid, []);
-
-    // Write VERIFY.json files
-    const evidence = {
-      schemaVersion: 1,
-      taskId: "T01",
-      unitId: "M001/S01/T01",
-      timestamp: Date.now(),
-      passed: true,
-      discoverySource: "plan",
-      checks: [
-        { command: "npm test", exitCode: 0, durationMs: 1500, verdict: "pass", blocking: true },
-      ],
-    };
-    writeFileSync(join(tDir, "T01-VERIFY.json"), JSON.stringify(evidence), "utf-8");
-
-    const evidence2 = { ...evidence, taskId: "T02", passed: false, checks: [
-      { command: "npm test", exitCode: 1, durationMs: 500, verdict: "fail", blocking: true },
-    ]};
-    writeFileSync(join(tDir, "T02-VERIFY.json"), JSON.stringify(evidence2), "utf-8");
-
-    const { aggregateMilestoneVerification } = await import("../mechanical-completion.js");
-    const result = await aggregateMilestoneVerification(base, mid);
-
-    assert.equal(result.verdict, "mixed", "should be mixed when some pass and some fail");
-    assert.equal(result.checks.length, 2, "should have 2 checks");
-
-    // Check VALIDATION.md was written
-    const validationPath = join(base, ".gsd", "milestones", mid, `${mid}-VALIDATION.md`);
-    assert.ok(existsSync(validationPath), "VALIDATION.md should exist");
-    const validationContent = readFileSync(validationPath, "utf-8");
-    assert.ok(validationContent.includes("verdict: mixed"), "should have mixed verdict in frontmatter");
-  } finally {
-    rmSync(base, { recursive: true, force: true });
-  }
-});
-
-test("mechanical: milestone summary aggregates slice summaries", async () => {
-  const base = createTmpBase();
-  try {
-    const mid = "M001";
-
-    // Create two slices with summaries
-    for (const sid of ["S01", "S02"]) {
-      const sDir = join(base, ".gsd", "milestones", mid, "slices", sid);
-      mkdirSync(sDir, { recursive: true });
-      writeFileSync(
-        join(sDir, `${sid}-SUMMARY.md`),
-        `---\nid: ${sid}\nprovides:\n  - feature-${sid.toLowerCase()}\nkey_files:\n  - src/${sid.toLowerCase()}.ts\n---\n\n# ${sid}: Slice\n\n**${sid} implemented**\n`,
-        "utf-8",
-      );
-    }
-
-    const { generateMilestoneSummary } = await import("../mechanical-completion.js");
-    const content = await generateMilestoneSummary(base, mid);
-
-    assert.ok(content.includes("S01"), "should reference S01");
-    assert.ok(content.includes("S02"), "should reference S02");
-    assert.ok(content.includes("feature-s01"), "should aggregate provides");
-    assert.ok(content.includes("feature-s02"), "should aggregate provides");
-
-    const summaryPath = join(base, ".gsd", "milestones", mid, `${mid}-SUMMARY.md`);
-    assert.ok(existsSync(summaryPath), "M##-SUMMARY.md should exist");
-  } finally {
-    rmSync(base, { recursive: true, force: true });
-  }
-});
-
-test("mechanical: decision deduplication skips existing decisions", async () => {
-  const base = createTmpBase();
-  try {
-    const gsdRoot = join(base, ".gsd");
-    mkdirSync(gsdRoot, { recursive: true });
-
-    // Write existing decisions
-    const decisionsPath = join(gsdRoot, "DECISIONS.md");
-    writeFileSync(decisionsPath, "# Decisions\n\n- Used TypeScript for type safety\n", "utf-8");
-
-    const { appendNewDecisions } = await import("../mechanical-completion.js");
-
-    // Call with one existing and one new decision
-    const mockSummaries = [
-      {
-        frontmatter: {
-          id: "T01", parent: "S01", milestone: "M001",
-          provides: [], requires: [], affects: [],
-          key_files: [], key_decisions: ["Used TypeScript for type safety", "Chose Express over Koa"],
-          patterns_established: [], drill_down_paths: [], observability_surfaces: [],
-          duration: "", verification_result: "passed", completed_at: "", blocker_discovered: false,
-        },
-        title: "T01", oneLiner: "", whatHappened: "", deviations: "", filesModified: [],
-      },
-    ];
-
-    await appendNewDecisions(base, mockSummaries as any);
-
-    const updated = readFileSync(decisionsPath, "utf-8");
-    assert.ok(updated.includes("Chose Express over Koa"), "should append new decision");
-    // The existing decision should not be duplicated
-    const matches = updated.match(/Used TypeScript for type safety/g);
-    assert.equal(matches?.length, 1, "should not duplicate existing decision");
-  } finally {
-    rmSync(base, { recursive: true, force: true });
-  }
-});

package/dist/resources/extensions/gsd/tests/memory-extractor.test.ts

@@ -1,180 +0,0 @@
-import { createTestContext } from './test-helpers.ts';
-import { parseMemoryResponse, _resetExtractionState } from '../memory-extractor.ts';
-import {
-  openDatabase,
-  closeDatabase,
-} from '../gsd-db.ts';
-import {
-  getActiveMemories,
-  applyMemoryActions,
-  getActiveMemoriesRanked,
-} from '../memory-store.ts';
-import type { MemoryAction } from '../memory-store.ts';
-
-const { assertEq, assertTrue, report } = createTestContext();
-
-// ═══════════════════════════════════════════════════════════════════════════
-// memory-extractor: parse valid JSON response
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== memory-extractor: parse valid JSON ===');
-{
-  const response = JSON.stringify([
-    { action: 'CREATE', category: 'gotcha', content: 'esbuild drops binaries', confidence: 0.85 },
-    { action: 'REINFORCE', id: 'MEM001' },
-    { action: 'UPDATE', id: 'MEM002', content: 'revised content' },
-    { action: 'SUPERSEDE', id: 'MEM003', superseded_by: 'MEM004' },
-  ]);
-
-  const actions = parseMemoryResponse(response);
-  assertEq(actions.length, 4, 'should parse 4 actions');
-  assertEq(actions[0].action, 'CREATE', 'first action should be CREATE');
-  assertEq((actions[0] as any).category, 'gotcha', 'CREATE category');
-  assertEq((actions[0] as any).confidence, 0.85, 'CREATE confidence');
-  assertEq(actions[1].action, 'REINFORCE', 'second action should be REINFORCE');
-  assertEq(actions[2].action, 'UPDATE', 'third action should be UPDATE');
-  assertEq(actions[3].action, 'SUPERSEDE', 'fourth action should be SUPERSEDE');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// memory-extractor: parse fenced JSON response
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== memory-extractor: parse fenced JSON ===');
-{
-  const response = '```json\n[\n  {"action": "CREATE", "category": "convention", "content": "test memory"}\n]\n```';
-
-  const actions = parseMemoryResponse(response);
-  assertEq(actions.length, 1, 'should parse 1 action from fenced JSON');
-  assertEq(actions[0].action, 'CREATE', 'action should be CREATE');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// memory-extractor: parse empty array response
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== memory-extractor: parse empty array ===');
-{
-  const actions = parseMemoryResponse('[]');
-  assertEq(actions.length, 0, 'empty array should parse to empty actions');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// memory-extractor: parse malformed response
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== memory-extractor: malformed responses ===');
-{
-  assertEq(parseMemoryResponse('not json at all'), [], 'garbage text should return []');
-  assertEq(parseMemoryResponse('{"action": "CREATE"}'), [], 'non-array should return []');
-  assertEq(parseMemoryResponse(''), [], 'empty string should return []');
-  assertEq(parseMemoryResponse('```\nbroken\n```'), [], 'fenced non-JSON should return []');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// memory-extractor: validation of required fields
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== memory-extractor: field validation ===');
-{
-  const response = JSON.stringify([
-    // Valid CREATE
-    { action: 'CREATE', category: 'gotcha', content: 'valid' },
-    // Invalid CREATE — missing content
-    { action: 'CREATE', category: 'gotcha' },
-    // Invalid CREATE — missing category
-    { action: 'CREATE', content: 'no category' },
-    // Valid REINFORCE
-    { action: 'REINFORCE', id: 'MEM001' },
-    // Invalid REINFORCE — missing id
-    { action: 'REINFORCE' },
-    // Valid UPDATE
-    { action: 'UPDATE', id: 'MEM002', content: 'new content' },
-    // Invalid UPDATE — missing content
-    { action: 'UPDATE', id: 'MEM002' },
-    // Valid SUPERSEDE
-    { action: 'SUPERSEDE', id: 'MEM001', superseded_by: 'MEM002' },
-    // Invalid SUPERSEDE — missing superseded_by
-    { action: 'SUPERSEDE', id: 'MEM001' },
-    // Unknown action
-    { action: 'DELETE', id: 'MEM001' },
-    // Null entry
-    null,
-  ]);
-
-  const actions = parseMemoryResponse(response);
-  assertEq(actions.length, 4, 'should only accept 4 valid actions');
-  assertEq(actions[0].action, 'CREATE', 'first valid is CREATE');
-  assertEq(actions[1].action, 'REINFORCE', 'second valid is REINFORCE');
-  assertEq(actions[2].action, 'UPDATE', 'third valid is UPDATE');
-  assertEq(actions[3].action, 'SUPERSEDE', 'fourth valid is SUPERSEDE');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Integration: applyMemoryActions with mixed actions
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== integration: mixed action lifecycle ===');
-{
-  openDatabase(':memory:');
-
-  // Phase 1: Create initial memories
-  applyMemoryActions([
-    { action: 'CREATE', category: 'gotcha', content: 'npm run build needs tsc first', confidence: 0.7 },
-    { action: 'CREATE', category: 'convention', content: 'all DB queries use named params', confidence: 0.8 },
-    { action: 'CREATE', category: 'architecture', content: 'extensions loaded from two paths', confidence: 0.85 },
-  ], 'plan-slice', 'M001/S01');
-
-  let active = getActiveMemoriesRanked(30);
-  assertEq(active.length, 3, 'phase 1: 3 active memories');
-
-  // Phase 2: Reinforce one, update another, create new
-  applyMemoryActions([
-    { action: 'REINFORCE', id: 'MEM002' },
-    { action: 'UPDATE', id: 'MEM001', content: 'npm run build requires tsc --noEmit first' },
-    { action: 'CREATE', category: 'pattern', content: 'use INSERT OR IGNORE for idempotency', confidence: 0.75 },
-  ], 'execute-task', 'M001/S01/T01');
-
-  active = getActiveMemoriesRanked(30);
-  assertEq(active.length, 4, 'phase 2: 4 active memories');
-  assertEq(
-    active.find(m => m.id === 'MEM001')?.content,
-    'npm run build requires tsc --noEmit first',
-    'MEM001 content should be updated',
-  );
-  assertEq(active.find(m => m.id === 'MEM002')?.hit_count, 1, 'MEM002 should be reinforced');
-
-  // Phase 3: Supersede MEM001 with MEM005
-  applyMemoryActions([
-    { action: 'CREATE', category: 'gotcha', content: 'build script handles tsc automatically now', confidence: 0.9 },
-    { action: 'SUPERSEDE', id: 'MEM001', superseded_by: 'MEM005' },
-  ], 'execute-task', 'M001/S01/T02');
-
-  active = getActiveMemoriesRanked(30);
-  assertEq(active.length, 4, 'phase 3: 4 active (1 superseded, 1 created)');
-  assertTrue(!active.find(m => m.id === 'MEM001'), 'MEM001 should be superseded');
-  assertTrue(!!active.find(m => m.id === 'MEM005'), 'MEM005 should be active');
-
-  // Verify ranking: MEM003 (0.85) > MEM005 (0.9) but MEM002 has 1 hit
-  // MEM002: 0.8 * (1 + 1*0.1) = 0.88
-  // MEM003: 0.85 * 1.0 = 0.85
-  // MEM005: 0.9 * 1.0 = 0.9
-  // MEM004: 0.75 * 1.0 = 0.75
-  assertEq(active[0].id, 'MEM005', 'MEM005 should rank first (0.9)');
-  assertEq(active[1].id, 'MEM002', 'MEM002 should rank second (0.88)');
-
-  closeDatabase();
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// memory-extractor: _resetExtractionState
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== memory-extractor: reset extraction state ===');
-{
-  // Just verify it doesn't throw
-  _resetExtractionState();
-  assertTrue(true, '_resetExtractionState should not throw');
-}
-
-report();

package/dist/resources/extensions/gsd/tests/memory-leak-guards.test.ts

@@ -1,91 +0,0 @@
-/**
- * memory-leak-guards.test.ts — Tests for #611 memory leak fixes.
- *
- * Verifies that module-level state accumulators are properly bounded
- * and cleared to prevent OOM during long-running auto-mode sessions.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, existsSync, readdirSync, readFileSync, realpathSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { saveActivityLog, clearActivityLogState } from "../activity-log.ts";
-import { clearPathCache } from "../paths.ts";
-import type { ExtensionContext } from "@gsd/pi-coding-agent";
-
-function createCtx(entries: unknown[]) {
-  return { sessionManager: { getEntries: () => entries } } as unknown as ExtensionContext;
-}
-
-// ─── activity-log: clearActivityLogState ─────────────────────────────────────
-
-test("clearActivityLogState resets dedup state so identical saves write again", () => {
-  clearActivityLogState();
-  // Pre-resolve baseDir so gsdRoot() returns a stable key across calls.
-  // On macOS, /tmp is a symlink to /private/tmp — without realpathSync, the
-  // key changes between the first save (dir doesn't exist, realpathSync throws)
-  // and subsequent saves (dir exists, realpathSync resolves to /private/tmp/...).
-  const baseDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-memleak-test-")));
-  try {
-    const entries = [{ role: "assistant", content: "test entry" }];
-    const ctx = createCtx(entries);
-
-    // First save
-    saveActivityLog(ctx, baseDir, "execute-task", "M001/S01/T01");
-
-    const actDir = join(baseDir, ".gsd", "activity");
-    assert.equal(readdirSync(actDir).length, 1, "first save creates one file");
-
-    // Same content, same unit — deduped
-    saveActivityLog(ctx, baseDir, "execute-task", "M001/S01/T01");
-    assert.equal(readdirSync(actDir).length, 1, "dedup prevents duplicate write");
-
-    // Clear state
-    clearActivityLogState();
-
-    // Same content again — after clear, writes again (fresh state)
-    saveActivityLog(ctx, baseDir, "execute-task", "M001/S01/T01");
-    assert.equal(readdirSync(actDir).length, 2, "after clear, dedup state is reset");
-  } finally {
-    rmSync(baseDir, { recursive: true, force: true });
-  }
-});
-
-// ─── activity-log: streaming JSONL write ────────────────────────────────────
-
-test("saveActivityLog writes valid JSONL via streaming", () => {
-  clearActivityLogState();
-  const baseDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-memleak-jsonl-")));
-  try {
-    const entries = [
-      { type: "message", message: { role: "user", content: "hello" } },
-      { type: "message", message: { role: "assistant", content: "world" } },
-      { type: "message", message: { role: "user", content: "test" } },
-    ];
-    const ctx = createCtx(entries);
-
-    saveActivityLog(ctx, baseDir, "execute-task", "M002/S01/T01");
-
-    const actDir = join(baseDir, ".gsd", "activity");
-    const files = readdirSync(actDir);
-    assert.equal(files.length, 1, "one file written");
-
-    const content = readFileSync(join(actDir, files[0]), "utf-8");
-    const lines = content.trim().split("\n");
-    assert.equal(lines.length, 3, "three JSONL lines");
-
-    for (const line of lines) {
-      assert.doesNotThrow(() => JSON.parse(line), `line is valid JSON`);
-    }
-  } finally {
-    rmSync(baseDir, { recursive: true, force: true });
-  }
-});
-
-// ─── paths.ts: directory cache bounds ───────────────────────────────────────
-
-test("clearPathCache does not throw", () => {
-  assert.doesNotThrow(() => clearPathCache(), "clearPathCache should not throw");
-});