@opengsd/gsd-pi 1.1.1-dev.9bb7453 → 1.1.1-dev.a5a2de8

package/src/resources/extensions/gsd/closeout-consistency-gate.ts

@@ -0,0 +1,137 @@
+// Project/App: gsd-pi
+// File Purpose: Shared DB-backed guard for milestone closeout finalization.
+
+import {
+  getDbPath,
+  getLatestAssessmentByScope,
+  getMilestone,
+  getMilestoneSlices,
+  getPendingGates,
+  getSliceTasks,
+  isDbAvailable,
+  refreshOpenDatabaseFromDisk,
+} from "./gsd-db.js";
+import { isClosedStatus } from "./status-guards.js";
+
+export const CLOSEOUT_CONSISTENCY_BLOCKED_REASON = "closeout-consistency-blocked";
+
+export type CloseoutConsistencyFailureReason =
+  | "db-unavailable"
+  | "db-refresh-failed"
+  | "milestone-missing"
+  | "milestone-open"
+  | "validation-not-pass"
+  | "slice-missing"
+  | "slice-open"
+  | "task-open"
+  | "quality-gate-pending";
+
+export type CloseoutConsistencyResult =
+  | { ok: true }
+  | {
+      ok: false;
+      reason: CloseoutConsistencyFailureReason;
+      recoveryReason: typeof CLOSEOUT_CONSISTENCY_BLOCKED_REASON;
+      message: string;
+    };
+
+export interface CloseoutConsistencyOptions {
+  refreshFromDisk?: boolean;
+}
+
+function blocked(reason: CloseoutConsistencyFailureReason, message: string): CloseoutConsistencyResult {
+  return {
+    ok: false,
+    reason,
+    recoveryReason: CLOSEOUT_CONSISTENCY_BLOCKED_REASON,
+    message,
+  };
+}
+
+function isFileBackedDbPath(path: string | null): boolean {
+  return Boolean(path && path !== ":memory:");
+}
+
+export function checkCloseoutConsistencyGate(
+  milestoneId: string,
+  options: CloseoutConsistencyOptions = {},
+): CloseoutConsistencyResult {
+  if (!isDbAvailable()) {
+    return blocked(
+      "db-unavailable",
+      `Closeout consistency blocked for ${milestoneId}: canonical DB is unavailable.`,
+    );
+  }
+
+  if (options.refreshFromDisk && isFileBackedDbPath(getDbPath()) && !refreshOpenDatabaseFromDisk()) {
+    return blocked(
+      "db-refresh-failed",
+      `Closeout consistency blocked for ${milestoneId}: canonical DB refresh failed.`,
+    );
+  }
+
+  const milestone = getMilestone(milestoneId);
+  if (!milestone) {
+    return blocked(
+      "milestone-missing",
+      `Closeout consistency blocked for ${milestoneId}: milestone is missing from canonical DB.`,
+    );
+  }
+  if (!isClosedStatus(milestone.status)) {
+    return blocked(
+      "milestone-open",
+      `Closeout consistency blocked for ${milestoneId}: canonical DB milestone status is "${milestone.status}".`,
+    );
+  }
+
+  if (milestone.status !== "skipped") {
+    const validation = getLatestAssessmentByScope(milestoneId, "milestone-validation");
+    if (validation?.status !== "pass") {
+      return blocked(
+        "validation-not-pass",
+        `Closeout consistency blocked for ${milestoneId}: latest milestone validation is "${validation?.status ?? "absent"}".`,
+      );
+    }
+  }
+
+  const slices = getMilestoneSlices(milestoneId);
+  if (slices.length === 0 && milestone.status !== "skipped") {
+    return blocked(
+      "slice-missing",
+      `Closeout consistency blocked for ${milestoneId}: no slices exist in canonical DB.`,
+    );
+  }
+
+  for (const slice of slices) {
+    if (!isClosedStatus(slice.status)) {
+      return blocked(
+        "slice-open",
+        `Closeout consistency blocked for ${milestoneId}: slice ${slice.id} status is "${slice.status}".`,
+      );
+    }
+
+    for (const task of getSliceTasks(milestoneId, slice.id)) {
+      if (!isClosedStatus(task.status)) {
+        return blocked(
+          "task-open",
+          `Closeout consistency blocked for ${milestoneId}: task ${slice.id}/${task.id} status is "${task.status}".`,
+        );
+      }
+    }
+
+    const pendingGate = getPendingGates(milestoneId, slice.id)[0];
+    if (pendingGate) {
+      return blocked(
+        "quality-gate-pending",
+        `Closeout consistency blocked for ${milestoneId}: quality gate ${pendingGate.gate_id} is still pending for ${slice.id}.`,
+      );
+    }
+  }
+
+  return { ok: true };
+}
+
+export function formatCloseoutConsistencyBlock(result: CloseoutConsistencyResult): string {
+  if (result.ok) return "";
+  return `${result.message} Recovery reason: ${result.recoveryReason}. Resolve the canonical DB state and run /gsd auto to retry.`;
+}

package/src/resources/extensions/gsd/guided-flow.ts

@@ -98,6 +98,7 @@ import {
   getDiscussionMilestoneId,
   hasPendingAutoStart,
   setPendingAutoStart,
+  type PendingAutoStartEntry,
 } from "./pending-auto-start.js";
 import { clearGuidedUnitContext, setGuidedUnitContext } from "./guided-unit-context.js";
 
@@ -320,6 +321,116 @@ export function _roadmapHasParseableSlicesForTest(
   return parseRoadmapSlices(roadmapContent).length > 0;
 }
 
+function hasExecutablePlanForHandoff(milestoneId: string, roadmapFile: string | null): boolean {
+  if (isDbAvailable()) {
+    return getMilestoneSlices(milestoneId).length > 0;
+  }
+  if (!roadmapFile) return false;
+  try {
+    return parseRoadmapSlices(readFileSync(roadmapFile, "utf-8")).length > 0;
+  } catch (e) {
+    logWarning(
+      "guided",
+      `failed to parse roadmap slices for ${milestoneId}: ${(e as Error).message}`,
+    );
+    return false;
+  }
+}
+
+function formatAcceptedDiscussHandoffMessage(
+  milestoneId: string,
+  contextFile: string | null,
+  hasExecutablePlan: boolean,
+): string {
+  if (hasExecutablePlan) return `Milestone ${milestoneId} ready.`;
+  if (contextFile) return `Milestone ${milestoneId} context captured. Continuing the planning pipeline.`;
+  return `Milestone ${milestoneId} planning artifacts captured. Continuing the planning pipeline.`;
+}
+
+function manifestContainsMilestone(basePath: string, milestoneId: string): boolean {
+  try {
+    const manifest = readManifest(basePath);
+    return (
+      Array.isArray(manifest?.milestones) &&
+      manifest.milestones.some(m => m.id === milestoneId)
+    );
+  } catch (e) {
+    logWarning("guided", `R3b: failed to read state manifest: ${(e as Error).message}`);
+    return false;
+  }
+}
+
+function notifyDbRowRecoveryFailed(entry: PendingAutoStartEntry): void {
+  entry.ctx.ui.notify(
+    `Milestone ${entry.milestoneId}: DB row recovery failed ${entry.r3bRecoveryCount} times. ` +
+    `Re-run /gsd to reset the recovery counter, or run /gsd-debug to diagnose without resetting.`,
+    "error",
+  );
+}
+
+function noteDbRowRecoveryMiss(entry: PendingAutoStartEntry): void {
+  entry.r3bRecoveryCount += 1;
+  if (entry.r3bRecoveryCount >= MAX_DB_ROW_RECOVERIES) {
+    notifyDbRowRecoveryFailed(entry);
+  }
+}
+
+function ensureMilestoneRowForAcceptedHandoff(
+  entry: PendingAutoStartEntry,
+  contextFile: string | null,
+): boolean {
+  if (!isDbAvailable()) return true;
+
+  const { basePath, milestoneId } = entry;
+  const milestoneRow = getMilestone(milestoneId);
+  if (milestoneRow) return true;
+
+  if (manifestContainsMilestone(basePath, milestoneId)) {
+    logWarning(
+      "guided",
+      `R3b: getMilestone(${milestoneId}) returned null but manifest has the row — treating as stale read`,
+    );
+    return true;
+  }
+
+  if (!contextFile) {
+    entry.ctx.ui.notify(
+      `Milestone ${milestoneId}: discuss artifacts on disk but no DB row exists. ` +
+      `PROJECT.md may have failed to register milestones. ` +
+      `Re-save PROJECT.md with canonical "- [ ] M001: Title — One-liner" lines, ` +
+      `then re-run /gsd to recover.`,
+      "error",
+    );
+    return false;
+  }
+
+  if (entry.r3bRecoveryCount >= MAX_DB_ROW_RECOVERIES) {
+    logWarning(
+      "guided",
+      `R3b: milestone ${milestoneId} DB-row recovery limit reached ` +
+      `(${entry.r3bRecoveryCount}/${MAX_DB_ROW_RECOVERIES}); user already notified`,
+    );
+    return false;
+  }
+
+  logWarning(
+    "guided",
+    `R3b: ${milestoneId} has CONTEXT.md but no DB row — inserting placeholder "queued" row ` +
+    `(attempt ${entry.r3bRecoveryCount + 1}/${MAX_DB_ROW_RECOVERIES})`,
+  );
+
+  try {
+    insertMilestone({ id: milestoneId, title: milestoneId, status: "queued" });
+  } catch (e) {
+    logWarning("guided", `R3b: insertMilestone failed: ${(e as Error).message}`);
+  }
+
+  if (getMilestone(milestoneId)) return true;
+
+  noteDbRowRecoveryMiss(entry);
+  return false;
+}
+
 // ─── Commit Instruction Helpers ──────────────────────────────────────────────
 
 /** Build commit instruction for planning prompts. .gsd/ is managed externally and always gitignored. */
@@ -344,10 +455,8 @@ interface PendingDeepProjectSetupEntry {
 // phrase before giving up and asking the user to re-run /gsd.
 const MAX_READY_REJECTS = 2;
 
-// H1 (#5012): cap for Gate 1b plan-blocked recovery hints. After this many
-// consecutive recovery attempts the loop is stopped and the user is directed
-// to investigate manually.
-const MAX_PLAN_BLOCKED_RECOVERIES = 3;
+// Cap failed in-flight DB row repair attempts before escalating to the user.
+const MAX_DB_ROW_RECOVERIES = 3;
 
 // #4573: matches the canonical ready phrase the discuss prompt asks the LLM
 // to emit. Accepts any M-prefixed milestone ID (three digits + optional
@@ -613,72 +722,12 @@ export function checkAutoStartAfterDiscuss(lookupBasePath?: string): boolean {
     }
   }
 
-  // Gate 1b: Discriminate plan-blocked from discuss-incomplete when the DB row is queued.
-  // If the DB is available and the row is still "queued" but CONTEXT.md already exists on
-  // disk, the discuss phase completed but gsd_plan_milestone was hard-blocked by the
-  // depth-verification gate.  Emit a recovery hint so the next agent turn can retry
-  // gsd_plan_milestone, then return false (keep blocking auto-start).
-  // If CONTEXT.md does not exist (discuss-incomplete), Gate 1 already blocked above.
-  if (isDbAvailable()) {
-    const dbRow = getMilestone(milestoneId);
-    if (dbRow?.status === "queued" && contextFile) {
-      if (entry.planBlockedRecoveryCount >= MAX_PLAN_BLOCKED_RECOVERIES) {
-        // H1: recovery loop cap reached — stop triggering new turns, escalate to user.
-        logWarning(
-          "guided",
-          `Gate 1b: milestone ${milestoneId} plan-blocked recovery limit reached ` +
-          `(${entry.planBlockedRecoveryCount}/${MAX_PLAN_BLOCKED_RECOVERIES}); escalating to user`,
-        );
-        ctx.ui.notify(
-          `Milestone ${milestoneId} plan_milestone has been blocked ${entry.planBlockedRecoveryCount} times. ` +
-          `Re-run /gsd to reset the recovery counter, or run /gsd-debug to diagnose without resetting.`,
-          "error",
-        );
-        return false;
-      }
-      logWarning(
-        "guided",
-        `Gate 1b: milestone ${milestoneId} queued with CONTEXT.md present — ` +
-        `plan_milestone was blocked; emitting recovery hint ` +
-        `(attempt ${entry.planBlockedRecoveryCount + 1}/${MAX_PLAN_BLOCKED_RECOVERIES})`,
-      );
-      ctx.ui.notify(
-        `Milestone ${milestoneId}: context file exists but milestone is still queued. ` +
-        `Retrying gsd_plan_milestone to complete the blocked planning step.`,
-        "warning",
-      );
-      try {
-        pi.sendMessage(
-          {
-            customType: "gsd-plan-milestone-blocked-recovery",
-            content:
-              `Milestone ${milestoneId} has ${contextFile} on disk but its DB row is still ` +
-              `"queued". The gsd_plan_milestone tool was previously blocked by the ` +
-              `depth-verification gate. Call gsd_plan_milestone now to complete the ` +
-              `planning phase.`,
-            display: false,
-          },
-          { triggerTurn: true },
-        );
-        // Increment only after a successful dispatch so transient sendMessage
-        // failures do not consume recovery budget.
-        entry.planBlockedRecoveryCount += 1;
-      } catch (e) {
-        logWarning("guided", `Gate 1b recovery sendMessage failed: ${(e as Error).message}`);
-      }
-      return false;
-    }
-  }
-
-  // Gate 2: STATE.md must exist — written as the last step in the discuss
-  // output phase. This prevents auto-start from firing during Phase 3
-  // (sequential readiness gates for remaining milestones) in multi-milestone
-  // discussions, where M001-CONTEXT.md exists but M002/M003 haven't been
-  // processed yet.
-  const stateFilePath = entry.scope.stateFile();
-  if (!existsSync(stateFilePath)) return false; // discussion not finalized yet
+  // Gate 1b: accept the in-flight discuss handoff. A queued DB row with pinned
+  // CONTEXT.md is Discussion Complete, Planning Pending, not a plan-blocked
+  // failure. If the row is missing, only this pending handoff may repair it.
+  if (!ensureMilestoneRowForAcceptedHandoff(entry, contextFile)) return false;
 
-  // Gate 3: Multi-milestone completeness warning
+  // Gate 2: Multi-milestone completeness warning
   // Parse PROJECT.md for milestone sequence, warn if any are missing context.
   // Don't block — milestones can be intentionally queued without context.
   const projectFile = resolveGsdRootFile(basePath, "PROJECT");
@@ -705,7 +754,7 @@ export function checkAutoStartAfterDiscuss(lookupBasePath?: string): boolean {
     } catch (e) { logWarning("guided", `PROJECT.md parsing failed: ${(e as Error).message}`); }
   }
 
-  // Gate 4: Discussion manifest process verification (multi-milestone only)
+  // Gate 3: Discussion manifest process verification (multi-milestone only)
   // The LLM writes DISCUSSION-MANIFEST.json after each Phase 3 gate decision.
   // When it exists, validate it before auto-starting. Project history alone is
   // not a reliable signal for the current discussion mode.
@@ -747,71 +796,12 @@ export function checkAutoStartAfterDiscuss(lookupBasePath?: string): boolean {
     try { unlinkSync(manifestPath); } catch (e) { logWarning("guided", `manifest unlink failed: ${(e as Error).message}`); }
   }
 
-  // R3b: belt-and-suspenders for silent registration failure. The discuss flow
-  // finished and STATE.md exists, but the milestone may never have landed in
-  // the DB. Without this guard, the user sees "Milestone M001 ready." and then
-  // /gsd reports "No Active Milestone".
-  if (isDbAvailable()) {
-    const milestoneRow = getMilestone(milestoneId);
-    if (!milestoneRow) {
-      let manifestHasMilestone = false;
-      try {
-        const manifest = readManifest(basePath);
-        manifestHasMilestone = Array.isArray(manifest?.milestones) && manifest.milestones.some(m => m.id === milestoneId);
-      } catch (e) {
-        logWarning("guided", `R3b: failed to read state manifest: ${(e as Error).message}`);
-      }
-      if (manifestHasMilestone) {
-        logWarning("guided", `R3b: getMilestone(${milestoneId}) returned null but manifest has the row — treating as stale read`);
-      } else if (contextFile) {
-        // R3b-recovery: CONTEXT.md is on disk but gsd_plan_milestone was never called
-        // (likely blocked by the depth-verification gate re-firing on post-verification
-        // text). Auto-register as "queued" so Gate 1b can pick it up and retry
-        // gsd_plan_milestone on the next checkAutoStartAfterDiscuss call.
-        if (entry.r3bRecoveryCount >= MAX_PLAN_BLOCKED_RECOVERIES) {
-          logWarning(
-            "guided",
-            `R3b: milestone ${milestoneId} DB-row recovery limit reached ` +
-            `(${entry.r3bRecoveryCount}/${MAX_PLAN_BLOCKED_RECOVERIES}); escalating to user`,
-          );
-          ctx.ui.notify(
-            `Milestone ${milestoneId}: DB row recovery failed ${entry.r3bRecoveryCount} times. ` +
-            `Re-run /gsd to reset the recovery counter, or run /gsd-debug to diagnose without resetting.`,
-            "error",
-          );
-          return false;
-        }
-        logWarning(
-          "guided",
-          `R3b: ${milestoneId} has CONTEXT.md but no DB row — inserting placeholder "queued" row ` +
-          `for Gate 1b recovery (attempt ${entry.r3bRecoveryCount + 1}/${MAX_PLAN_BLOCKED_RECOVERIES})`,
-        );
-        try {
-          insertMilestone({ id: milestoneId, title: milestoneId, status: "queued" });
-        } catch (e) {
-          logWarning("guided", `R3b: insertMilestone failed: ${(e as Error).message}`);
-        }
-        entry.r3bRecoveryCount += 1;
-        ctx.ui.notify(
-          `Milestone ${milestoneId}: context file exists but DB row was missing — recovering. Retrying gsd_plan_milestone.`,
-          "warning",
-        );
-        return false;
-      } else {
-        ctx.ui.notify(
-          `Milestone ${milestoneId}: discuss artifacts on disk but no DB row exists. ` +
-          `PROJECT.md may have failed to register milestones. ` +
-          `Re-save PROJECT.md with canonical "- [ ] M001: Title — One-liner" lines, ` +
-          `then re-run /gsd to recover.`,
-          "error",
-        );
-        return false;
-      }
-    }
-  }
-
   deletePendingAutoStart(basePath);
-  ctx.ui.notify(`Milestone ${milestoneId} ready.`, "success");
+  const hasExecutablePlan = hasExecutablePlanForHandoff(milestoneId, roadmapFile);
+  ctx.ui.notify(
+    formatAcceptedDiscussHandoffMessage(milestoneId, contextFile, hasExecutablePlan),
+    "success",
+  );
   if (entry.startAuto !== false) {
     scheduleAutoStartAfterIdle(ctx, pi, basePath, false, { step: step ?? true });
   }

package/src/resources/extensions/gsd/milestone-closeout.ts

@@ -16,6 +16,7 @@ import { extractVerdict, isAcceptableUatVerdict } from "./verdict-parser.js";
 import { logWarning } from "./workflow-logger.js";
 import { hasImplementationArtifacts } from "./milestone-implementation-evidence.js";
 import { buildCompleteMilestonePrompt } from "./auto-prompts.js";
+import { checkCloseoutConsistencyGate } from "./closeout-consistency-gate.js";
 import type { DispatchAction, DispatchContext } from "./auto-dispatch.js";
 import {
   commitPendingMilestoneCloseoutChanges,
@@ -37,7 +38,8 @@ export async function isMilestoneCloseoutSettled(mid: string, basePath: string):
     if (isDbAvailable()) {
       const milestone = getMilestone(mid);
       if (milestone && isClosedStatus(milestone.status)) {
-        if (verifyExpectedArtifact("complete-milestone", mid, basePath)) {
+        const closeoutGate = checkCloseoutConsistencyGate(mid, { refreshFromDisk: true });
+        if (closeoutGate.ok && verifyExpectedArtifact("complete-milestone", mid, basePath)) {
           return true;
         }
       }

package/src/resources/extensions/gsd/pending-auto-start.ts

@@ -14,7 +14,6 @@ export interface PendingAutoStartEntry {
   createdAt: number;
   readyRejectCount?: number;
   scope: MilestoneScope;
-  planBlockedRecoveryCount: number;
   r3bRecoveryCount: number;
 }
 
@@ -51,7 +50,6 @@ export function setPendingAutoStart(basePath: string, entry: PendingAutoStartInp
   const scope = scopeMilestone(ws, entry.milestoneId);
   pendingAutoStartMap.set(basePath, {
     createdAt: Date.now(),
-    planBlockedRecoveryCount: 0,
     r3bRecoveryCount: 0,
     ...entry,
     scope,

package/src/resources/extensions/gsd/prompts/run-uat.md

@@ -75,24 +75,10 @@ verdict: "PASS" | "FAIL" | "PARTIAL",
 notes: "<one sentence overall verdict rationale>",
 ```
 
-Use this exact `presentation` shape in the save call so the audit can verify the run-uat tool surface without retrying missing fields one by one:
+Use this canonical `presentation` object in the save call so the audit can verify the run-uat tool surface without retrying missing fields one by one. Keep `toolPresentationPlanId` as `{{toolPresentationPlanId}}`. If browser tools were actually presented for this run, add those concrete browser tool names to `presentedTools`; otherwise reuse this object exactly:
 
-```ts
-presentation: {
-  surface: "mcp",
-  presentedTools: [
-    "gsd_uat_exec",
-    "gsd_uat_result_save",
-    "gsd_resume",
-    "gsd_milestone_status",
-    "gsd_journal_query",
-  ],
-  blockedTools: [
-    { name: "gsd_exec", reason: "forbidden during run-uat" },
-    { name: "gsd_summary_save", reason: "forbidden during run-uat" },
-    { name: "gsd_save_gate_result", reason: "forbidden during run-uat" },
-  ],
-}
+```json
+{{canonicalPresentation}}
 ```
 
 Pass `checks` with this logical shape:

package/src/resources/extensions/gsd/recovery-classification.ts

@@ -6,7 +6,9 @@ import { ReconciliationFailedError } from "./state-reconciliation.js";
 
 export type RecoveryFailureKind =
   | "tool-schema"
+  | "tool-contract"
   | "deterministic-policy"
+  | "lifecycle-progression"
   | "stale-worker"
   | "worktree-invalid"
   | "verification-drift"
@@ -52,6 +54,14 @@ export function classifyFailure(input: RecoveryClassificationInput): RecoveryCla
         exitReason: "tool-schema",
         remediation: "Fix the Unit Tool Contract or tool schema before retrying.",
       };
+    case "tool-contract":
+      return {
+        failureKind,
+        action: "stop",
+        reason: `Tool Contract failure${unitSuffix(input)}: ${message}`,
+        exitReason: "tool-contract",
+        remediation: "Fix the Unit Tool Contract or prompt so the Unit is only asked to use tools owned by its phase.",
+      };
     case "deterministic-policy":
       return {
         failureKind,
@@ -60,6 +70,14 @@ export function classifyFailure(input: RecoveryClassificationInput): RecoveryCla
         exitReason: "deterministic-policy",
         remediation: "Resolve the policy blocker; retrying the same Unit will repeat the failure.",
       };
+    case "lifecycle-progression":
+      return {
+        failureKind,
+        action: "stop",
+        reason: `Lifecycle progression failure${unitSuffix(input)}: ${message}`,
+        exitReason: "lifecycle-progression",
+        remediation: "Route to the required owning Unit or restore the missing artifact before advancing lifecycle state.",
+      };
     case "stale-worker":
       return {
         failureKind,
@@ -118,6 +136,8 @@ export function classifyFailure(input: RecoveryClassificationInput): RecoveryCla
 }
 
 function inferFailureKind(message: string): RecoveryFailureKind {
+  if (/tool contract|auto-unit tool scope|phase-boundary gate|not permitted.*own/i.test(message)) return "tool-contract";
+  if (/lifecycle progression|required artifact|missing .*assessment|missing .*closeout|cannot legally (?:advance|progress)/i.test(message)) return "lifecycle-progression";
   if (/schema|invalid.*tool|tool.*invalid|enum/i.test(message)) return "tool-schema";
   if (/deterministic policy|policy rejection|write gate|blocked by policy/i.test(message)) return "deterministic-policy";
   if (/stale worker|stale lock|worker.*stale/i.test(message)) return "stale-worker";

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

@@ -1558,6 +1558,14 @@ test("verifyExpectedArtifact complete-milestone passes when DB milestone is comp
 
     openDatabase(join(base, ".gsd", "gsd.db"));
     insertMilestone({ id: "M001", title: "Milestone One", status: "complete" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Done Slice", status: "complete" });
+    insertAssessment({
+      path: "milestones/M001/M001-VALIDATION.md",
+      milestoneId: "M001",
+      status: "pass",
+      scope: "milestone-validation",
+      fullContent: "verdict: pass",
+    });
 
     const result = verifyExpectedArtifact("complete-milestone", "M001", base);
     assert.equal(result, true, "complete-milestone should pass when DB status is complete");
@@ -1566,7 +1574,7 @@ test("verifyExpectedArtifact complete-milestone passes when DB milestone is comp
   }
 });
 
-test("verifyExpectedArtifact complete-milestone tolerates transient DB lag when SUMMARY is canonical success (#4658)", () => {
+test("verifyExpectedArtifact complete-milestone rejects success SUMMARY when DB milestone is still open (#4658)", () => {
   const base = makeGitBase();
   try {
     execFileSync("git", ["checkout", "-b", "feat/ms-db-lag-success"], { cwd: base, stdio: "ignore" });
@@ -1591,7 +1599,7 @@ test("verifyExpectedArtifact complete-milestone tolerates transient DB lag when
     insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
 
     const result = verifyExpectedArtifact("complete-milestone", "M001", base);
-    assert.equal(result, true, "canonical success SUMMARY should pass verification during transient DB lag");
+    assert.equal(result, false, "success SUMMARY must not overrule an open DB milestone");
   } finally {
     cleanup(base);
   }

package/src/resources/extensions/gsd/tests/auto-start-bootstrap-await-3420.test.ts

@@ -30,6 +30,7 @@ test("checkAutoStartAfterDiscuss waits until discussion artifacts exist before r
   setPendingAutoStart(base, {
     basePath: base,
     milestoneId: "M001",
+    startAuto: false,
     ctx: { ui: { notify: (message: string) => notifications.push(message) } } as any,
     pi: { sendMessage: () => {} } as any,
   });
@@ -41,5 +42,7 @@ test("checkAutoStartAfterDiscuss waits until discussion artifacts exist before r
   writeFileSync(join(base, ".gsd", "STATE.md"), "# State\n", "utf-8");
 
   assert.equal(checkAutoStartAfterDiscuss(), true);
-  assert.deepEqual(notifications, ["Milestone M001 ready."]);
+  assert.deepEqual(notifications, [
+    "Milestone M001 context captured. Continuing the planning pipeline.",
+  ]);
 });

package/src/resources/extensions/gsd/tests/auto-warning-noise-regression.test.ts

@@ -92,13 +92,23 @@ test("checkAutoStartAfterDiscuss completes when discussion manifest is absent",
     setPendingAutoStart(base, {
       basePath: base,
       milestoneId: "M001",
-      ctx: { ui: { notify: (message: string, level: string) => notifications.push({ message, level }) } } as any,
+      startAuto: false,
+      ctx: {
+        ui: {
+          notify: (message: string, level: string) => notifications.push({ message, level }),
+        },
+      } as any,
       pi: { sendMessage: () => { scheduled = true; } } as any,
     });
 
     assert.equal(checkAutoStartAfterDiscuss(), true);
     assert.equal(scheduled, false);
-    assert.deepEqual(notifications, [{ message: "Milestone M001 ready.", level: "success" }]);
+    assert.deepEqual(notifications, [
+      {
+        message: "Milestone M001 context captured. Continuing the planning pipeline.",
+        level: "success",
+      },
+    ]);
   } finally {
     clearPendingAutoStart(base);
     rmSync(base, { recursive: true, force: true });