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

package/dist/resources/extensions/gsd/tools/complete-task.js

@@ -15,79 +15,41 @@ import { checkOwnership, taskUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
 import { renderPlanCheckboxes } from "../markdown-renderer.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { renderAllProjections, renderSummaryContent } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 /**
- * Render task summary markdown matching the template format.
- * YAML frontmatter uses snake_case keys for parseSummary() compatibility.
+ * Build a TaskRow-shaped object from CompleteTaskParams so the unified
+ * renderSummaryContent() can be used at completion time (#2720).
  */
-function renderSummaryMarkdown(params) {
-    const now = new Date().toISOString();
-    const keyFilesYaml = params.keyFiles.length > 0
-        ? params.keyFiles.map(f => `  - ${f}`).join("\n")
-        : "  - (none)";
-    const keyDecisionsYaml = params.keyDecisions.length > 0
-        ? params.keyDecisions.map(d => `  - ${d}`).join("\n")
-        : "  - (none)";
-    // Build verification evidence table rows
-    let evidenceTable = "| # | Command | Exit Code | Verdict | Duration |\n|---|---------|-----------|---------|----------|\n";
-    if (params.verificationEvidence.length > 0) {
-        params.verificationEvidence.forEach((e, i) => {
-            evidenceTable += `| ${i + 1} | \`${e.command}\` | ${e.exitCode} | ${e.verdict} | ${e.durationMs}ms |\n`;
-        });
-    }
-    else {
-        evidenceTable += "| — | No verification commands discovered | — | — | — |\n";
-    }
-    // Determine verification_result from evidence
-    const allPassed = params.verificationEvidence.length > 0 &&
-        params.verificationEvidence.every(e => e.exitCode === 0 || e.verdict.includes("✅") || e.verdict.toLowerCase().includes("pass"));
-    const verificationResult = allPassed ? "passed" : (params.verificationEvidence.length === 0 ? "untested" : "mixed");
-    // Extract a title from the oneLiner or taskId
-    const title = params.oneLiner || params.taskId;
-    return `---
-id: ${params.taskId}
-parent: ${params.sliceId}
-milestone: ${params.milestoneId}
-key_files:
-${keyFilesYaml}
-key_decisions:
-${keyDecisionsYaml}
-duration: ""
-verification_result: ${verificationResult}
-completed_at: ${now}
-blocker_discovered: ${params.blockerDiscovered}
----
-
-# ${params.taskId}: ${title}
-
-**${params.oneLiner}**
-
-## What Happened
-
-${params.narrative}
-
-## Verification
-
-${params.verification}
-
-## Verification Evidence
-
-${evidenceTable}
-
-## Deviations
-
-${params.deviations || "None."}
-
-## Known Issues
-
-${params.knownIssues || "None."}
-
-## Files Created/Modified
-
-${params.keyFiles.map(f => `- \`${f}\``).join("\n") || "None."}
-`;
+function paramsToTaskRow(params, completedAt) {
+    return {
+        milestone_id: params.milestoneId,
+        slice_id: params.sliceId,
+        id: params.taskId,
+        title: params.oneLiner || params.taskId,
+        status: "complete",
+        one_liner: params.oneLiner,
+        narrative: params.narrative,
+        verification_result: params.verification,
+        duration: "",
+        completed_at: completedAt,
+        blocker_discovered: params.blockerDiscovered,
+        deviations: params.deviations,
+        known_issues: params.knownIssues,
+        key_files: params.keyFiles,
+        key_decisions: params.keyDecisions,
+        full_summary_md: "",
+        description: "",
+        estimate: "",
+        files: [],
+        verify: "",
+        inputs: [],
+        expected_output: [],
+        observability_impact: "",
+        full_plan_md: "",
+        sequence: 0,
+    };
 }
 /**
  * Handle the complete_task operation end-to-end.
@@ -174,8 +136,9 @@ export async function handleCompleteTask(params, basePath) {
     // ── Filesystem operations (outside transaction) ─────────────────────────
     // If disk render fails, roll back the DB status so deriveState() and
     // verifyExpectedArtifact() stay consistent (both say "not done").
-    // Render summary markdown
-    const summaryMd = renderSummaryMarkdown(params);
+    // Render summary markdown via the single source of truth (#2720)
+    const taskRow = paramsToTaskRow(params, completedAt);
+    const summaryMd = renderSummaryContent(taskRow, params.sliceId, params.milestoneId, params.verificationEvidence);
     // Resolve and write summary to disk
     let summaryPath;
     const tasksDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);

package/dist/resources/extensions/gsd/tools/plan-milestone.js

@@ -1,7 +1,7 @@
 import { clearParseCache } from "../files.js";
 import { isClosedStatus } from "../status-guards.js";
 import { isNonEmptyString, validateStringArray } from "../validation.js";
-import { transaction, getMilestone, insertMilestone, insertSlice, upsertMilestonePlanning, upsertSlicePlanning, } from "../gsd-db.js";
+import { transaction, getMilestone, getMilestoneSlices, insertMilestone, insertSlice, upsertMilestonePlanning, upsertSlicePlanning, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
@@ -146,6 +146,16 @@ export async function handlePlanMilestone(rawParams, basePath) {
                 guardError = `cannot re-plan milestone ${params.milestoneId}: it is already complete`;
                 return;
             }
+            // Guard: refuse to re-plan a milestone that has completed slices (#2960).
+            // INSERT OR IGNORE on slices won't overwrite existing rows, but a full
+            // re-plan after worktree recreation or DB resync can create new slice rows
+            // that shadow completed work. Block early when any slice is already done.
+            const existingSlices = getMilestoneSlices(params.milestoneId);
+            const completedSlices = existingSlices.filter(s => isClosedStatus(s.status));
+            if (completedSlices.length > 0) {
+                guardError = `cannot re-plan milestone ${params.milestoneId}: ${completedSlices.length} slice(s) already completed (${completedSlices.map(s => s.id).join(", ")}). Use gsd_reassess_roadmap to modify the roadmap.`;
+                return;
+            }
             // Validate depends_on: all dependencies must exist and be complete
             if (params.dependsOn && params.dependsOn.length > 0) {
                 for (const depId of params.dependsOn) {
@@ -178,7 +188,7 @@ export async function handlePlanMilestone(rawParams, basePath) {
                 definitionOfDone: params.definitionOfDone,
                 requirementCoverage: params.requirementCoverage,
                 boundaryMapMarkdown: params.boundaryMapMarkdown,
-            });
+            }, params.title);
             for (const slice of params.slices) {
                 insertSlice({
                     id: slice.sliceId,

package/dist/resources/extensions/gsd/tools/reassess-roadmap.js

@@ -1,8 +1,9 @@
 import { join } from "node:path";
+import { existsSync, unlinkSync } from "node:fs";
 import { clearParseCache } from "../files.js";
 import { isClosedStatus } from "../status-guards.js";
 import { isNonEmptyString } from "../validation.js";
-import { transaction, getMilestone, getMilestoneSlices, getSlice, insertSlice, updateSliceFields, insertAssessment, deleteSlice, } from "../gsd-db.js";
+import { transaction, getMilestone, getMilestoneSlices, getSlice, insertSlice, updateSliceFields, insertAssessment, deleteAssessmentByScope, deleteSlice, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapFromDb, renderAssessmentFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
@@ -143,6 +144,18 @@ export async function handleReassessRoadmap(rawParams, basePath) {
             for (const removedId of params.sliceChanges.removed) {
                 deleteSlice(params.milestoneId, removedId);
             }
+            // ── Invalidate stale milestone validation (#2957) ──────────────
+            // When roadmap structure changes (slices added/modified/removed),
+            // any prior milestone-validation verdict is stale. Delete the DB
+            // row so deriveState() returns phase: 'validating-milestone' once
+            // the new slices complete, rather than advancing directly to
+            // 'completing-milestone' with a stale needs-remediation verdict.
+            const hasStructuralChanges = params.sliceChanges.added.length > 0 ||
+                params.sliceChanges.modified.length > 0 ||
+                params.sliceChanges.removed.length > 0;
+            if (hasStructuralChanges) {
+                deleteAssessmentByScope(params.milestoneId, "milestone-validation");
+            }
         });
     }
     catch (err) {
@@ -159,6 +172,21 @@ export async function handleReassessRoadmap(rawParams, basePath) {
             assessment: params.assessment,
             completedSliceId: params.completedSliceId,
         });
+        // ── Remove stale VALIDATION file from disk (#2957) ────────────
+        const hasStructuralChanges = params.sliceChanges.added.length > 0 ||
+            params.sliceChanges.modified.length > 0 ||
+            params.sliceChanges.removed.length > 0;
+        if (hasStructuralChanges) {
+            const validationFile = join(basePath, ".gsd", "milestones", params.milestoneId, `${params.milestoneId}-VALIDATION.md`);
+            try {
+                if (existsSync(validationFile))
+                    unlinkSync(validationFile);
+            }
+            catch {
+                // Best-effort: DB row is already deleted, so state derivation
+                // will not see the file-based verdict as authoritative.
+            }
+        }
         // ── Invalidate caches ─────────────────────────────────────────
         invalidateStateCache();
         clearParseCache();

package/dist/resources/extensions/gsd/tools/validate-milestone.js

@@ -1,15 +1,20 @@
 /**
  * validate-milestone handler — the core operation behind gsd_validate_milestone.
  *
- * Persists milestone validation results to the assessments table,
- * renders VALIDATION.md to disk, and invalidates caches.
+ * Persists milestone validation results to the assessments table and
+ * quality_gates table, renders VALIDATION.md to disk, and invalidates caches.
+ *
+ * #2945 Bug 4: Previously only wrote to assessments — quality_gates records
+ * were never persisted, causing M002+ milestones to have zero gate records
+ * despite passing validation.
  */
 import { join } from "node:path";
-import { transaction, insertAssessment, deleteAssessmentByScope, } from "../gsd-db.js";
+import { transaction, insertAssessment, deleteAssessmentByScope, getMilestoneSlices, } from "../gsd-db.js";
 import { resolveMilestonePath, clearPathCache } from "../paths.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
 import { VALIDATION_VERDICTS, isValidMilestoneVerdict } from "../verdict-parser.js";
+import { insertMilestoneValidationGates } from "../milestone-validation-gates.js";
 function renderValidationMarkdown(params) {
     let md = `---
 verdict: ${params.verdict}
@@ -77,6 +82,12 @@ export async function handleValidateMilestone(params, basePath) {
             scope: 'milestone-validation',
             fullContent: validationMd,
         });
+        // #2945 Bug 4: persist quality_gates records alongside the assessment.
+        // Previously only the assessment was written, leaving M002+ milestones
+        // with zero quality_gate records despite passing validation.
+        const slices = getMilestoneSlices(params.milestoneId);
+        const sliceId = slices.length > 0 ? slices[0].id : "_milestone";
+        insertMilestoneValidationGates(params.milestoneId, sliceId, params.verdict, validatedAt);
     });
     // ── Filesystem render (outside transaction) ────────────────────────────
     // If disk render fails, roll back the DB row so state stays consistent.

package/dist/resources/extensions/gsd/triage-resolution.js

@@ -14,7 +14,7 @@ import { join } from "node:path";
 import { createRequire } from "node:module";
 import { gsdRoot, milestonesDir } from "./paths.js";
 import { MILESTONE_ID_RE } from "./milestone-ids.js";
-import { loadAllCaptures, loadActionableCaptures, markCaptureExecuted, } from "./captures.js";
+import { loadAllCaptures, loadActionableCaptures, markCaptureExecuted, stampCaptureMilestone, } from "./captures.js";
 // ─── Resolution Executors ─────────────────────────────────────────────────────
 /**
  * Inject a new task into the current slice plan.
@@ -209,11 +209,15 @@ export function buildQuickTaskPrompt(capture) {
         ``,
         `## Instructions`,
         ``,
-        `1. Execute this task as a small, self-contained change.`,
-        `2. Do NOT modify any \`.gsd/\` plan files — this is a one-off, not a planned task.`,
-        `3. Commit your changes with a descriptive message.`,
-        `4. Keep changes minimal and focused on the capture text.`,
-        `5. When done, say: "Quick task complete."`,
+        `1. **Verify the issue still exists.** Before making any changes, inspect the`,
+        `   relevant code to confirm the problem described above is actually present in`,
+        `   the current codebase. If the issue has already been fixed (e.g., by planned`,
+        `   milestone work), report "Already resolved — no changes needed." and stop.`,
+        `2. Execute this task as a small, self-contained change.`,
+        `3. Do NOT modify any \`.gsd/\` plan files — this is a one-off, not a planned task.`,
+        `4. Commit your changes with a descriptive message.`,
+        `5. Keep changes minimal and focused on the capture text.`,
+        `6. When done, say: "Quick task complete."`,
     ].join("\n");
 }
 /**
@@ -238,7 +242,18 @@ export function executeTriageResolutions(basePath, mid, sid) {
         quickTasks: [],
         actions: [],
     };
-    const actionable = loadActionableCaptures(basePath);
+    const actionable = loadActionableCaptures(basePath, mid || undefined);
+    // Reconciliation: stamp actionable captures that are missing the Milestone field
+    // with the current milestone ID.  This covers captures resolved by the triage LLM
+    // before the prompt included the Milestone instruction, and acts as a safety net
+    // when the LLM omits the field (#2872).
+    if (mid) {
+        for (const capture of actionable) {
+            if (!capture.resolvedInMilestone) {
+                stampCaptureMilestone(basePath, capture.id, mid);
+            }
+        }
+    }
     // Also process deferred captures that target milestone IDs — create
     // milestone directories so deriveState() discovers them.
     const deferred = loadAllCaptures(basePath).filter(c => c.status === "resolved" && !c.executed && c.classification === "defer");

package/dist/resources/extensions/gsd/undo.js

@@ -3,7 +3,7 @@
 // handleUndoTask: Reset a single task's DB status to "pending" and re-render markdown.
 // handleResetSlice: Reset a slice and all its tasks, re-rendering plan + roadmap.
 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";
@@ -124,7 +124,7 @@ export async function handleUndo(args, ctx, _pi, basePath) {
         results.push(`  Review with 'git diff --cached' then 'git commit' or 'git reset HEAD'`);
     }
     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/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.