gsd-pi 2.57.0 → 2.58.0-dev.778d6ac

package/dist/resources/extensions/gsd/unit-ownership.js

@@ -3,17 +3,112 @@
 //
 // 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);
+let providerName = null;
+let providerModule = null;
+let loadAttempted = false;
+function suppressSqliteWarning() {
+    const origEmit = process.emit;
+    // @ts-expect-error overriding process.emit for warning filter
+    process.emit = function (event, ...args) {
+        if (event === "warning" &&
+            args[0] &&
+            typeof args[0] === "object" &&
+            "name" in args[0] &&
+            args[0].name === "ExperimentalWarning" &&
+            "message" in args[0] &&
+            typeof args[0].message === "string" &&
+            args[0].message.includes("SQLite")) {
+            return false;
+        }
+        return origEmit.apply(process, [event, ...args]);
+    };
+}
+function loadProvider() {
+    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) {
+    if (row == null)
+        return undefined;
+    if (Object.getPrototypeOf(row) === null) {
+        return { ...row };
+    }
+    return row;
+}
+function openRawDb(path) {
+    loadProvider();
+    if (!providerModule || !providerName)
+        return null;
+    if (providerName === "node:sqlite") {
+        const { DatabaseSync } = providerModule;
+        return new DatabaseSync(path);
+    }
+    const Database = providerModule;
+    return new Database(path);
+}
+function wrapDb(rawDb) {
+    const db = rawDb;
+    return {
+        exec(sql) { db.exec(sql); },
+        prepare(sql) {
+            const raw = db.prepare(sql);
+            return {
+                run(...params) { return raw.run(...params); },
+                get(...params) {
+                    return normalizeRow(raw.get(...params));
+                },
+            };
+        },
+        close() { db.close(); },
+    };
+}
+// ─── Per-basePath DB pool ────────────────────────────────────────────────
+const dbPool = new Map();
+function claimsDbPath(basePath) {
+    return join(basePath, ".gsd", "unit-claims.db");
+}
+function getDb(basePath) {
+    const existing = dbPool.get(basePath);
+    if (existing)
+        return existing;
+    return null;
+}
 // ─── Key Builders ────────────────────────────────────────────────────────
 export function taskUnitKey(milestoneId, sliceId, taskId) {
     return `${milestoneId}/${sliceId}/${taskId}`;
@@ -21,56 +116,92 @@ export function taskUnitKey(milestoneId, sliceId, taskId) {
 export function sliceUnitKey(milestoneId, sliceId) {
     return `${milestoneId}/${sliceId}`;
 }
-// ─── File Path ───────────────────────────────────────────────────────────
-function claimsPath(basePath) {
-    return join(basePath, ".gsd", "unit-claims.json");
+// ─── Lifecycle ───────────────────────────────────────────────────────────
+/**
+ * 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) {
+    if (dbPool.has(basePath))
+        return;
+    const dir = join(basePath, ".gsd");
+    mkdirSync(dir, { recursive: true });
+    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);
 }
-// ─── Read Claims ─────────────────────────────────────────────────────────
-function readClaims(basePath) {
-    const path = claimsPath(basePath);
-    if (!existsSync(path))
-        return null;
+/**
+ * Close the ownership database for a given basePath.
+ * Safe to call even if not initialized.
+ */
+export function closeOwnershipDb(basePath) {
+    const db = dbPool.get(basePath);
+    if (!db)
+        return;
     try {
-        return JSON.parse(readFileSync(path, "utf-8"));
-    }
-    catch {
-        return null;
+        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, unitKey, agentName) {
-    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");
+    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;
+    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, unitKey) {
-    const claims = readClaims(basePath);
-    if (!claims || !(unitKey in claims))
+    const db = getDb(basePath);
+    if (!db)
         return;
-    delete claims[unitKey];
-    atomicWriteSync(claimsPath(basePath), JSON.stringify(claims, null, 2) + "\n");
+    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, unitKey) {
-    const claims = readClaims(basePath);
-    if (!claims)
+    const db = getDb(basePath);
+    if (!db)
         return null;
-    return claims[unitKey]?.agent ?? null;
+    const row = db.prepare("SELECT agent_name FROM unit_claims WHERE unit_key = ?").get(unitKey);
+    return row?.agent_name ?? 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(basePath, unitKey, actorName) {
@@ -78,7 +209,7 @@ export function checkOwnership(basePath, unitKey, 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
+        return null; // unit unclaimed
     if (owner === actorName)
         return null; // actor is the owner
     return `Unit ${unitKey} is owned by ${owner}, not ${actorName}`;

package/dist/resources/extensions/gsd/verdict-parser.js

@@ -16,16 +16,28 @@ import { extractUatType } from "./files.js";
  * Returns `undefined` when frontmatter is absent or has no `verdict` field.
  */
 export function extractVerdict(content) {
+    // Primary: YAML frontmatter verdict (canonical format)
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
-    if (!fmMatch)
+    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;
-    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;
+    }
+    // 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;
 }
 /**
  * Returns `true` when the content's frontmatter contains a `verdict` field.

package/dist/resources/extensions/gsd/workflow-manifest.js

@@ -9,6 +9,25 @@ function requireDb() {
         throw new Error("workflow-manifest: No database open");
     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, fallback = 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 ───────────────────────────────────────────────────────
 /**
  * Capture complete DB state as a StateManifest.
@@ -62,7 +81,7 @@ export function snapshotState() {
             proof_level: r["proof_level"] ?? "",
             integration_closure: r["integration_closure"] ?? "",
             observability_impact: r["observability_impact"] ?? "",
-            sequence: r["sequence"] ?? 0,
+            sequence: toNumeric(r["sequence"], 0),
             replan_triggered_at: r["replan_triggered_at"] ?? null,
         }));
         const rawTasks = db.prepare("SELECT * FROM tasks ORDER BY milestone_id, slice_id, sequence, id").all();
@@ -91,11 +110,11 @@ export function snapshotState() {
             expected_output: JSON.parse(r["expected_output"] || "[]"),
             observability_impact: r["observability_impact"] ?? "",
             full_plan_md: r["full_plan_md"] ?? "",
-            sequence: r["sequence"] ?? 0,
+            sequence: toNumeric(r["sequence"], 0),
         }));
         const rawDecisions = db.prepare("SELECT * FROM decisions ORDER BY seq").all();
         const decisions = rawDecisions.map((r) => ({
-            seq: r["seq"],
+            seq: toNumeric(r["seq"], 0),
             id: r["id"],
             when_context: r["when_context"] ?? "",
             scope: r["scope"] ?? "",
@@ -113,9 +132,9 @@ export function snapshotState() {
             slice_id: r["slice_id"],
             milestone_id: r["milestone_id"],
             command: r["command"],
-            exit_code: r["exit_code"] ?? null,
+            exit_code: toNumeric(r["exit_code"]),
             verdict: r["verdict"] ?? "",
-            duration_ms: r["duration_ms"] ?? null,
+            duration_ms: toNumeric(r["duration_ms"]),
             created_at: r["created_at"],
         }));
         const result = {

package/dist/resources/extensions/gsd/workflow-projections.js

@@ -1,7 +1,7 @@
 // GSD Extension — Projection Renderers (DB -> Markdown)
 // Renders PLAN.md, ROADMAP.md, SUMMARY.md, and STATE.md from database rows.
 // Projections are read-only views of engine state (Layer 3 of the architecture).
-import { _getAdapter, isDbAvailable, getMilestone, getMilestoneSlices, getSliceTasks, } from "./gsd-db.js";
+import { _getAdapter, isDbAvailable, getMilestone, getMilestoneSlices, getSliceTasks, getVerificationEvidence, } from "./gsd-db.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { join } from "node:path";
 import { mkdirSync, existsSync } from "node:fs";
@@ -16,8 +16,10 @@ export function renderPlanContent(sliceRow, taskRows) {
     const lines = [];
     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");
     for (const task of taskRows) {
@@ -85,7 +87,10 @@ export function renderRoadmapContent(milestoneRow, sliceRows) {
             depends = slice.depends.join(", ");
         }
         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} |`);
     }
     lines.push("");
@@ -108,64 +113,85 @@ export function renderRoadmapProjection(basePath, milestoneId) {
 // ─── SUMMARY.md Projection ──────────────────────────────────────────────
 /**
  * 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, sliceId, milestoneId) {
-    const lines = [];
-    // 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 {
-        lines.push("key_files: []");
-    }
-    // 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(", ")}]`);
+export function renderSummaryContent(taskRow, sliceId, milestoneId, evidence) {
+    // ── 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_decisions: []");
-    }
-    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("");
-    // One-liner (if present)
-    if (taskRow.one_liner) {
-        lines.push(`> ${taskRow.one_liner}`);
-        lines.push("");
+        evidenceTable += "| \u2014 | No verification commands discovered | \u2014 | \u2014 | \u2014 |\n";
     }
-    lines.push("## What Happened");
-    lines.push(taskRow.full_summary_md || taskRow.narrative || "No summary recorded.");
-    lines.push("");
-    // Deviations (if present)
-    if (taskRow.deviations) {
-        lines.push("## Deviations");
-        lines.push(taskRow.deviations);
-        lines.push("");
-    }
-    // Known issues (if present)
-    if (taskRow.known_issues) {
-        lines.push("## Known Issues");
-        lines.push(taskRow.known_issues);
-        lines.push("");
-    }
-    return lines.join("\n");
+    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
+
+${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."}
+`;
 }
 /**
  * Render SUMMARY.md projection to disk for a specific task.
@@ -176,7 +202,8 @@ export function renderSummaryProjection(basePath, milestoneId, sliceId, taskId)
     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);
@@ -190,13 +217,18 @@ export function renderSummaryProjection(basePath, milestoneId, sliceId, taskId)
 export function renderStateContent(state) {
     const lines = [];
     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) {

package/dist/resources/extensions/gsd/workflow-reconcile.js

@@ -1,10 +1,39 @@
 import { join } from "node:path";
 import { mkdirSync, existsSync, readFileSync, unlinkSync } from "node:fs";
+import { logWarning, logError } from "./workflow-logger.js";
 import { readEvents, findForkPoint, appendEvent, getSessionId } from "./workflow-events.js";
-import { transaction, updateTaskStatus, updateSliceStatus, insertVerificationEvidence, upsertDecision, openDatabase, } from "./gsd-db.js";
+import { transaction, updateTaskStatus, updateSliceStatus, getSliceTasks, insertVerificationEvidence, upsertDecision, openDatabase, } from "./gsd-db.js";
+import { isClosedStatus } from "./status-guards.js";
 import { writeManifest } from "./workflow-manifest.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { acquireSyncLock, releaseSyncLock } from "./sync-lock.js";
+// ─── Replay Helpers ──────────────────────────────────────────────────────────
+/**
+ * Replay a complete_slice event with task validation.
+ *
+ * #2945 Bug 2: The original replay blindly called updateSliceStatus("done")
+ * without checking whether all tasks in the slice are actually complete.
+ * During API overload or partial execution, a complete_slice event could
+ * be logged even when tasks were skipped, causing the milestone completion
+ * guard to see the slice as "done" and allow premature milestone completion.
+ *
+ * This function validates that every task in the slice has a closed status
+ * before marking the slice as done. If any task is still pending, the slice
+ * status is left unchanged.
+ */
+export function replaySliceComplete(milestoneId, sliceId, ts) {
+    const tasks = getSliceTasks(milestoneId, sliceId);
+    // If there are tasks and any are not closed, skip the status update
+    if (tasks.length > 0) {
+        const incompleteTasks = tasks.filter(t => !isClosedStatus(t.status));
+        if (incompleteTasks.length > 0) {
+            process.stderr.write(`[gsd] reconcile: skipping complete_slice replay for ${sliceId} — ` +
+                `${incompleteTasks.length} task(s) still pending\n`);
+            return;
+        }
+    }
+    updateSliceStatus(milestoneId, sliceId, "done", ts);
+}
 // ─── replayEvents ─────────────────────────────────────────────────────────────
 /**
  * Replay a list of WorkflowEvents by dispatching each to the appropriate
@@ -58,7 +87,8 @@ function replayEvents(events) {
                 case "complete_slice": {
                     const milestoneId = p["milestoneId"];
                     const sliceId = p["sliceId"];
-                    updateSliceStatus(milestoneId, sliceId, "done", event.ts);
+                    // #2945 Bug 2: validate tasks before marking slice done
+                    replaySliceComplete(milestoneId, sliceId, event.ts);
                     break;
                 }
                 case "plan_slice": {
@@ -221,7 +251,7 @@ export function reconcileWorktreeLogs(mainBasePath, worktreeBasePath) {
     // Acquire advisory lock to prevent concurrent reconcile + append races
     const lock = acquireSyncLock(mainBasePath);
     if (!lock.acquired) {
-        process.stderr.write(`[gsd] reconcile: could not acquire sync lock — another reconciliation may be in progress\n`);
+        logWarning("reconcile", "could not acquire sync lock — another reconciliation may be in progress");
         return { autoMerged: 0, conflicts: [] };
     }
     try {
@@ -251,7 +281,7 @@ function _reconcileWorktreeLogsInner(mainBasePath, worktreeBasePath) {
     if (conflicts.length > 0) {
         // D-04: atomic all-or-nothing — block entire merge
         writeConflictsFile(mainBasePath, conflicts, worktreeBasePath);
-        process.stderr.write(`[gsd] reconcile: ${conflicts.length} conflict(s) detected — see ${join(mainBasePath, ".gsd", "CONFLICTS.md")}\n`);
+        logError("reconcile", `${conflicts.length} conflict(s) detected`, { count: String(conflicts.length), path: join(mainBasePath, ".gsd", "CONFLICTS.md") });
         return { autoMerged: 0, conflicts };
     }
     // Step 6: Clean merge — stable sort by timestamp (index-based tiebreaker)
@@ -272,7 +302,7 @@ function _reconcileWorktreeLogsInner(mainBasePath, worktreeBasePath) {
         writeManifest(mainBasePath);
     }
     catch (err) {
-        process.stderr.write(`[gsd] reconcile: manifest write failed (non-fatal): ${err.message}\n`);
+        logWarning("reconcile", "manifest write failed (non-fatal)", { error: err.message });
     }
     return { autoMerged: merged.length, conflicts: [] };
 }