gsd-pi 2.58.0-dev.778d6ac → 2.58.0-dev.d63175c

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

@@ -3,20 +3,18 @@
 //
 // An agent can claim a unit (task, slice) before working on it.
 // complete-task and complete-slice enforce ownership when claims exist.
-// Claims are stored in SQLite (.gsd/unit-claims.db) for atomic
-// first-writer-wins semantics via INSERT OR IGNORE.
+// If no claim file is present, ownership is not enforced (backward compatible).
 //
+// 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 { createRequire } from "node:module";
-import { mkdirSync } from "node:fs";
+import { existsSync, readFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
-
-const _require = createRequire(import.meta.url);
+import { atomicWriteSync } from "./atomic-write.js";
 
 // ─── Types ───────────────────────────────────────────────────────────────
 
@@ -25,133 +23,7 @@ export interface UnitClaim {
   claimed_at: string;
 }
 
-// ─── 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;
-}
+type ClaimsMap = Record<string, UnitClaim>;
 
 // ─── Key Builders ────────────────────────────────────────────────────────
 
@@ -163,103 +35,60 @@ export function sliceUnitKey(milestoneId: string, sliceId: string): string {
   return `${milestoneId}/${sliceId}`;
 }
 
-// ─── Lifecycle ───────────────────────────────────────────────────────────
+// ─── File Path ───────────────────────────────────────────────────────────
 
-/**
- * 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;
+function claimsPath(basePath: string): string {
+  return join(basePath, ".gsd", "unit-claims.json");
+}
 
-  const dir = join(basePath, ".gsd");
-  mkdirSync(dir, { recursive: true });
+// ─── Read Claims ─────────────────────────────────────────────────────────
 
-  const raw = openRawDb(claimsDbPath(basePath));
-  if (!raw) {
-    throw new Error("No SQLite provider available for unit-ownership");
+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 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.
- * 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.
+ * Overwrites any existing claim for this unit (last writer wins).
  */
-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;
+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");
 }
 
 /**
- * Release a unit claim (remove it from the claims table).
+ * Release a unit claim (remove it from the claims map).
  */
 export function releaseUnit(basePath: string, unitKey: string): void {
-  const db = getDb(basePath);
-  if (!db) return;
-  db.prepare("DELETE FROM unit_claims WHERE unit_key = ?").run(unitKey);
+  const claims = readClaims(basePath);
+  if (!claims || !(unitKey in claims)) return;
+  delete claims[unitKey];
+  atomicWriteSync(claimsPath(basePath), JSON.stringify(claims, null, 2) + "\n");
 }
 
 /**
- * Get the current owner of a unit, or null if unclaimed.
+ * Get the current owner of a unit, or null if unclaimed / no claims file.
  */
 export function getOwner(basePath: string, unitKey: string): string | 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;
+  const claims = readClaims(basePath);
+  if (!claims) return null;
+  return claims[unitKey]?.agent ?? null;
 }
 
 /**
  * Check if an actor is authorized to operate on a unit.
- * Returns null if ownership passes (or is unclaimed).
+ * Returns null if ownership passes (or is unclaimed / no file).
  * Returns an error string if a different agent owns the unit.
  */
 export function checkOwnership(
@@ -269,7 +98,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
+  if (owner === null) return null; // unit unclaimed or no claims file
   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,28 +20,13 @@ 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) {
-    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;
+  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;
 }
 
 /**

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

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

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

@@ -42,23 +42,6 @@ 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 ───────────────────────────────────────────────────────
 
 /**
@@ -116,7 +99,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: toNumeric(r["sequence"], 0) as number,
+    sequence: (r["sequence"] as number) ?? 0,
     replan_triggered_at: (r["replan_triggered_at"] as string) ?? null,
   }));
 
@@ -146,12 +129,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: toNumeric(r["sequence"], 0) as number,
+    sequence: (r["sequence"] as number) ?? 0,
   }));
 
   const rawDecisions = db.prepare("SELECT * FROM decisions ORDER BY seq").all() as Record<string, unknown>[];
   const decisions: Decision[] = rawDecisions.map((r) => ({
-    seq: toNumeric(r["seq"], 0) as number,
+    seq: r["seq"] as number,
     id: r["id"] as string,
     when_context: (r["when_context"] as string) ?? "",
     scope: (r["scope"] as string) ?? "",
@@ -170,9 +153,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: toNumeric(r["exit_code"]),
+    exit_code: (r["exit_code"] as number) ?? null,
     verdict: (r["verdict"] as string) ?? "",
-    duration_ms: toNumeric(r["duration_ms"]),
+    duration_ms: (r["duration_ms"] as number) ?? null,
     created_at: r["created_at"] as string,
   }));
 

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

@@ -9,9 +9,8 @@ import {
   getMilestone,
   getMilestoneSlices,
   getSliceTasks,
-  getVerificationEvidence,
 } from "./gsd-db.js";
-import type { MilestoneRow, SliceRow, TaskRow, VerificationEvidenceRow } from "./gsd-db.js";
+import type { MilestoneRow, SliceRow, TaskRow } from "./gsd-db.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { join } from "node:path";
 import { mkdirSync, existsSync } from "node:fs";
@@ -30,10 +29,8 @@ export function renderPlanContent(sliceRow: SliceRow, taskRows: TaskRow[]): stri
 
   lines.push(`# ${sliceRow.id}: ${sliceRow.title}`);
   lines.push("");
-  // #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(`**Goal:** ${sliceRow.goal || sliceRow.full_summary_md || "TBD"}`);
+  lines.push(`**Demo:** After this: ${sliceRow.demo || sliceRow.full_uat_md || "TBD"}`);
   lines.push("");
   lines.push("## Tasks");
 
@@ -116,10 +113,7 @@ export function renderRoadmapContent(milestoneRow: MilestoneRow, sliceRows: Slic
     }
 
     const risk = (slice.risk || "low").toLowerCase();
-    // #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";
+    const demo = slice.demo || slice.full_uat_md || "TBD";
 
     lines.push(`| ${slice.id} | ${slice.title} | ${risk} | ${depends} | ${done} | ${demo} |`);
   }
@@ -148,93 +142,71 @@ export function renderRoadmapProjection(basePath: string, milestoneId: string):
 
 /**
  * Render SUMMARY.md content from a task row.
- * 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.
+ * Pure function — no side effects.
  */
-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`;
-    });
+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(", ")}]`);
   } else {
-    evidenceTable += "| \u2014 | No verification commands discovered | \u2014 | \u2014 | \u2014 |\n";
+    lines.push("key_files: []");
   }
 
-  const title = taskRow.one_liner || taskRow.title || taskRow.id;
-
-  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"}
----
-
-# ${taskRow.id}: ${title}
-
-**${taskRow.one_liner || ""}**
-
-## What Happened
-
-${taskRow.narrative || "No summary recorded."}
-
-## Verification
-
-${taskRow.verification_result || "No verification recorded."}
-
-## Verification Evidence
+  // 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: []");
+  }
 
-${evidenceTable}
-## Deviations
+  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("");
 
-${taskRow.deviations || "None."}
+  // One-liner (if present)
+  if (taskRow.one_liner) {
+    lines.push(`> ${taskRow.one_liner}`);
+    lines.push("");
+  }
 
-## Known Issues
+  lines.push("## What Happened");
+  lines.push(taskRow.full_summary_md || taskRow.narrative || "No summary recorded.");
+  lines.push("");
 
-${taskRow.known_issues || "None."}
+  // Deviations (if present)
+  if (taskRow.deviations) {
+    lines.push("## Deviations");
+    lines.push(taskRow.deviations);
+    lines.push("");
+  }
 
-## Files Created/Modified
+  // Known issues (if present)
+  if (taskRow.known_issues) {
+    lines.push("## Known Issues");
+    lines.push(taskRow.known_issues);
+    lines.push("");
+  }
 
-${taskRow.key_files && taskRow.key_files.length > 0 ? taskRow.key_files.map(f => `- \`${f}\``).join("\n") : "None."}
-`;
+  return lines.join("\n");
 }
 
 /**
@@ -246,8 +218,7 @@ export function renderSummaryProjection(basePath: string, milestoneId: string, s
   const taskRow = taskRows.find(t => t.id === taskId);
   if (!taskRow) return;
 
-  const evidenceRows = getVerificationEvidence(milestoneId, sliceId, taskId);
-  const content = renderSummaryContent(taskRow, sliceId, milestoneId, evidenceRows);
+  const content = renderSummaryContent(taskRow, sliceId, milestoneId);
   const dir = join(basePath, ".gsd", "milestones", milestoneId, "slices", sliceId, "tasks");
   mkdirSync(dir, { recursive: true });
   atomicWriteSync(join(dir, `${taskId}-SUMMARY.md`), content);
@@ -264,18 +235,14 @@ 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";
 
-  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 Milestone:** ${activeMilestone}`);
   lines.push(`**Active Slice:** ${activeSlice}`);
   lines.push(`**Phase:** ${state.phase}`);
   if (state.requirements) {