gsd-pi 2.80.0-dev.42bd34838 → 2.80.0-dev.488219eb6

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-step-ordering.test.ts

@@ -1,146 +1,91 @@
 /**
- * Regression test for #3696 — prompt step ordering and runtime fixes
+ * Regression tests for #3696 — prompt step ordering and compact hook behavior.
  *
- * 1. complete-milestone.md: gsd_requirement_update (step 9) before
- *    gsd_complete_milestone, and completion remains the final durable write
- * 2. complete-slice.md: uses gsd_requirement_update
- * 3. register-extension.ts: _gsdEpipeGuard logs instead of re-throwing
- * 4. register-hooks.ts: session_before_compact only checks isAutoActive
+ * These tests assert rendered prompts and registered hook behavior instead of
+ * reading source files as text.
  */
 
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-import { extractSourceRegion } from "./test-helpers.ts";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+import { _setAutoActiveForTest } from '../auto.ts';
+import { buildCompleteMilestonePrompt, buildCompleteSlicePrompt } from '../auto-prompts.ts';
+import { registerHooks } from '../bootstrap/register-hooks.ts';
 
-const completeMilestoneMd = readFileSync(
-  join(__dirname, '..', 'prompts', 'complete-milestone.md'),
-  'utf-8',
-);
-const completeSliceMd = readFileSync(
-  join(__dirname, '..', 'prompts', 'complete-slice.md'),
-  'utf-8',
-);
-const registerExtSrc = readFileSync(
-  join(__dirname, '..', 'bootstrap', 'register-extension.ts'),
-  'utf-8',
-);
-const registerHooksSrc = readFileSync(
-  join(__dirname, '..', 'bootstrap', 'register-hooks.ts'),
-  'utf-8',
-);
+function makePromptBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-prompt-order-'));
+  const msDir = join(base, '.gsd', 'milestones', 'M001');
+  const sliceDir = join(msDir, 'slices', 'S01');
+  mkdirSync(sliceDir, { recursive: true });
+  writeFileSync(
+    join(msDir, 'M001-ROADMAP.md'),
+    '# Roadmap\n\n## Slices\n\n- [x] **S01: Done** `risk:low` `depends:[]`\n',
+  );
+  writeFileSync(join(sliceDir, 'S01-PLAN.md'), '# S01 Plan\n\n## Tasks\n\n- T01\n');
+  writeFileSync(join(sliceDir, 'S01-SUMMARY.md'), '# S01 Summary\n\nDone.\n');
+  return base;
+}
 
-describe('prompt step ordering (#3696)', () => {
-  test('gsd_requirement_update step appears before gsd_complete_milestone step', () => {
-    // Search for the numbered step definitions, not early "Do NOT call" warnings
-    const reqUpdateMatch = completeMilestoneMd.match(/^\d+\.\s.*gsd_requirement_update/m);
-    const completeMilestoneMatch = completeMilestoneMd.match(/^\d+\.\s.*gsd_complete_milestone/m);
-    assert.ok(reqUpdateMatch, 'gsd_requirement_update should appear in a numbered step');
-    assert.ok(completeMilestoneMatch, 'gsd_complete_milestone should appear in a numbered step');
-    const reqUpdateIdx = completeMilestoneMd.indexOf(reqUpdateMatch![0]);
-    const completeMilestoneIdx = completeMilestoneMd.indexOf(completeMilestoneMatch![0]);
-    assert.ok(
-      reqUpdateIdx < completeMilestoneIdx,
-      'gsd_requirement_update step must come before gsd_complete_milestone step',
-    );
-  });
-
-  test('project and learnings writes appear before gsd_complete_milestone', () => {
-    const projectMatch = completeMilestoneMd.match(/^\d+\.\s.*PROJECT\.md/m);
-    const learningsMatch = completeMilestoneMd.match(/^\d+\.\s.*Extract structured learnings/m);
-    const completeMilestoneMatch = completeMilestoneMd.match(/^\d+\.\s.*gsd_complete_milestone/m);
-    assert.ok(projectMatch, 'PROJECT.md update should appear in a numbered step');
-    assert.ok(learningsMatch, 'learnings extraction should appear in a numbered step');
-    assert.ok(completeMilestoneMatch, 'gsd_complete_milestone should appear in a numbered step');
-
-    const projectIdx = completeMilestoneMd.indexOf(projectMatch![0]);
-    const learningsIdx = completeMilestoneMd.indexOf(learningsMatch![0]);
-    const completeMilestoneIdx = completeMilestoneMd.indexOf(completeMilestoneMatch![0]);
-    assert.ok(projectIdx < completeMilestoneIdx, 'PROJECT.md update must happen before gsd_complete_milestone');
-    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');
+function numberedStepIndex(prompt: string, needle: RegExp): number {
+  const lines = prompt.split('\n');
+  const idx = lines.findIndex((line) => /^\d+\.\s/.test(line) && needle.test(line));
+  assert.notEqual(idx, -1, `missing numbered step matching ${needle}`);
+  return idx;
+}
 
-    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',
-    );
-  });
+describe('prompt step ordering (#3696)', () => {
+  test('complete-milestone prompt orders durable writes before gsd_complete_milestone', async () => {
+    const base = makePromptBase();
+    try {
+      const prompt = await buildCompleteMilestonePrompt('M001', 'Milestone', base, 'minimal');
+      const guardIdx = numberedStepIndex(prompt, /gsd_milestone_status/);
+      const requirementIdx = numberedStepIndex(prompt, /gsd_requirement_update/);
+      const projectIdx = numberedStepIndex(prompt, /PROJECT\.md/);
+      const learningsIdx = numberedStepIndex(prompt, /Extract structured learnings/);
+      const completeIdx = numberedStepIndex(prompt, /gsd_complete_milestone/);
 
-  test('complete-slice.md uses gsd_requirement_update', () => {
-    assert.match(completeSliceMd, /gsd_requirement_update/,
-      'complete-slice.md should reference gsd_requirement_update');
+      assert.ok(guardIdx < requirementIdx);
+      assert.ok(requirementIdx < completeIdx);
+      assert.ok(projectIdx < completeIdx);
+      assert.ok(learningsIdx < completeIdx);
+      assert.match(prompt, /status(?:`|\*\*)?\s+(?:is\s+)?(?:`complete`|"complete")/i);
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
   });
-});
 
-describe('register-extension _gsdEpipeGuard (#3696)', () => {
-  test('_gsdEpipeGuard exists and does not re-throw', () => {
-    assert.match(registerExtSrc, /_gsdEpipeGuard/,
-      '_gsdEpipeGuard should be defined in register-extension.ts');
-    // After the fix, the handler logs instead of throwing
-    assert.ok(
-      !registerExtSrc.includes('throw err'),
-      '_gsdEpipeGuard should NOT contain "throw err"',
-    );
+  test('complete-slice prompt exposes gsd_requirement_update', async () => {
+    const base = makePromptBase();
+    try {
+      const prompt = await buildCompleteSlicePrompt('M001', 'Milestone', 'S01', 'Done', base, 'minimal');
+      assert.match(prompt, /gsd_requirement_update/);
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
   });
 });
 
 describe('register-hooks session_before_compact (#3696)', () => {
-  test('session_before_compact only checks isAutoActive', () => {
-    // Anchor on the full registration token rather than the bare event name —
-    // prevents matching unrelated substring occurrences.
-    const compactIdx = registerHooksSrc.indexOf('pi.on("session_before_compact"');
-    assert.ok(compactIdx > -1, 'session_before_compact hook should exist');
-    // The first check in the handler should be isAutoActive(), not isAutoPaused().
-    // Bound the region to this single handler — register-hooks.ts contains
-    // multiple pi.on("session_before_compact") handlers and a later handler
-    // legitimately references isAutoPaused.
-    const afterCompact = extractSourceRegion(
-      registerHooksSrc,
-      'pi.on("session_before_compact"',
-      'pi.on("',
-      // NB: endAnchor search starts AFTER the startAnchor, so the next
-      // pi.on("... matches the subsequent handler rather than this one.
-    );
-    assert.match(afterCompact, /isAutoActive\(\)/,
-      'session_before_compact should check isAutoActive()');
-    // Should NOT block compaction when paused
-    assert.ok(
-      !afterCompact.includes('isAutoPaused()'),
-      'session_before_compact should not check isAutoPaused',
-    );
-  });
-
-  test('session_before_compact does not gate checkpointing to executing phase (#4258)', () => {
-    const compactIdx = registerHooksSrc.indexOf('session_before_compact');
-    assert.ok(compactIdx > -1, 'session_before_compact hook should exist');
+  test('registered hook cancels compaction only while auto-mode is active', async () => {
+    const handlers = new Map<string, Function>();
+    registerHooks({
+      on(event: string, handler: Function) {
+        handlers.set(event, handler);
+      },
+    } as any, []);
 
-    const preCheckpointSection = registerHooksSrc.slice(
-      compactIdx,
-      registerHooksSrc.indexOf('const sliceDir', compactIdx),
-    );
+    const compact = handlers.get('session_before_compact');
+    assert.ok(compact, 'session_before_compact hook should be registered');
 
-    const normalized = preCheckpointSection.replace(/\/\/.*$/gm, '');
-    assert.ok(
-      !/if\s*\(\s*state\.phase\s*!==\s*['"]executing['"]\s*\)\s*\{?\s*return\b/.test(normalized),
-      'session_before_compact should not early-return on non-executing phases',
-    );
+    _setAutoActiveForTest(true);
+    try {
+      const result = await compact({}, { cwd: mkdtempSync(join(tmpdir(), 'gsd-compact-active-')), ui: { notify() {}, setWidget() {} } });
+      assert.deepEqual(result, { cancel: true });
+    } finally {
+      _setAutoActiveForTest(false);
+    }
   });
 });