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

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

@@ -15,41 +15,79 @@ 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, renderSummaryContent } from "../workflow-projections.js";
+import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 /**
- * Build a TaskRow-shaped object from CompleteTaskParams so the unified
- * renderSummaryContent() can be used at completion time (#2720).
+ * Render task summary markdown matching the template format.
+ * YAML frontmatter uses snake_case keys for parseSummary() compatibility.
  */
-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,
-    };
+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."}
+`;
 }
 /**
  * Handle the complete_task operation end-to-end.
@@ -136,9 +174,8 @@ 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 via the single source of truth (#2720)
-    const taskRow = paramsToTaskRow(params, completedAt);
-    const summaryMd = renderSummaryContent(taskRow, params.sliceId, params.milestoneId, params.verificationEvidence);
+    // Render summary markdown
+    const summaryMd = renderSummaryMarkdown(params);
     // 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, getMilestoneSlices, insertMilestone, insertSlice, upsertMilestonePlanning, upsertSlicePlanning, } from "../gsd-db.js";
+import { transaction, getMilestone, 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,16 +146,6 @@ 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) {
@@ -188,7 +178,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,9 +1,8 @@
 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, deleteAssessmentByScope, deleteSlice, } from "../gsd-db.js";
+import { transaction, getMilestone, getMilestoneSlices, getSlice, insertSlice, updateSliceFields, insertAssessment, deleteSlice, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapFromDb, renderAssessmentFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
@@ -144,18 +143,6 @@ 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) {
@@ -172,21 +159,6 @@ 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,20 +1,15 @@
 /**
  * validate-milestone handler — the core operation behind gsd_validate_milestone.
  *
- * 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.
+ * Persists milestone validation results to the assessments table,
+ * renders VALIDATION.md to disk, and invalidates caches.
  */
 import { join } from "node:path";
-import { transaction, insertAssessment, deleteAssessmentByScope, getMilestoneSlices, } from "../gsd-db.js";
+import { transaction, insertAssessment, deleteAssessmentByScope, } 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}
@@ -82,12 +77,6 @@ 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, stampCaptureMilestone, } from "./captures.js";
+import { loadAllCaptures, loadActionableCaptures, markCaptureExecuted, } from "./captures.js";
 // ─── Resolution Executors ─────────────────────────────────────────────────────
 /**
  * Inject a new task into the current slice plan.
@@ -209,15 +209,11 @@ export function buildQuickTaskPrompt(capture) {
         ``,
         `## Instructions`,
         ``,
-        `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."`,
+        `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."`,
     ].join("\n");
 }
 /**
@@ -242,18 +238,7 @@ export function executeTriageResolutions(basePath, mid, sid) {
         quickTasks: [],
         actions: [],
     };
-    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);
-            }
-        }
-    }
+    const actionable = loadActionableCaptures(basePath);
     // 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, basename } from "node:path";
+import { join } 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", basename(basePath));
+    sendDesktopNotification("GSD", `Undone: ${unitType} (${unitId})`, "info", "complete");
 }
 // ─── Targeted State Reset ────────────────────────────────────────────────────
 /**

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

@@ -3,112 +3,17 @@
 //
 // 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);
-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;
-}
+import { atomicWriteSync } from "./atomic-write.js";
 // ─── Key Builders ────────────────────────────────────────────────────────
 export function taskUnitKey(milestoneId, sliceId, taskId) {
     return `${milestoneId}/${sliceId}/${taskId}`;
@@ -116,92 +21,56 @@ export function taskUnitKey(milestoneId, sliceId, taskId) {
 export function sliceUnitKey(milestoneId, sliceId) {
     return `${milestoneId}/${sliceId}`;
 }
-// ─── 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);
+// ─── File Path ───────────────────────────────────────────────────────────
+function claimsPath(basePath) {
+    return join(basePath, ".gsd", "unit-claims.json");
 }
-/**
- * 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;
+// ─── Read Claims ─────────────────────────────────────────────────────────
+function readClaims(basePath) {
+    const path = claimsPath(basePath);
+    if (!existsSync(path))
+        return null;
     try {
-        db.close();
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return null;
     }
-    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, unitKey, agentName) {
-    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;
+    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, unitKey) {
-    const db = getDb(basePath);
-    if (!db)
+    const claims = readClaims(basePath);
+    if (!claims || !(unitKey in claims))
         return;
-    db.prepare("DELETE FROM unit_claims WHERE unit_key = ?").run(unitKey);
+    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, unitKey) {
-    const db = getDb(basePath);
-    if (!db)
+    const claims = readClaims(basePath);
+    if (!claims)
         return null;
-    const row = db.prepare("SELECT agent_name FROM unit_claims WHERE unit_key = ?").get(unitKey);
-    return row?.agent_name ?? 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(basePath, unitKey, actorName) {
@@ -209,7 +78,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
+        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/dist/resources/extensions/gsd/verdict-parser.js

@@ -16,28 +16,16 @@ 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) {
-        const verdictMatch = fmMatch[1].match(/verdict:\s*([\w-]+)/i);
-        if (verdictMatch) {
-            let v = verdictMatch[1].toLowerCase();
-            if (v === "passed")
-                v = "pass";
-            return v;
-        }
+    if (!fmMatch)
         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;
+    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;
 }
 /**
  * Returns `true` when the content's frontmatter contains a `verdict` field.