gsd-pi 2.65.0 → 2.66.0-dev.e159299

package/src/resources/extensions/gsd/templates/context-enhanced.md

@@ -0,0 +1,138 @@
+# {{milestoneId}}: {{milestoneTitle}}
+
+**Gathered:** {{date}}
+**Status:** Ready for planning
+
+## Project Description
+
+{{description}}
+
+## Why This Milestone
+
+{{whatProblemThisSolves_AND_whyNow}}
+
+## Codebase Brief
+
+### Technology Stack
+
+{{techStack}}
+
+### Key Modules
+
+{{keyModules}}
+
+### Patterns in Use
+
+{{patternsInUse}}
+
+## User-Visible Outcome
+
+### When this milestone is complete, the user can:
+
+- {{literalUserActionInRealEnvironment}}
+- {{literalUserActionInRealEnvironment}}
+
+### Entry point / environment
+
+- Entry point: {{CLI command / URL / bot / extension / service / workflow}}
+- Environment: {{local dev / browser / mobile / launchd / CI / production-like}}
+- Live dependencies involved: {{telegram / database / webhook / rpc subprocess / none}}
+
+## Completion Class
+
+- Contract complete means: {{what can be proven by tests / fixtures / artifacts}}
+- Integration complete means: {{what must work across real subsystems}}
+- Operational complete means: {{what must work under real lifecycle conditions, or none}}
+
+## Architectural Decisions
+
+### {{decisionTitle}}
+
+**Decision:** {{decisionStatement}}
+
+**Rationale:** {{rationale}}
+
+**Evidence:** {{evidence}}
+
+**Alternatives Considered:**
+- {{alternative1}} — {{whyNotChosen1}}
+- {{alternative2}} — {{whyNotChosen2}}
+
+---
+
+> Add additional decisions as separate `### Decision Title` blocks following the same structure above.
+
+## Interface Contracts
+
+{{interfaceContracts}}
+
+> Document API boundaries, function signatures, data shapes, or protocol agreements that must be honored. Leave blank or remove if not applicable to this milestone.
+
+## Error Handling Strategy
+
+{{errorHandlingStrategy}}
+
+> Describe the approach for handling failures, edge cases, and error propagation. Include retry policies, fallback behaviors, and user-facing error messages where relevant.
+
+## Final Integrated Acceptance
+
+To call this milestone complete, we must prove:
+
+- {{one real end-to-end scenario}}
+- {{one real end-to-end scenario}}
+- {{what cannot be simulated if this milestone is to be considered truly done}}
+
+## Testing Requirements
+
+{{testingRequirements}}
+
+> Specify test types (unit, integration, e2e), coverage expectations, and any specific test scenarios that must pass.
+
+## Acceptance Criteria
+
+{{acceptanceCriteria}}
+
+> Per-slice acceptance criteria gathered during discussion. Each slice should have clear, testable criteria.
+
+## Risks and Unknowns
+
+- {{riskOrUnknown}} — {{whyItMatters}}
+
+## Existing Codebase / Prior Art
+
+- `{{fileOrModule}}` — {{howItRelates}}
+- `{{fileOrModule}}` — {{howItRelates}}
+
+> See `.gsd/DECISIONS.md` for all architectural and pattern decisions — it is an append-only register; read it during planning, append to it during execution.
+
+## Relevant Requirements
+
+- {{requirementId}} — {{howThisMilestoneAdvancesIt}}
+
+## Scope
+
+### In Scope
+
+- {{inScopeItem}}
+
+### Out of Scope / Non-Goals
+
+- {{outOfScopeItem}}
+
+## Technical Constraints
+
+- {{constraint}}
+
+## Integration Points
+
+- {{systemOrService}} — {{howThisMilestoneInteractsWithIt}}
+
+## Ecosystem Notes
+
+{{ecosystemNotes}}
+
+> Research findings, best practices, known issues, and relevant external documentation discovered during preparation.
+
+## Open Questions
+
+- {{question}} — {{currentThinking}}

package/src/resources/extensions/gsd/tests/adversarial-review-fixes.test.ts

@@ -0,0 +1,223 @@
+/**
+ * Tests for adversarial review fixes from PR #3602.
+ *
+ * These tests verify the fixes for:
+ * 1. Cross-session state leak in lastPreparationResult (HIGH)
+ * 2. Invalid regex anchor \z in prompt-validation.ts (HIGH)
+ * 3. Consecutive error counter in agent-loop.ts (MEDIUM) — UPSTREAM CODE, NOT MODIFIED
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { getLastPreparationResult, clearPreparationResult } from "../guided-flow.ts";
+import { validateEnhancedContext } from "../prompt-validation.ts";
+
+// ─── Test Helpers ───────────────────────────────────────────────────────────────
+
+function makeTempDir(prefix: string): string {
+  const dir = join(
+    tmpdir(),
+    `gsd-adversarial-test-${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function cleanup(dir: string): void {
+  try {
+    rmSync(dir, { recursive: true, force: true });
+  } catch {
+    // best-effort
+  }
+}
+
+// ─── Fix 1: Cross-session state leak in lastPreparationResult ────────────────────
+
+describe("Fix #1 — Cross-session state leak (lastPreparationResult)", () => {
+  beforeEach(() => {
+    clearPreparationResult();
+  });
+
+  afterEach(() => {
+    clearPreparationResult();
+  });
+
+  test("clearPreparationResult sets lastPreparationResult to null", () => {
+    // First, verify the getter returns null after clear
+    clearPreparationResult();
+    const result = getLastPreparationResult();
+    assert.equal(result, null, "lastPreparationResult should be null after clear");
+  });
+
+  test("getLastPreparationResult returns null initially", () => {
+    clearPreparationResult();
+    const result = getLastPreparationResult();
+    assert.equal(result, null, "should return null when no preparation has run");
+  });
+
+  // Note: The actual test that prepareAndBuildDiscussPrompt clears the result
+  // on entry requires mocking ExtensionCommandContext which is complex.
+  // The fix is verified by code inspection and integration tests.
+  // The key behavior is:
+  // 1. lastPreparationResult = null at the start of prepareAndBuildDiscussPrompt
+  // 2. If preparation throws, lastPreparationResult stays null
+  // 3. If discuss_preparation is false, lastPreparationResult stays null
+});
+
+// ─── Fix 2: Invalid regex anchor \z in prompt-validation.ts ──────────────────────
+
+describe("Fix #2 — Invalid regex anchor (prompt-validation.ts)", () => {
+  test("validates content with Architectural Decisions at end of file", () => {
+    // This was the bug: \z is PCRE/Ruby, not JS. JS treated it as literal 'z'.
+    // The section extraction would fail when Architectural Decisions was the
+    // last section (no subsequent ## heading).
+    const contentWithDecisionsAtEnd = `
+# M001: Test Milestone
+
+## Why This Milestone
+
+This is why.
+
+## Acceptance Criteria
+
+- Criterion 1
+
+## Architectural Decisions
+
+### Decision 1
+
+**Decision:** Use TypeScript
+**Rationale:** Type safety
+`;
+
+    const result = validateEnhancedContext(contentWithDecisionsAtEnd);
+    assert.equal(result.valid, true, "should validate content with decisions at end");
+    assert.equal(result.missing.length, 0, "should have no missing sections");
+  });
+
+  test("validates content with Architectural Decisions followed by another section", () => {
+    const contentWithDecisionsInMiddle = `
+# M001: Test Milestone
+
+## Why This Milestone
+
+This is why.
+
+## Architectural Decisions
+
+### Decision 1
+
+**Decision:** Use TypeScript
+
+## Acceptance Criteria
+
+- Criterion 1
+`;
+
+    const result = validateEnhancedContext(contentWithDecisionsInMiddle);
+    assert.equal(result.valid, true, "should validate content with decisions in middle");
+  });
+
+  test("detects missing decision entry when section is empty", () => {
+    const contentEmptyDecisions = `
+# M001: Test Milestone
+
+## Why This Milestone
+
+This is why.
+
+## Architectural Decisions
+
+(No decisions yet)
+
+## Acceptance Criteria
+
+- Criterion 1
+`;
+
+    const result = validateEnhancedContext(contentEmptyDecisions);
+    assert.equal(result.valid, false, "should fail when decisions section has no entries");
+    assert.ok(
+      result.missing.some((m) => m.includes("decision entry")),
+      "should report missing decision entry",
+    );
+  });
+
+  test("accepts inline **Decision format", () => {
+    const contentInlineDecision = `
+## Why This Milestone
+
+Test
+
+## Architectural Decisions
+
+**Decision:** Use React
+
+## Acceptance Criteria
+
+- Criterion 1
+`;
+
+    const result = validateEnhancedContext(contentInlineDecision);
+    assert.equal(result.valid, true, "should accept **Decision format");
+  });
+
+  test("accepts ### subsection format", () => {
+    const contentSubsectionDecision = `
+## Why This Milestone
+
+Test
+
+## Architectural Decisions
+
+### Database Choice
+
+We chose SQLite.
+
+## Acceptance Criteria
+
+- Criterion 1
+`;
+
+    const result = validateEnhancedContext(contentSubsectionDecision);
+    assert.equal(result.valid, true, "should accept ### subsection format");
+  });
+
+  test("handles edge case: Architectural Decisions heading without space before content", () => {
+    const contentNoSpace = `## Why This Milestone
+Test
+## Architectural Decisions
+### Decision 1
+Content here
+## Acceptance Criteria
+- Done`;
+
+    const result = validateEnhancedContext(contentNoSpace);
+    assert.equal(result.valid, true, "should handle content without extra spacing");
+  });
+});
+
+// ─── Fix 3: Consecutive error counter (agent-loop.ts) ────────────────────────────
+
+describe("Fix #3 — Consecutive error counter (UPSTREAM)", () => {
+  test("NOTE: agent-loop.ts is upstream code that was not modified", () => {
+    // This finding from the adversarial review relates to upstream behavior
+    // in packages/pi-agent-core/src/agent-loop.ts.
+    //
+    // The consecutiveAllToolErrorTurns counter logic was added in PR #3301
+    // and refined in PR #3618 by upstream contributors. These PRs fix
+    // issues with:
+    // - Schema overload detection counting bash exit codes as failures
+    // - The counter not resetting properly on successful turns
+    //
+    // Since this is upstream code (part of pi-agent-core, not gsd extension),
+    // we do not modify it here. The fix should be coordinated with upstream.
+    //
+    // See: packages/pi-agent-core/src/agent-loop.ts lines 191, 298-325
+    assert.ok(true, "Documented as upstream behavior — no changes made");
+  });
+});

package/src/resources/extensions/gsd/tests/auto-model-selection.test.ts

@@ -1,8 +1,11 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
 
 import { resolvePreferredModelConfig, resolveModelId } from "../auto-model-selection.js";
 
@@ -196,6 +199,34 @@ test("resolveModelId: bare ID with claude-code as only provider still resolves",
   assert.equal(result.provider, "claude-code");
 });
 
+// ─── selectAndApplyModel verbose-gating tests ──────────────────────────
+
+test("model change notify in selectAndApplyModel is gated behind verbose flag", () => {
+  // The Model [phase] [tier] notification should only fire when verbose=true.
+  // The dashboard header already shows the active model, so the notification
+  // is redundant noise during auto-mode (#3719).
+  const gsdDir = join(__dirname, "..");
+  const src = readFileSync(join(gsdDir, "auto-model-selection.ts"), "utf-8");
+
+  // Find the block where setModel succeeds (appliedModel = model) and
+  // verify notify is inside an `if (verbose)` guard.
+  const setModelBlock = src.match(
+    /const ok = await pi\.setModel\(model[\s\S]*?appliedModel = model;([\s\S]*?)break;/,
+  );
+  assert.ok(setModelBlock, "should find the setModel success block");
+
+  const blockBody = setModelBlock![1];
+  // The notify call must be inside an if (verbose) block
+  assert.ok(
+    blockBody.includes("if (verbose)"),
+    "Model change ctx.ui.notify must be gated behind if (verbose) to avoid auto-mode notification noise",
+  );
+  assert.ok(
+    blockBody.includes("ctx.ui.notify"),
+    "notify call should still exist (just verbose-gated)",
+  );
+});
+
 test("resolveModelId: anthropic wins over claude-code regardless of list order", () => {
   const availableModels = [
     { id: "claude-sonnet-4-6", provider: "claude-code" },

package/src/resources/extensions/gsd/tests/auto-remediate-slice-status.test.ts

@@ -0,0 +1,56 @@
+/**
+ * Regression test for #3673 — auto-remediate stale slice DB status
+ *
+ * When complete-slice fails after writing SUMMARY.md but before calling
+ * updateSliceStatus(), the DB stays stale and the post-unit check
+ * previously reported this as a "rogue" artifact, causing infinite
+ * re-dispatch. The fix calls updateSliceStatus() to sync the DB.
+ *
+ * This structural test verifies updateSliceStatus is imported and called
+ * in the complete-slice branch of auto-post-unit.ts.
+ */
+
+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';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const source = readFileSync(join(__dirname, '..', 'auto-post-unit.ts'), 'utf-8');
+
+describe('auto-remediate stale slice status (#3673)', () => {
+  test('updateSliceStatus is imported from gsd-db', () => {
+    assert.match(source, /import\s*\{[^}]*updateSliceStatus[^}]*\}\s*from\s*["']\.\/gsd-db/,
+      'updateSliceStatus should be imported from gsd-db');
+  });
+
+  test('updateSliceStatus is called with "complete" status', () => {
+    assert.match(source, /updateSliceStatus\(mid,\s*sid,\s*["']complete["']/,
+      'updateSliceStatus should be called with "complete" status');
+  });
+
+  test('remediation is wrapped in try-catch for fallback to rogue detection', () => {
+    // The updateSliceStatus call should be in a try block with a catch
+    // that falls back to rogues.push
+    const updateIdx = source.indexOf('updateSliceStatus(mid, sid');
+    assert.ok(updateIdx > 0, 'updateSliceStatus call should exist');
+
+    // Find surrounding try-catch
+    const before = source.slice(Math.max(0, updateIdx - 200), updateIdx);
+    assert.match(before, /try\s*\{/,
+      'updateSliceStatus should be inside a try block');
+
+    const after = source.slice(updateIdx, updateIdx + 300);
+    assert.match(after, /catch/,
+      'try block should have a catch for fallback');
+  });
+
+  test('rogue detection still exists as fallback', () => {
+    // rogues.push should appear in the catch block
+    assert.match(source, /rogues\.push\(\{.*path:\s*summaryPath/,
+      'rogues.push fallback should still exist');
+  });
+});

package/src/resources/extensions/gsd/tests/clear-stale-autostart.test.ts

@@ -0,0 +1,41 @@
+/**
+ * clear-stale-autostart.test.ts — #3667
+ *
+ * Verify that guided-flow.ts adds a createdAt timestamp to pending auto-start
+ * entries and implements a staleness check (30s age guard) so that /clear
+ * interrupted discussions don't permanently block future /gsd invocations.
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const sourceFile = join(__dirname, "..", "guided-flow.ts");
+
+describe("clear stale pending auto-start (#3667)", () => {
+  const source = readFileSync(sourceFile, "utf-8");
+
+  test("PendingAutoStartEntry interface includes createdAt field", () => {
+    assert.match(source, /createdAt:\s*number/);
+  });
+
+  test("setPendingAutoStart defaults createdAt to Date.now()", () => {
+    assert.match(source, /createdAt:\s*Date\.now\(\)/);
+  });
+
+  test("staleness check uses 30_000ms threshold", () => {
+    assert.match(source, /30[_]?000/);
+  });
+
+  test("stale entry detection checks manifest and context files", () => {
+    assert.match(source, /DISCUSSION-MANIFEST\.json/);
+    assert.match(source, /CONTEXT\.md/);
+  });
+
+  test("stale entries are deleted from the map", () => {
+    assert.match(source, /pendingAutoStartMap\.delete\(basePath\)/);
+  });
+});

package/src/resources/extensions/gsd/tests/complete-slice-verification-gate.test.ts

@@ -0,0 +1,72 @@
+/**
+ * Regression test for #3580 — complete-slice verification gate
+ *
+ * Without the gate, a prompt regression could silently advance a blocked
+ * or failed slice to "complete" status. The fix adds a BLOCKED_SIGNALS
+ * regex that rejects completion when verification/UAT content clearly
+ * indicates blocked or failed state.
+ */
+
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+const src = readFileSync(
+  resolve(process.cwd(), 'src', 'resources', 'extensions', 'gsd', 'tools', 'complete-slice.ts'),
+  'utf-8',
+)
+
+describe('complete-slice verification gate (#3580)', () => {
+  it('BLOCKED_SIGNALS regex is defined', () => {
+    assert.ok(
+      src.includes('BLOCKED_SIGNALS'),
+      'BLOCKED_SIGNALS constant must be defined in complete-slice.ts',
+    )
+  })
+
+  it('BLOCKED_SIGNALS is a regex that tests verification content', () => {
+    // Extract the BLOCKED_SIGNALS definition line
+    const idx = src.indexOf('BLOCKED_SIGNALS')
+    assert.ok(idx !== -1)
+    const lineEnd = src.indexOf(';', idx)
+    const definition = src.slice(idx, lineEnd)
+
+    // Must be a regex (starts with /)
+    assert.ok(
+      definition.includes('= /'),
+      'BLOCKED_SIGNALS must be assigned a regex literal',
+    )
+
+    // Must match key blocked/failed signals
+    assert.ok(definition.includes('blocked'), 'regex must match "blocked" signals')
+    assert.ok(definition.includes('failed'), 'regex must match "failed" signals')
+  })
+
+  it('gate checks params.verification and params.uatContent', () => {
+    // Find usage of BLOCKED_SIGNALS.test
+    const testCalls = src.match(/BLOCKED_SIGNALS\.test\([^)]+\)/g)
+    assert.ok(testCalls, 'BLOCKED_SIGNALS.test() must be called')
+    assert.ok(testCalls.length >= 2, 'must check at least verification and uatContent')
+
+    const joined = testCalls.join(' ')
+    assert.ok(joined.includes('verification'), 'must test params.verification')
+    assert.ok(joined.includes('uatContent'), 'must test params.uatContent')
+  })
+
+  it('gate returns an error message when blocked signals detected', () => {
+    // Find the return statement after BLOCKED_SIGNALS check
+    const gateIdx = src.indexOf('BLOCKED_SIGNALS.test(')
+    assert.ok(gateIdx !== -1)
+
+    const afterGate = src.slice(gateIdx, gateIdx + 500)
+    assert.ok(
+      afterGate.includes('return { error:'),
+      'blocked signal detection must return an error',
+    )
+    assert.ok(
+      afterGate.includes('do not complete'),
+      'error message must explain why completion is rejected',
+    )
+  })
+})

package/src/resources/extensions/gsd/tests/complete-task-normalize-lists.test.ts

@@ -0,0 +1,54 @@
+/**
+ * Regression test for #3692 — normalizeListParam in complete-task
+ *
+ * Agents sometimes pass keyFiles/keyDecisions as comma-separated strings
+ * instead of arrays.  normalizeListParam coerces both forms to string[].
+ *
+ * Also verifies roadmap-slices.ts detects dependency column from header.
+ */
+
+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';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const completeTaskSrc = readFileSync(
+  join(__dirname, '..', 'tools', 'complete-task.ts'),
+  'utf-8',
+);
+const roadmapSlicesSrc = readFileSync(
+  join(__dirname, '..', 'roadmap-slices.ts'),
+  'utf-8',
+);
+
+describe('complete-task normalizeListParam (#3692)', () => {
+  test('normalizeListParam function is defined', () => {
+    assert.match(completeTaskSrc, /function normalizeListParam\(/,
+      'normalizeListParam function should be defined in complete-task.ts');
+  });
+
+  test('normalizeListParam is applied to keyFiles', () => {
+    assert.match(completeTaskSrc, /normalizeListParam\(params\.keyFiles\)/,
+      'normalizeListParam should be applied to keyFiles');
+  });
+
+  test('normalizeListParam is applied to keyDecisions', () => {
+    assert.match(completeTaskSrc, /normalizeListParam\(params\.keyDecisions\)/,
+      'normalizeListParam should be applied to keyDecisions');
+  });
+});
+
+describe('roadmap-slices depColumnIndex detection (#3692)', () => {
+  test('depColumnIndex is detected from header row', () => {
+    assert.match(roadmapSlicesSrc, /depColumnIndex/,
+      'depColumnIndex variable should exist in roadmap-slices.ts');
+    assert.match(roadmapSlicesSrc, /headerCells/,
+      'headerCells should be parsed from the header row');
+    assert.match(roadmapSlicesSrc, /depends|deps|depend/i,
+      'header detection should match depends/deps/depend');
+  });
+});

package/src/resources/extensions/gsd/tests/defer-milestone-stamp.test.ts

@@ -0,0 +1,30 @@
+/**
+ * Regression test for #3542: defer and milestone captures must be stamped
+ * as executed after triage resolution, regardless of directory state.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { executeTriageResolutions } from "../triage-resolution.ts";
+import { appendCapture, markCaptureResolved, loadAllCaptures } from "../captures.ts";
+
+test("defer captures without milestone ID are stamped as executed (#3542)", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-stamp-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  try {
+    appendCapture(base, "Improve error messages");
+    const captures = loadAllCaptures(base);
+    const id = captures[0].id;
+    markCaptureResolved(base, id, "defer", "Deferred to a future UX-polish milestone", "Not urgent");
+
+    executeTriageResolutions(base, "M001", "S01");
+
+    const after = loadAllCaptures(base);
+    const cap = after.find(c => c.id === id);
+    assert.ok(cap?.executed, "Defer capture should be stamped as executed");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/derive-state-db.test.ts

@@ -1098,16 +1098,17 @@ describe('derive-state-db', async () => {
       // M001: complete milestone with summary
       writeFile(base, 'milestones/M001/M001-SUMMARY.md', '# M001 Summary\n\nDone.');
 
-      // M002: queued milestone — directory exists, no content files, but has DB row
+      // M002: queued milestone — directory exists with CONTEXT file and DB row
       mkdirSync(join(base, '.gsd', 'milestones', 'M002', 'slices'), { recursive: true });
+      writeFile(base, 'milestones/M002/M002-CONTEXT.md', '# M002 Context\n\nPlanned milestone.');
 
       // DB has both M001 complete and M002 queued
       openDatabase(':memory:');
       insertMilestone({ id: 'M001', title: 'First', status: 'complete' });
       insertMilestone({ id: 'M002', title: 'Second', status: 'queued' });
 
-      // isGhostMilestone should NOT treat M002 as ghost when DB row exists
-      assert.ok(!isGhostMilestone(base, 'M002'), 'ghost-dbrow: M002 with DB row is NOT a ghost');
+      // isGhostMilestone should NOT treat M002 as ghost when DB row + content files exist
+      assert.ok(!isGhostMilestone(base, 'M002'), 'ghost-dbrow: M002 with DB row and content is NOT a ghost');
 
       invalidateStateCache();
       const dbState = await deriveStateFromDb(base);