gsd-pi 2.57.0-dev.f22a903 → 2.58.0-dev.778d6ac

package/src/resources/extensions/gsd/undo.ts

@@ -5,7 +5,7 @@
 
 import type { ExtensionCommandContext, ExtensionAPI } from "@gsd/pi-coding-agent";
 import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from "node:fs";
-import { join } from "node:path";
+import { join, basename } from "node:path";
 import { nativeRevertCommit, nativeRevertAbort } from "./native-git-bridge.js";
 import { parseUnitId } from "./unit-id.js";
 import { deriveState } from "./state.js";
@@ -133,7 +133,7 @@ export async function handleUndo(args: string, ctx: ExtensionCommandContext, _pi
   }
 
   ctx.ui.notify(results.join("\n"), "success");
-  sendDesktopNotification("GSD", `Undone: ${unitType} (${unitId})`, "info", "complete");
+  sendDesktopNotification("GSD", `Undone: ${unitType} (${unitId})`, "info", "complete", basename(basePath));
 }
 
 // ─── Targeted State Reset ────────────────────────────────────────────────────

package/src/resources/extensions/gsd/unit-ownership.ts

@@ -3,18 +3,20 @@
 //
 // An agent can claim a unit (task, slice) before working on it.
 // complete-task and complete-slice enforce ownership when claims exist.
-// If no claim file is present, ownership is not enforced (backward compatible).
+// Claims are stored in SQLite (.gsd/unit-claims.db) for atomic
+// first-writer-wins semantics via INSERT OR IGNORE.
 //
-// Claim file location: .gsd/unit-claims.json
 // Unit key format:
 //   task:  "<milestoneId>/<sliceId>/<taskId>"
 //   slice: "<milestoneId>/<sliceId>"
 //
 // Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 
-import { existsSync, readFileSync, mkdirSync } from "node:fs";
+import { createRequire } from "node:module";
+import { mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { atomicWriteSync } from "./atomic-write.js";
+
+const _require = createRequire(import.meta.url);
 
 // ─── Types ───────────────────────────────────────────────────────────────
 
@@ -23,7 +25,133 @@ export interface UnitClaim {
   claimed_at: string;
 }
 
-type ClaimsMap = Record<string, UnitClaim>;
+// ─── SQLite Provider (mirrors gsd-db.ts pattern) ─────────────────────────
+
+interface StmtLike {
+  run(...params: unknown[]): unknown;
+  get(...params: unknown[]): Record<string, unknown> | undefined;
+}
+
+interface DbLike {
+  exec(sql: string): void;
+  prepare(sql: string): StmtLike;
+  close(): void;
+}
+
+type ProviderName = "node:sqlite" | "better-sqlite3";
+
+let providerName: ProviderName | null = null;
+let providerModule: unknown = null;
+let loadAttempted = false;
+
+function suppressSqliteWarning(): void {
+  const origEmit = process.emit;
+  // @ts-expect-error overriding process.emit for warning filter
+  process.emit = function (event: string, ...args: unknown[]): boolean {
+    if (
+      event === "warning" &&
+      args[0] &&
+      typeof args[0] === "object" &&
+      "name" in args[0] &&
+      (args[0] as { name: string }).name === "ExperimentalWarning" &&
+      "message" in args[0] &&
+      typeof (args[0] as { message: string }).message === "string" &&
+      (args[0] as { message: string }).message.includes("SQLite")
+    ) {
+      return false;
+    }
+    return origEmit.apply(process, [event, ...args] as Parameters<typeof process.emit>) as unknown as boolean;
+  };
+}
+
+function loadProvider(): void {
+  if (loadAttempted) return;
+  loadAttempted = true;
+
+  try {
+    suppressSqliteWarning();
+    const mod = _require("node:sqlite");
+    if (mod.DatabaseSync) {
+      providerModule = mod;
+      providerName = "node:sqlite";
+      return;
+    }
+  } catch {
+    // unavailable
+  }
+
+  try {
+    const mod = _require("better-sqlite3");
+    if (typeof mod === "function" || (mod && mod.default)) {
+      providerModule = mod.default || mod;
+      providerName = "better-sqlite3";
+      return;
+    }
+  } catch {
+    // unavailable
+  }
+}
+
+function normalizeRow(row: unknown): Record<string, unknown> | undefined {
+  if (row == null) return undefined;
+  if (Object.getPrototypeOf(row) === null) {
+    return { ...(row as Record<string, unknown>) };
+  }
+  return row as Record<string, unknown>;
+}
+
+function openRawDb(path: string): unknown {
+  loadProvider();
+  if (!providerModule || !providerName) return null;
+
+  if (providerName === "node:sqlite") {
+    const { DatabaseSync } = providerModule as {
+      DatabaseSync: new (path: string) => unknown;
+    };
+    return new DatabaseSync(path);
+  }
+
+  const Database = providerModule as new (path: string) => unknown;
+  return new Database(path);
+}
+
+function wrapDb(rawDb: unknown): DbLike {
+  const db = rawDb as {
+    exec(sql: string): void;
+    prepare(sql: string): {
+      run(...args: unknown[]): unknown;
+      get(...args: unknown[]): unknown;
+    };
+    close(): void;
+  };
+  return {
+    exec(sql: string): void { db.exec(sql); },
+    prepare(sql: string): StmtLike {
+      const raw = db.prepare(sql);
+      return {
+        run(...params: unknown[]): unknown { return raw.run(...params); },
+        get(...params: unknown[]): Record<string, unknown> | undefined {
+          return normalizeRow(raw.get(...params));
+        },
+      };
+    },
+    close(): void { db.close(); },
+  };
+}
+
+// ─── Per-basePath DB pool ────────────────────────────────────────────────
+
+const dbPool = new Map<string, DbLike>();
+
+function claimsDbPath(basePath: string): string {
+  return join(basePath, ".gsd", "unit-claims.db");
+}
+
+function getDb(basePath: string): DbLike | null {
+  const existing = dbPool.get(basePath);
+  if (existing) return existing;
+  return null;
+}
 
 // ─── Key Builders ────────────────────────────────────────────────────────
 
@@ -35,60 +163,103 @@ export function sliceUnitKey(milestoneId: string, sliceId: string): string {
   return `${milestoneId}/${sliceId}`;
 }
 
-// ─── File Path ───────────────────────────────────────────────────────────
+// ─── Lifecycle ───────────────────────────────────────────────────────────
 
-function claimsPath(basePath: string): string {
-  return join(basePath, ".gsd", "unit-claims.json");
-}
+/**
+ * Initialize the ownership SQLite database for a given basePath.
+ * Creates .gsd/ directory and unit-claims.db with the unit_claims table.
+ * Safe to call multiple times (idempotent).
+ */
+export function initOwnershipTable(basePath: string): void {
+  if (dbPool.has(basePath)) return;
 
-// ─── Read Claims ─────────────────────────────────────────────────────────
+  const dir = join(basePath, ".gsd");
+  mkdirSync(dir, { recursive: true });
 
-function readClaims(basePath: string): ClaimsMap | null {
-  const path = claimsPath(basePath);
-  if (!existsSync(path)) return null;
-  try {
-    return JSON.parse(readFileSync(path, "utf-8")) as ClaimsMap;
-  } catch {
-    return null;
+  const raw = openRawDb(claimsDbPath(basePath));
+  if (!raw) {
+    throw new Error("No SQLite provider available for unit-ownership");
   }
+
+  const db = wrapDb(raw);
+
+  db.exec("PRAGMA journal_mode=WAL");
+  db.exec("PRAGMA busy_timeout = 5000");
+  db.exec("PRAGMA synchronous = NORMAL");
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS unit_claims (
+      unit_key TEXT PRIMARY KEY,
+      agent_name TEXT NOT NULL,
+      claimed_at TEXT NOT NULL
+    )
+  `);
+
+  dbPool.set(basePath, db);
+}
+
+/**
+ * Close the ownership database for a given basePath.
+ * Safe to call even if not initialized.
+ */
+export function closeOwnershipDb(basePath: string): void {
+  const db = dbPool.get(basePath);
+  if (!db) return;
+  try { db.close(); } catch { /* swallow */ }
+  dbPool.delete(basePath);
 }
 
 // ─── Public API ──────────────────────────────────────────────────────────
 
 /**
  * Claim a unit for an agent.
- * Overwrites any existing claim for this unit (last writer wins).
+ * Uses INSERT OR IGNORE for atomic first-writer-wins semantics.
+ * Returns true if the claim was acquired (or the same agent already owns it).
+ * Returns false if a different agent already owns the unit.
  */
-export function claimUnit(basePath: string, unitKey: string, agentName: string): void {
-  const claims = readClaims(basePath) ?? {};
-  claims[unitKey] = { agent: agentName, claimed_at: new Date().toISOString() };
-  const dir = join(basePath, ".gsd");
-  mkdirSync(dir, { recursive: true });
-  atomicWriteSync(claimsPath(basePath), JSON.stringify(claims, null, 2) + "\n");
+export function claimUnit(basePath: string, unitKey: string, agentName: string): boolean {
+  const db = getDb(basePath);
+  if (!db) {
+    // Auto-init if not already initialized (backward compat)
+    initOwnershipTable(basePath);
+    return claimUnit(basePath, unitKey, agentName);
+  }
+
+  // INSERT OR IGNORE: if the row already exists, this is a no-op.
+  // The PRIMARY KEY constraint on unit_key prevents duplicate claims.
+  db.prepare(
+    "INSERT OR IGNORE INTO unit_claims (unit_key, agent_name, claimed_at) VALUES (?, ?, ?)",
+  ).run(unitKey, agentName, new Date().toISOString());
+
+  // Check who owns it now
+  const row = db.prepare("SELECT agent_name FROM unit_claims WHERE unit_key = ?").get(unitKey);
+  const owner = row?.agent_name as string | undefined;
+
+  return owner === agentName;
 }
 
 /**
- * Release a unit claim (remove it from the claims map).
+ * Release a unit claim (remove it from the claims table).
  */
 export function releaseUnit(basePath: string, unitKey: string): void {
-  const claims = readClaims(basePath);
-  if (!claims || !(unitKey in claims)) return;
-  delete claims[unitKey];
-  atomicWriteSync(claimsPath(basePath), JSON.stringify(claims, null, 2) + "\n");
+  const db = getDb(basePath);
+  if (!db) return;
+  db.prepare("DELETE FROM unit_claims WHERE unit_key = ?").run(unitKey);
 }
 
 /**
- * Get the current owner of a unit, or null if unclaimed / no claims file.
+ * Get the current owner of a unit, or null if unclaimed.
  */
 export function getOwner(basePath: string, unitKey: string): string | null {
-  const claims = readClaims(basePath);
-  if (!claims) return null;
-  return claims[unitKey]?.agent ?? null;
+  const db = getDb(basePath);
+  if (!db) return null;
+  const row = db.prepare("SELECT agent_name FROM unit_claims WHERE unit_key = ?").get(unitKey);
+  return (row?.agent_name as string) ?? null;
 }
 
 /**
  * Check if an actor is authorized to operate on a unit.
- * Returns null if ownership passes (or is unclaimed / no file).
+ * Returns null if ownership passes (or is unclaimed).
  * Returns an error string if a different agent owns the unit.
  */
 export function checkOwnership(
@@ -98,7 +269,7 @@ export function checkOwnership(
 ): string | null {
   if (!actorName) return null; // no actor identity provided — opt-in, so allow
   const owner = getOwner(basePath, unitKey);
-  if (owner === null) return null; // unit unclaimed or no claims file
+  if (owner === null) return null; // unit unclaimed
   if (owner === actorName) return null; // actor is the owner
   return `Unit ${unitKey} is owned by ${owner}, not ${actorName}`;
 }

package/src/resources/extensions/gsd/verdict-parser.ts

@@ -20,13 +20,28 @@ import type { UatType } from "./files.js";
  * Returns `undefined` when frontmatter is absent or has no `verdict` field.
  */
 export function extractVerdict(content: string): string | undefined {
+  // Primary: YAML frontmatter verdict (canonical format)
   const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
-  if (!fmMatch) return undefined;
-  const verdictMatch = fmMatch[1].match(/verdict:\s*([\w-]+)/i);
-  if (!verdictMatch) return undefined;
-  let v = verdictMatch[1].toLowerCase();
-  if (v === "passed") v = "pass";
-  return v;
+  if (fmMatch) {
+    const verdictMatch = fmMatch[1].match(/verdict:\s*([\w-]+)/i);
+    if (verdictMatch) {
+      let v = verdictMatch[1].toLowerCase();
+      if (v === "passed") v = "pass";
+      return v;
+    }
+    return undefined;
+  }
+
+  // Fallback: detect verdict in markdown body (LLM manual writes, #2960).
+  // Matches patterns like: **Verdict:** PASS, **Verdict:** ✅ PASS, **Verdict** needs-remediation
+  const bodyMatch = content.match(/\*\*Verdict:?\*\*\s*(?:✅\s*)?(\w[\w-]*)/i);
+  if (bodyMatch) {
+    let v = bodyMatch[1].toLowerCase();
+    if (v === "passed") v = "pass";
+    return v;
+  }
+
+  return undefined;
 }
 
 /**

package/src/resources/extensions/gsd/workflow-logger.ts

@@ -31,7 +31,9 @@ export type LogComponent =
   | "state"         // deriveState fallback/degradation
   | "tool"          // Tool handler errors
   | "compaction"    // Event compaction
-  | "reconcile";    // Worktree reconciliation
+  | "reconcile"     // Worktree reconciliation
+  | "db"            // Database operations (gsd-db)
+  | "dispatch";     // Auto-dispatch rule evaluation
 
 export interface LogEntry {
   ts: string;

package/src/resources/extensions/gsd/workflow-manifest.ts

@@ -42,6 +42,23 @@ function requireDb() {
   return db;
 }
 
+/**
+ * Coerce a raw DB value to a number, returning `fallback` for
+ * null/undefined/non-numeric strings (e.g. "-", "N/A", "").
+ * SQLite can store TEXT in INTEGER columns after migrations or manual inserts.
+ */
+export function toNumeric(value: unknown, fallback: number | null = null): number | null {
+  if (value === null || value === undefined) return fallback;
+  if (typeof value === "number") return Number.isFinite(value) ? value : fallback;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed === "" || trimmed === "-" || trimmed === "N/A") return fallback;
+    const n = Number(trimmed);
+    return Number.isFinite(n) ? n : fallback;
+  }
+  return fallback;
+}
+
 // ─── snapshotState ───────────────────────────────────────────────────────
 
 /**
@@ -99,7 +116,7 @@ export function snapshotState(): StateManifest {
     proof_level: (r["proof_level"] as string) ?? "",
     integration_closure: (r["integration_closure"] as string) ?? "",
     observability_impact: (r["observability_impact"] as string) ?? "",
-    sequence: (r["sequence"] as number) ?? 0,
+    sequence: toNumeric(r["sequence"], 0) as number,
     replan_triggered_at: (r["replan_triggered_at"] as string) ?? null,
   }));
 
@@ -129,12 +146,12 @@ export function snapshotState(): StateManifest {
     expected_output: JSON.parse((r["expected_output"] as string) || "[]"),
     observability_impact: (r["observability_impact"] as string) ?? "",
     full_plan_md: (r["full_plan_md"] as string) ?? "",
-    sequence: (r["sequence"] as number) ?? 0,
+    sequence: toNumeric(r["sequence"], 0) as number,
   }));
 
   const rawDecisions = db.prepare("SELECT * FROM decisions ORDER BY seq").all() as Record<string, unknown>[];
   const decisions: Decision[] = rawDecisions.map((r) => ({
-    seq: r["seq"] as number,
+    seq: toNumeric(r["seq"], 0) as number,
     id: r["id"] as string,
     when_context: (r["when_context"] as string) ?? "",
     scope: (r["scope"] as string) ?? "",
@@ -153,9 +170,9 @@ export function snapshotState(): StateManifest {
     slice_id: r["slice_id"] as string,
     milestone_id: r["milestone_id"] as string,
     command: r["command"] as string,
-    exit_code: (r["exit_code"] as number) ?? null,
+    exit_code: toNumeric(r["exit_code"]),
     verdict: (r["verdict"] as string) ?? "",
-    duration_ms: (r["duration_ms"] as number) ?? null,
+    duration_ms: toNumeric(r["duration_ms"]),
     created_at: r["created_at"] as string,
   }));
 

package/src/resources/extensions/gsd/workflow-projections.ts

@@ -9,8 +9,9 @@ import {
   getMilestone,
   getMilestoneSlices,
   getSliceTasks,
+  getVerificationEvidence,
 } from "./gsd-db.js";
-import type { MilestoneRow, SliceRow, TaskRow } from "./gsd-db.js";
+import type { MilestoneRow, SliceRow, TaskRow, VerificationEvidenceRow } from "./gsd-db.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { join } from "node:path";
 import { mkdirSync, existsSync } from "node:fs";
@@ -29,8 +30,10 @@ export function renderPlanContent(sliceRow: SliceRow, taskRows: TaskRow[]): stri
 
   lines.push(`# ${sliceRow.id}: ${sliceRow.title}`);
   lines.push("");
-  lines.push(`**Goal:** ${sliceRow.goal || sliceRow.full_summary_md || "TBD"}`);
-  lines.push(`**Demo:** After this: ${sliceRow.demo || sliceRow.full_uat_md || "TBD"}`);
+  // #2945: never use full_summary_md/full_uat_md as display fallbacks —
+  // they contain multi-line rendered markdown that corrupts single-line fields.
+  lines.push(`**Goal:** ${sliceRow.goal || "TBD"}`);
+  lines.push(`**Demo:** After this: ${sliceRow.demo || "TBD"}`);
   lines.push("");
   lines.push("## Tasks");
 
@@ -113,7 +116,10 @@ export function renderRoadmapContent(milestoneRow: MilestoneRow, sliceRows: Slic
     }
 
     const risk = (slice.risk || "low").toLowerCase();
-    const demo = slice.demo || slice.full_uat_md || "TBD";
+    // #2945 Bug 1: never use full_uat_md as a table cell fallback — it contains
+    // multi-line UAT content (preconditions, steps, expected results) that
+    // corrupts the markdown table and makes subsequent slices invisible.
+    const demo = slice.demo || "TBD";
 
     lines.push(`| ${slice.id} | ${slice.title} | ${risk} | ${depends} | ${done} | ${demo} |`);
   }
@@ -142,71 +148,93 @@ export function renderRoadmapProjection(basePath: string, milestoneId: string):
 
 /**
  * Render SUMMARY.md content from a task row.
- * Pure function — no side effects.
+ * Single source of truth for summary rendering — used both at completion
+ * time and at projection regeneration time (#2720).
+ *
+ * @param evidence - Optional verification evidence rows. When called from
+ *   complete-task, these are passed directly. When called from projection
+ *   regeneration, they are queried from the DB by renderSummaryProjection.
  */
-export function renderSummaryContent(taskRow: TaskRow, sliceId: string, milestoneId: string): string {
-  const lines: string[] = [];
-
-  // Frontmatter
-  lines.push("---");
-  lines.push(`id: ${taskRow.id}`);
-  lines.push(`parent: ${sliceId}`);
-  lines.push(`milestone: ${milestoneId}`);
-  lines.push("provides: []");
-  lines.push("requires: []");
-  lines.push("affects: []");
-
-  // key_files is already parsed to string[]
-  if (taskRow.key_files && taskRow.key_files.length > 0) {
-    lines.push(`key_files: [${taskRow.key_files.map(f => `"${f}"`).join(", ")}]`);
+export function renderSummaryContent(
+  taskRow: TaskRow,
+  sliceId: string,
+  milestoneId: string,
+  evidence?: Array<{ command: string; exitCode?: number; exit_code?: number; verdict: string; durationMs?: number; duration_ms?: number }>,
+): string {
+  // ── Frontmatter (YAML list format, matches parseSummary() expectations) ──
+  const keyFilesYaml = taskRow.key_files && taskRow.key_files.length > 0
+    ? taskRow.key_files.map(f => `  - ${f}`).join("\n")
+    : "  - (none)";
+  const keyDecisionsYaml = taskRow.key_decisions && taskRow.key_decisions.length > 0
+    ? taskRow.key_decisions.map(d => `  - ${d}`).join("\n")
+    : "  - (none)";
+
+  // Derive verification_result from evidence if available
+  const evidenceList = evidence ?? [];
+  const allPassed = evidenceList.length > 0 &&
+    evidenceList.every(e => {
+      const code = e.exitCode ?? e.exit_code ?? -1;
+      return code === 0 || e.verdict.includes("\u2705") || e.verdict.toLowerCase().includes("pass");
+    });
+  const verificationResult = taskRow.verification_result
+    ? (allPassed ? "passed" : (evidenceList.length === 0 ? "untested" : "mixed"))
+    : (allPassed ? "passed" : (evidenceList.length === 0 ? "untested" : "mixed"));
+
+  // Build verification evidence table
+  let evidenceTable = "| # | Command | Exit Code | Verdict | Duration |\n|---|---------|-----------|---------|----------|\n";
+  if (evidenceList.length > 0) {
+    evidenceList.forEach((e, i) => {
+      const code = e.exitCode ?? e.exit_code ?? 0;
+      const dur = e.durationMs ?? e.duration_ms ?? 0;
+      evidenceTable += `| ${i + 1} | \`${e.command}\` | ${code} | ${e.verdict} | ${dur}ms |\n`;
+    });
   } else {
-    lines.push("key_files: []");
+    evidenceTable += "| \u2014 | No verification commands discovered | \u2014 | \u2014 | \u2014 |\n";
   }
 
-  // key_decisions is already parsed to string[]
-  if (taskRow.key_decisions && taskRow.key_decisions.length > 0) {
-    lines.push(`key_decisions: [${taskRow.key_decisions.map(d => `"${d}"`).join(", ")}]`);
-  } else {
-    lines.push("key_decisions: []");
-  }
+  const title = taskRow.one_liner || taskRow.title || taskRow.id;
 
-  lines.push("patterns_established: []");
-  lines.push("drill_down_paths: []");
-  lines.push("observability_surfaces: []");
-  lines.push(`duration: "${taskRow.duration || ""}"`);
-  lines.push(`verification_result: "${taskRow.verification_result || ""}"`);
-  lines.push(`completed_at: ${taskRow.completed_at || ""}`);
-  lines.push(`blocker_discovered: ${taskRow.blocker_discovered ? "true" : "false"}`);
-  lines.push("---");
-  lines.push("");
-  lines.push(`# ${taskRow.id}: ${taskRow.title}`);
-  lines.push("");
+  return `---
+id: ${taskRow.id}
+parent: ${sliceId}
+milestone: ${milestoneId}
+key_files:
+${keyFilesYaml}
+key_decisions:
+${keyDecisionsYaml}
+duration: ${taskRow.duration || ""}
+verification_result: ${verificationResult}
+completed_at: ${taskRow.completed_at || ""}
+blocker_discovered: ${taskRow.blocker_discovered ? "true" : "false"}
+---
 
-  // One-liner (if present)
-  if (taskRow.one_liner) {
-    lines.push(`> ${taskRow.one_liner}`);
-    lines.push("");
-  }
+# ${taskRow.id}: ${title}
 
-  lines.push("## What Happened");
-  lines.push(taskRow.full_summary_md || taskRow.narrative || "No summary recorded.");
-  lines.push("");
+**${taskRow.one_liner || ""}**
 
-  // Deviations (if present)
-  if (taskRow.deviations) {
-    lines.push("## Deviations");
-    lines.push(taskRow.deviations);
-    lines.push("");
-  }
+## What Happened
 
-  // Known issues (if present)
-  if (taskRow.known_issues) {
-    lines.push("## Known Issues");
-    lines.push(taskRow.known_issues);
-    lines.push("");
-  }
+${taskRow.narrative || "No summary recorded."}
 
-  return lines.join("\n");
+## Verification
+
+${taskRow.verification_result || "No verification recorded."}
+
+## Verification Evidence
+
+${evidenceTable}
+## Deviations
+
+${taskRow.deviations || "None."}
+
+## Known Issues
+
+${taskRow.known_issues || "None."}
+
+## Files Created/Modified
+
+${taskRow.key_files && taskRow.key_files.length > 0 ? taskRow.key_files.map(f => `- \`${f}\``).join("\n") : "None."}
+`;
 }
 
 /**
@@ -218,7 +246,8 @@ export function renderSummaryProjection(basePath: string, milestoneId: string, s
   const taskRow = taskRows.find(t => t.id === taskId);
   if (!taskRow) return;
 
-  const content = renderSummaryContent(taskRow, sliceId, milestoneId);
+  const evidenceRows = getVerificationEvidence(milestoneId, sliceId, taskId);
+  const content = renderSummaryContent(taskRow, sliceId, milestoneId, evidenceRows);
   const dir = join(basePath, ".gsd", "milestones", milestoneId, "slices", sliceId, "tasks");
   mkdirSync(dir, { recursive: true });
   atomicWriteSync(join(dir, `${taskId}-SUMMARY.md`), content);
@@ -235,14 +264,18 @@ export function renderStateContent(state: GSDState): string {
   const lines: string[] = [];
   lines.push("# GSD State", "");
 
-  const activeMilestone = state.activeMilestone
-    ? `${state.activeMilestone.id}: ${state.activeMilestone.title}`
-    : "None";
   const activeSlice = state.activeSlice
     ? `${state.activeSlice.id}: ${state.activeSlice.title}`
     : "None";
 
-  lines.push(`**Active Milestone:** ${activeMilestone}`);
+  if (state.phase === 'complete' && state.lastCompletedMilestone) {
+    lines.push(`**Last Completed Milestone:** ${state.lastCompletedMilestone.id}: ${state.lastCompletedMilestone.title}`);
+  } else {
+    const activeMilestone = state.activeMilestone
+      ? `${state.activeMilestone.id}: ${state.activeMilestone.title}`
+      : "None";
+    lines.push(`**Active Milestone:** ${activeMilestone}`);
+  }
   lines.push(`**Active Slice:** ${activeSlice}`);
   lines.push(`**Phase:** ${state.phase}`);
   if (state.requirements) {