gsd-pi 2.80.0-dev.2848d9009 → 2.80.0-dev.3065f7bfa

package/src/resources/extensions/gsd/tests/prompt-duplication-cuts.test.ts

@@ -0,0 +1,230 @@
+// Project/App: GSD-2
+// File Purpose: Verifies low-risk auto-prompt duplication cuts render through prompt builders.
+
+import test from "node:test";
+import type { TestContext } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { invalidateAllCaches } from "../cache.ts";
+import {
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  openDatabase,
+  upsertMilestonePlanning,
+} from "../gsd-db.ts";
+
+type AutoPromptBuilders = typeof import("../auto-prompts.ts");
+
+function makeBase(prefix: string): string {
+  const base = mkdtempSync(join(tmpdir(), prefix));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  invalidateAllCaches();
+  rmSync(base, { recursive: true, force: true });
+}
+
+async function loadAutoPromptBuilders(t: TestContext): Promise<AutoPromptBuilders> {
+  const previousGsdHome = process.env.GSD_HOME;
+  const isolatedHome = mkdtempSync(join(tmpdir(), "gsd-prompt-loader-home-"));
+  process.env.GSD_HOME = isolatedHome;
+  t.after(() => {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    rmSync(isolatedHome, { recursive: true, force: true });
+  });
+  return import(`../auto-prompts.ts?promptDupCuts=${Date.now()}-${Math.random()}`) as Promise<AutoPromptBuilders>;
+}
+
+function seedDb(base: string, taskStatus = "complete"): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Prompt Cuts", status: "active", depends_on: [] });
+  upsertMilestonePlanning("M001", {
+    title: "Prompt Cuts",
+    status: "active",
+    vision: "Reduce duplicate prompt reads.",
+    successCriteria: ["Prompt builders render compact context."],
+    keyRisks: [],
+    proofStrategy: [],
+    verificationContract: "",
+    verificationIntegration: "",
+    verificationOperational: "",
+    verificationUat: "",
+    definitionOfDone: [],
+    requirementCoverage: "",
+    boundaryMapMarkdown: "",
+  });
+  insertSlice({
+    id: "S01",
+    milestoneId: "M001",
+    title: "Prompt Slice",
+    status: "active",
+    risk: "low",
+    depends: [],
+    demo: "",
+    sequence: 1,
+  });
+  insertTask({
+    id: "T01",
+    sliceId: "S01",
+    milestoneId: "M001",
+    title: "Task one",
+    status: taskStatus,
+  });
+}
+
+function writeRoadmapAndPlan(base: string): void {
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    [
+      "# M001 Roadmap",
+      "## Slices",
+      "- [ ] **S01: Prompt Slice** `risk:low` `depends:[]`",
+    ].join("\n"),
+  );
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md"),
+    [
+      "# S01 Plan",
+      "",
+      "**Goal:** Reduce duplicate prompt reads.",
+      "",
+      "## Tasks",
+      "- [x] **T01: Task one** `est:15m`",
+    ].join("\n"),
+  );
+}
+
+function writeTaskSummary(base: string, options?: { blocker?: boolean; repeatedNarrative?: string }): void {
+  const narrative = options?.repeatedNarrative ?? "This full implementation narrative should stay out of closer prompts.";
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"),
+    [
+      "---",
+      "id: T01",
+      "parent: S01",
+      "milestone: M001",
+      "provides:",
+      "  - prompt context reduction",
+      "key_files:",
+      "  - src/resources/extensions/gsd/auto-prompts.ts",
+      "key_decisions:",
+      "  - use compact excerpts before full reads",
+      "patterns_established:",
+      "  - excerpt-first complete-slice context",
+      "observability_surfaces: []",
+      "duration: 15m",
+      "verification_result: passed",
+      "completed_at: 2026-05-06T12:00:00Z",
+      `blocker_discovered: ${options?.blocker ? "true" : "false"}`,
+      "---",
+      "",
+      "# T01: Task one",
+      "**One-line result.**",
+      "",
+      "## What Happened",
+      narrative,
+      "",
+      "## Verification",
+      "node:test passed.",
+      "",
+      "## Diagnostics",
+      "Prompt size stayed bounded.",
+    ].join("\n"),
+  );
+}
+
+test("execute-task rendering makes memory_query and template disk reads fallback-only", async (t) => {
+  const base = makeBase("gsd-execute-dup-cuts-");
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seedDb(base, "pending");
+  writeRoadmapAndPlan(base);
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-PLAN.md"),
+    "# T01 Plan\n\nDo the prompt edit.\n",
+  );
+
+  const { buildExecuteTaskPrompt } = await loadAutoPromptBuilders(t);
+  const prompt = await buildExecuteTaskPrompt("M001", "S01", "Prompt Slice", "T01", "Task one", base);
+
+  assert.match(prompt, /Call `memory_query`.*only when no injected memory block exists or the inlined memory\/context is insufficient/s);
+  assert.doesNotMatch(prompt, /Call `memory_query` with 2-4 keywords from the task title and touched files unless this is purely mechanical/);
+  assert.match(prompt, /Use the inlined Task Summary template below/);
+  assert.match(prompt, /Read `.*task-summary\.md` only if the inlined template is absent or visibly truncated/);
+  assert.doesNotMatch(prompt, /Read the template at `.*task-summary\.md`/);
+  assert.match(prompt, /### Output Template: Task Summary/);
+});
+
+test("complete-slice renders task summary excerpts without full summary bodies", async (t) => {
+  const base = makeBase("gsd-complete-slice-excerpts-");
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seedDb(base);
+  writeRoadmapAndPlan(base);
+  const repeatedNarrative = "FULL_TASK_BODY_SHOULD_NOT_RENDER ".repeat(40);
+  writeTaskSummary(base, { repeatedNarrative });
+
+  const { buildCompleteSlicePrompt } = await loadAutoPromptBuilders(t);
+  const prompt = await buildCompleteSlicePrompt("M001", "Prompt Cuts", "S01", "Prompt Slice", base);
+
+  assert.match(prompt, /### Task Summary: T01 \(excerpt\)/);
+  assert.match(prompt, /On-demand.*read `\.gsd\/milestones\/M001\/slices\/S01\/tasks\/T01-SUMMARY\.md` only when this excerpt is absent\/truncated/s);
+  assert.doesNotMatch(prompt, /FULL_TASK_BODY_SHOULD_NOT_RENDER/);
+  assert.match(prompt, /Review the inlined task-summary excerpts/);
+});
+
+test("complete-slice caps malformed task summaries instead of inlining full bodies", async (t) => {
+  const base = makeBase("gsd-complete-slice-malformed-excerpts-");
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seedDb(base);
+  writeRoadmapAndPlan(base);
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"),
+    [
+      "# Legacy summary without frontmatter id",
+      "LEGACY_FULL_BODY_SHOULD_BE_CAPPED ".repeat(200),
+    ].join("\n"),
+  );
+
+  const { buildCompleteSlicePrompt } = await loadAutoPromptBuilders(t);
+  const prompt = await buildCompleteSlicePrompt("M001", "Prompt Cuts", "S01", "Prompt Slice", base);
+
+  assert.match(prompt, /Truncated malformed summary/);
+  assert.ok(prompt.length < 20_000);
+  assert.ok((prompt.match(/LEGACY_FULL_BODY_SHOULD_BE_CAPPED/g) ?? []).length < 60);
+});
+
+test("replan-slice renders blocker summary excerpt and tells the agent to read full only on demand", async (t) => {
+  const base = makeBase("gsd-replan-excerpts-");
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seedDb(base);
+  writeRoadmapAndPlan(base);
+  writeTaskSummary(base, {
+    blocker: true,
+    repeatedNarrative: "FULL_BLOCKER_BODY_SHOULD_NOT_RENDER ".repeat(40),
+  });
+
+  const { buildReplanSlicePrompt } = await loadAutoPromptBuilders(t);
+  const prompt = await buildReplanSlicePrompt("M001", "Prompt Cuts", "S01", "Prompt Slice", base);
+
+  assert.match(prompt, /### Blocker Task Summary: T01 \(excerpt\)/);
+  assert.match(prompt, /Use the inlined blocker summary excerpt first/);
+  assert.match(prompt, /Read the full blocker task summary only if the excerpt is absent, marked truncated, or lacks the specific blocker evidence needed to replan/);
+  assert.doesNotMatch(prompt, /FULL_BLOCKER_BODY_SHOULD_NOT_RENDER/);
+  assert.doesNotMatch(prompt, /Read the blocker task summary carefully/);
+});

package/src/resources/extensions/gsd/tests/prompt-path-audit.test.ts

@@ -0,0 +1,40 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { dirname } from "node:path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const promptsDir = join(__dirname, "..", "prompts");
+
+test("prompt templates do not reference legacy milestone-root .gsd paths", () => {
+  const offenders: string[] = [];
+  for (const file of readdirSync(promptsDir)) {
+    if (!file.endsWith(".md")) continue;
+    const content = readFileSync(join(promptsDir, file), "utf-8");
+    const legacyPatterns = [
+      /\.gsd\/\{\{(?:milestoneId|mid)\}\}\//g,
+      /\.gsd\/<milestone-id>\//g,
+      /\.gsd\/<ID>\//g,
+    ];
+    for (const pattern of legacyPatterns) {
+      if (pattern.test(content)) {
+        offenders.push(`${file}: ${pattern.source}`);
+      }
+    }
+  }
+
+  assert.deepEqual(
+    offenders,
+    [],
+    "Milestone artifacts must use .gsd/milestones/<MID>/..., not legacy .gsd/<MID>/...",
+  );
+});
+
+test("quick task prompt delegates commit policy to quick.ts", () => {
+  const content = readFileSync(join(promptsDir, "quick-task.md"), "utf-8");
+  assert.match(content, /\{\{commitInstruction\}\}/);
+  assert.doesNotMatch(content, /Stage only relevant files/);
+});

package/src/resources/extensions/gsd/tests/prompt-step-ordering.test.ts

@@ -65,6 +65,25 @@ describe('prompt step ordering (#3696)', () => {
     assert.ok(learningsIdx < completeMilestoneIdx, 'learnings extraction must happen before gsd_complete_milestone');
   });
 
+  test('complete-milestone duplicate guard checks milestone status before durable writes', () => {
+    const guardMatch = completeMilestoneMd.match(/^\d+\.\s.*gsd_milestone_status/m);
+    const reqUpdateMatch = completeMilestoneMd.match(/^\d+\.\s.*gsd_requirement_update/m);
+    assert.ok(guardMatch, 'complete-milestone must start with a gsd_milestone_status duplicate guard');
+    assert.ok(reqUpdateMatch, 'gsd_requirement_update should appear in a numbered step');
+
+    const guardIdx = completeMilestoneMd.indexOf(guardMatch![0]);
+    const reqUpdateIdx = completeMilestoneMd.indexOf(reqUpdateMatch![0]);
+    assert.ok(
+      guardIdx < reqUpdateIdx,
+      'duplicate guard must run before requirement/project/learnings writes',
+    );
+    assert.match(
+      completeMilestoneMd,
+      /status(?:`|\*\*)?\s+(?:is\s+)?(?:`complete`|"complete")/i,
+      'duplicate guard must tell the agent to stop when status is complete',
+    );
+  });
+
   test('complete-slice.md uses gsd_requirement_update', () => {
     assert.match(completeSliceMd, /gsd_requirement_update/,
       'complete-slice.md should reference gsd_requirement_update');

package/src/resources/extensions/gsd/tests/query-tools-db-open.test.ts

@@ -28,8 +28,8 @@ describe('query-tools ensureDbOpen usage (#3672)', () => {
   });
 
   test('calls ensureDbOpen() before DB queries', () => {
-    assert.match(source, /await ensureDbOpen\(\)/,
-      'query-tools should call await ensureDbOpen()');
+    assert.match(source, /await ensureDbOpen\([^)]*\)/,
+      'query-tools should call await ensureDbOpen(...)');
   });
 
   test('no longer imports isDbAvailable in the execute path', () => {
@@ -41,7 +41,7 @@ describe('query-tools ensureDbOpen usage (#3672)', () => {
   });
 
   test('uses dbAvailable result from ensureDbOpen', () => {
-    assert.match(source, /dbAvailable\s*=\s*await ensureDbOpen\(\)/,
+    assert.match(source, /dbAvailable\s*=\s*await ensureDbOpen\([^)]*\)/,
       'should store ensureDbOpen result in dbAvailable');
   });
 });

package/src/resources/extensions/gsd/tests/quick-external-gsd.test.ts

@@ -0,0 +1,40 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { buildQuickCommitInstruction } from "../quick.ts";
+
+function git(cwd: string, args: string[]): void {
+  const result = spawnSync("git", args, { cwd, encoding: "utf-8" });
+  assert.equal(result.status, 0, result.stderr || result.stdout);
+}
+
+test("quick task commit instruction does not ask agents to stage external .gsd quick files", { skip: process.platform === "win32" }, () => {
+  const tempRoot = realpathSync(mkdtempSync(join(tmpdir(), "gsd-quick-ext-")));
+  const repo = join(tempRoot, "repo");
+  const externalGsd = join(tempRoot, "state");
+  mkdirSync(repo);
+  mkdirSync(externalGsd);
+
+  const previousCwd = process.cwd();
+  try {
+    git(repo, ["init"]);
+    git(repo, ["config", "user.email", "test@example.com"]);
+    git(repo, ["config", "user.name", "Test User"]);
+    writeFileSync(join(repo, "README.md"), "# Test\n", "utf-8");
+    git(repo, ["add", "README.md"]);
+    git(repo, ["commit", "-m", "init"]);
+    symlinkSync(externalGsd, join(repo, ".gsd"), "dir");
+
+    const instruction = buildQuickCommitInstruction(repo, join(repo, ".gsd"));
+
+    assert.match(instruction, /do not stage or commit `\.gsd\/quick\/\.\.\.`/);
+    assert.match(instruction, /nothing in the project repo to commit/);
+    assert.match(instruction, /Write the quick summary file directly/);
+  } finally {
+    process.chdir(previousCwd);
+    rmSync(tempRoot, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/restore-tools-after-discuss.test.ts

@@ -24,7 +24,7 @@ describe('restore tools after discuss flow scoping (#3628)', () => {
   it('savedTools is declared before the discuss scoping block', () => {
     // savedTools must be declared before the discuss-* check
     const savedToolsDecl = src.indexOf('let savedTools')
-    const discussCheck = src.indexOf('if (unitType?.startsWith("discuss-"))')
+    const discussCheck = src.indexOf('if (unitType?.startsWith("discuss-")')
     assert.ok(savedToolsDecl !== -1, 'savedTools variable must be declared')
     assert.ok(discussCheck !== -1, 'discuss-* type check must exist')
     assert.ok(
@@ -33,40 +33,61 @@ describe('restore tools after discuss flow scoping (#3628)', () => {
     )
   })
 
-  it('savedTools captures current tools inside the discuss block', () => {
-    const discussCheck = src.indexOf('if (unitType?.startsWith("discuss-"))')
+  it('savedTools captures current tools before scoping can mutate active state', () => {
+    const discussCheck = src.indexOf('if (unitType?.startsWith("discuss-")')
     assert.ok(discussCheck !== -1)
 
-    // Look for savedTools assignment within the discuss block
-    const blockAfter = extractSourceRegion(src, 'if (unitType?.startsWith("discuss-"))')
+    const currentToolsDecl = src.indexOf('const currentTools = pi.getActiveTools()')
+    const savedToolsAssign = src.indexOf('savedTools = {', currentToolsDecl)
+    const firstMutation = src.indexOf('pi.setActiveTools(scopedTools)')
     assert.ok(
-      blockAfter.includes('savedTools = currentTools'),
-      'savedTools must be assigned from currentTools inside the discuss block',
+      currentToolsDecl !== -1 && savedToolsAssign !== -1 && firstMutation !== -1,
+      'guided-flow.ts must capture current tools, save them, and then scope active tools',
+    )
+    assert.ok(
+      currentToolsDecl < savedToolsAssign && savedToolsAssign < firstMutation,
+      'savedTools must capture currentTools before any discuss scoping mutation',
+    )
+    assert.ok(
+      src.slice(savedToolsAssign, firstMutation).includes('tools: currentTools'),
+      'savedTools must include currentTools before the first scoping mutation',
     )
   })
 
+  it('scoping and workflow read happen inside the restore try block', () => {
+    const savedToolsDecl = src.indexOf('let savedTools')
+    const tryIdx = src.indexOf('try {', savedToolsDecl)
+    const firstMutation = src.indexOf('pi.setActiveTools(scopedTools)')
+    const workflowRead = src.indexOf('readFileSync(workflowPath')
+    const finallyIdx = src.indexOf('} finally {', tryIdx)
+
+    assert.ok(savedToolsDecl !== -1, 'savedTools variable must be declared')
+    assert.ok(tryIdx !== -1, 'restore try block must exist')
+    assert.ok(firstMutation !== -1, 'discuss scoping mutation must exist')
+    assert.ok(workflowRead !== -1, 'workflow file read must exist')
+    assert.ok(finallyIdx !== -1, 'restore finally block must exist')
+    assert.ok(tryIdx < firstMutation && firstMutation < finallyIdx, 'scoping mutation must be inside try/finally')
+    assert.ok(tryIdx < workflowRead && workflowRead < finallyIdx, 'workflow file read must be inside try/finally')
+  })
+
   it('savedTools is restored after sendMessage', () => {
     // #4573: guided-flow.ts now contains multiple `triggerTurn: true` calls
     // (ready-phrase and empty-turn recovery paths). The discuss-flow scoping
-    // sendMessage is the one that follows `savedTools = currentTools`, so
+    // sendMessage is the one that follows `tools: currentTools`, so
     // anchor the search there rather than at the first `triggerTurn: true`.
-    const savedToolsAssign = src.indexOf('savedTools = currentTools')
-    assert.ok(savedToolsAssign !== -1, 'savedTools = currentTools must exist')
+    const savedToolsAssign = src.indexOf('tools: currentTools')
+    assert.ok(savedToolsAssign !== -1, 'savedTools must capture currentTools')
 
     const sendMsg = src.indexOf('triggerTurn: true', savedToolsAssign)
     assert.ok(sendMsg !== -1, 'discuss-flow sendMessage with triggerTurn must exist after savedTools capture')
 
-    // After sendMessage, savedTools should be restored via setActiveTools.
+    // After sendMessage, savedTools should be restored via the shared helper.
     // Use fromIdx to anchor at the discuss-flow sendMessage, not the first
     // triggerTurn: true occurrence in the file.
     const afterSend = extractSourceRegion(src, 'triggerTurn: true', { fromIdx: savedToolsAssign })
     assert.ok(
-      afterSend.includes('if (savedTools)'),
-      'savedTools restoration guard must exist after sendMessage',
-    )
-    assert.ok(
-      afterSend.includes('setActiveTools(savedTools)'),
-      'setActiveTools(savedTools) must be called to restore the full tool set',
+      afterSend.includes('restoreGsdWorkflowTools(pi, savedTools)'),
+      'restoreGsdWorkflowTools(pi, savedTools) must restore the full scoped state',
     )
   })
 })

package/src/resources/extensions/gsd/tests/schema-v27-v28-sequence.test.ts

@@ -0,0 +1,156 @@
+// gsd-2 / V27 + V28 schema migration regression tests
+//
+// Same bug class as #4591 (schema-v21-sequence): a migration block can be
+// added but the SCHEMA_VERSION constant left unchanged, causing fresh-install
+// + upgrade paths to silently skip the column add. This file pins both V27
+// (artifacts.content_hash) and V28 (memories.last_hit_at) at the schema and
+// write-path level on fresh-install DBs.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+
+import {
+  openDatabase,
+  closeDatabase,
+  _getAdapter,
+  insertArtifact,
+  insertMemoryRow,
+  incrementMemoryHitCount,
+  SCHEMA_VERSION,
+} from "../gsd-db.ts";
+
+function makeTmp(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "gsd-v27v28-"));
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { fs.rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+test("SCHEMA_VERSION constant is at least 28 (V28 migration committed)", () => {
+  assert.ok(
+    SCHEMA_VERSION >= 28,
+    `SCHEMA_VERSION must be ≥ 28 after V28 migration; got ${SCHEMA_VERSION}`,
+  );
+});
+
+test("fresh-install DB has artifacts.content_hash column (V27)", () => {
+  const base = makeTmp();
+  const dbPath = path.join(base, "gsd.db");
+  try {
+    openDatabase(dbPath);
+    const db = _getAdapter()!;
+    const cols = db.prepare("PRAGMA table_info(artifacts)").all() as Array<Record<string, unknown>>;
+    const colNames = new Set(cols.map((c) => c["name"] as string));
+    assert.ok(
+      colNames.has("content_hash"),
+      "V27 must add content_hash column to artifacts on fresh install",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("fresh-install DB has memories.last_hit_at column (V28)", () => {
+  const base = makeTmp();
+  const dbPath = path.join(base, "gsd.db");
+  try {
+    openDatabase(dbPath);
+    const db = _getAdapter()!;
+    const cols = db.prepare("PRAGMA table_info(memories)").all() as Array<Record<string, unknown>>;
+    const colNames = new Set(cols.map((c) => c["name"] as string));
+    assert.ok(
+      colNames.has("last_hit_at"),
+      "V28 must add last_hit_at column to memories on fresh install",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("fresh-install DB stamps SCHEMA_VERSION (≥28) in schema_version table", () => {
+  const base = makeTmp();
+  const dbPath = path.join(base, "gsd.db");
+  try {
+    openDatabase(dbPath);
+    const db = _getAdapter()!;
+    const row = db.prepare("SELECT MAX(version) as v FROM schema_version").get() as Record<string, unknown> | undefined;
+    const max = (row?.["v"] as number) ?? 0;
+    assert.ok(max >= 28, `fresh install must record schema_version ≥ 28; got ${max}`);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("insertArtifact populates content_hash with SHA-256 of full_content (V27 write-path)", () => {
+  const base = makeTmp();
+  const dbPath = path.join(base, "gsd.db");
+  try {
+    openDatabase(dbPath);
+    insertArtifact({
+      path: "M001/PROJECT.md",
+      artifact_type: "PROJECT",
+      milestone_id: "M001",
+      slice_id: null,
+      task_id: null,
+      full_content: "hello world",
+    });
+
+    const db = _getAdapter()!;
+    const row = db
+      .prepare("SELECT content_hash FROM artifacts WHERE path = :p")
+      .get({ ":p": "M001/PROJECT.md" }) as Record<string, unknown> | undefined;
+    const hash = row?.["content_hash"] as string | null | undefined;
+
+    // SHA-256 of "hello world" hex-encoded:
+    const expected = "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9";
+    assert.equal(hash, expected, "content_hash must be SHA-256 hex of full_content");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("incrementMemoryHitCount sets last_hit_at alongside hit_count (V28 write-path)", () => {
+  const base = makeTmp();
+  const dbPath = path.join(base, "gsd.db");
+  try {
+    openDatabase(dbPath);
+
+    const created = "2026-01-01T00:00:00.000Z";
+    insertMemoryRow({
+      id: "MEM001",
+      category: "gotcha",
+      content: "test memory",
+      confidence: 0.9,
+      sourceUnitType: null,
+      sourceUnitId: null,
+      createdAt: created,
+      updatedAt: created,
+      scope: "project",
+      tags: [],
+      structuredFields: null,
+    });
+
+    // Before increment: last_hit_at should be NULL
+    const db = _getAdapter()!;
+    const before = db
+      .prepare("SELECT last_hit_at FROM memories WHERE id = :id")
+      .get({ ":id": "MEM001" }) as Record<string, unknown>;
+    assert.equal(before["last_hit_at"], null, "last_hit_at starts NULL on fresh insert");
+
+    const hitTime = "2026-02-01T00:00:00.000Z";
+    incrementMemoryHitCount("MEM001", hitTime);
+
+    const after = db
+      .prepare("SELECT hit_count, last_hit_at FROM memories WHERE id = :id")
+      .get({ ":id": "MEM001" }) as Record<string, unknown>;
+    assert.equal(after["hit_count"], 1, "hit_count increments");
+    assert.equal(after["last_hit_at"], hitTime, "last_hit_at set to provided timestamp");
+  } finally {
+    cleanup(base);
+  }
+});