gsd-pi 2.82.0 → 3.0.0-dev.04f5ccf82

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

@@ -0,0 +1,139 @@
+import { loadFile } from "./files.js";
+import { resolveMilestoneFile } from "./paths.js";
+import { deriveState } from "./state.js";
+import { executeValidateMilestone } from "./tools/workflow-tool-executors.js";
+import { VALIDATION_VERDICTS, extractVerdict, isValidMilestoneVerdict, } from "./verdict-parser.js";
+const USAGE = 'Usage: /gsd verdict <pass|needs-attention|needs-remediation> [--milestone Mxxx] [--rationale "..."]';
+function tokenize(raw) {
+    const tokens = [];
+    const re = /"([^"]*)"|(\S+)/g;
+    let match;
+    while ((match = re.exec(raw)) !== null) {
+        tokens.push(match[1] ?? match[2]);
+    }
+    return tokens;
+}
+function parseArgs(raw) {
+    const tokens = tokenize(raw);
+    const out = {};
+    for (let i = 0; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (t === "--milestone") {
+            const next = tokens[++i];
+            if (!next)
+                return { error: "--milestone requires a milestone ID" };
+            out.milestoneId = next;
+        }
+        else if (t === "--rationale") {
+            const next = tokens[++i];
+            if (next == null)
+                return { error: "--rationale requires a value" };
+            out.rationale = next;
+        }
+        else if (!out.verdict) {
+            if (!isValidMilestoneVerdict(t)) {
+                return {
+                    error: `Invalid verdict "${t}". Must be one of: ${VALIDATION_VERDICTS.join(", ")}`,
+                };
+            }
+            out.verdict = t;
+        }
+        else {
+            return { error: `Unexpected argument: ${t}` };
+        }
+    }
+    return out;
+}
+function extractRemediationRound(content) {
+    const fm = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fm)
+        return 0;
+    const m = fm[1].match(/^remediation_round:\s*(\d+)/im);
+    return m ? Number.parseInt(m[1], 10) : 0;
+}
+function extractSection(content, heading) {
+    const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    // Match section bodies bounded by the next "## " heading or end-of-string.
+    // Leading "\n" prefix lets a single pattern handle first-line headings too.
+    // No /m flag — we want `$` to mean end-of-string, not end-of-line.
+    const re = new RegExp(`\\n## ${escaped}\\s*\\n([\\s\\S]*?)(?=\\n## |$)`);
+    const m = ("\n" + content).match(re);
+    if (!m)
+        return undefined;
+    return m[1].replace(/\s+$/, "");
+}
+export function parseValidationFile(content) {
+    return {
+        verdict: extractVerdict(content),
+        remediationRound: extractRemediationRound(content),
+        successCriteriaChecklist: extractSection(content, "Success Criteria Checklist") ?? "",
+        sliceDeliveryAudit: extractSection(content, "Slice Delivery Audit") ?? "",
+        crossSliceIntegration: extractSection(content, "Cross-Slice Integration") ?? "",
+        requirementCoverage: extractSection(content, "Requirement Coverage") ?? "",
+        verificationClasses: extractSection(content, "Verification Class Compliance"),
+        verdictRationale: extractSection(content, "Verdict Rationale") ?? "",
+        remediationPlan: extractSection(content, "Remediation Plan"),
+    };
+}
+export async function handleVerdict(rawArgs, ctx, basePath) {
+    if (!rawArgs.trim()) {
+        ctx.ui.notify(USAGE, "warning");
+        return;
+    }
+    const parsed = parseArgs(rawArgs);
+    if ("error" in parsed) {
+        ctx.ui.notify(`${parsed.error}\n${USAGE}`, "warning");
+        return;
+    }
+    if (!parsed.verdict) {
+        ctx.ui.notify(USAGE, "warning");
+        return;
+    }
+    let milestoneId = parsed.milestoneId;
+    if (!milestoneId) {
+        const state = await deriveState(basePath);
+        if (!state.activeMilestone) {
+            ctx.ui.notify("No active milestone — pass --milestone Mxxx to target a specific milestone.", "warning");
+            return;
+        }
+        milestoneId = state.activeMilestone.id;
+    }
+    const validationPath = resolveMilestoneFile(basePath, milestoneId, "VALIDATION");
+    if (!validationPath) {
+        ctx.ui.notify(`No VALIDATION file found for ${milestoneId}. Run gsd_validate_milestone first to produce one.`, "warning");
+        return;
+    }
+    const existing = await loadFile(validationPath);
+    if (!existing) {
+        ctx.ui.notify(`Could not read VALIDATION file for ${milestoneId} (${validationPath}).`, "warning");
+        return;
+    }
+    const current = parseValidationFile(existing);
+    if (parsed.verdict !== "pass" && !parsed.rationale) {
+        ctx.ui.notify(`--rationale is required when overriding to ${parsed.verdict}.`, "warning");
+        return;
+    }
+    const verdictRationale = parsed.rationale ?? "Manually overridden via /gsd verdict";
+    const result = await executeValidateMilestone({
+        milestoneId,
+        verdict: parsed.verdict,
+        remediationRound: current.remediationRound,
+        successCriteriaChecklist: current.successCriteriaChecklist,
+        sliceDeliveryAudit: current.sliceDeliveryAudit,
+        crossSliceIntegration: current.crossSliceIntegration,
+        requirementCoverage: current.requirementCoverage,
+        verificationClasses: current.verificationClasses,
+        verdictRationale,
+        remediationPlan: current.remediationPlan,
+    }, basePath);
+    if (result.isError) {
+        const msg = result.content[0]?.type === "text" ? result.content[0].text : "Unknown error";
+        ctx.ui.notify(msg, "error");
+        return;
+    }
+    const prevVerdict = current.verdict ?? "unknown";
+    ctx.ui.notify(`Milestone ${milestoneId} verdict: ${prevVerdict} -> ${parsed.verdict}`, "success");
+    if (parsed.verdict === "needs-remediation") {
+        ctx.ui.notify("Follow up with gsd_reassess_roadmap to add remediation slices, then re-run /gsd auto.", "info");
+    }
+}

package/dist/resources/extensions/gsd/context-store.js

@@ -47,6 +47,118 @@ export function queryDecisions(opts) {
         return [];
     }
 }
+/**
+ * Internal: shared core for the two memory-sourced decision queries. Reads
+ * memory rows tagged with `sourceDecisionId` and reconstructs `Decision[]`
+ * from their `structured_fields` JSON.
+ *
+ * @param includeSuperseded — when false, drops rows whose
+ *   `structured_fields.superseded_by` is non-null. The supersedes-chain is
+ *   captured by the backfill (`memory-backfill.ts`) and kept in sync by
+ *   the backfill's drift auto-heal pass.
+ */
+function readDecisionsFromMemories(opts, includeSuperseded) {
+    if (!isDbAvailable())
+        return [];
+    const adapter = _getAdapter();
+    if (!adapter)
+        return [];
+    try {
+        const clauses = [
+            "category = 'architecture'",
+            "structured_fields LIKE '%\"sourceDecisionId\":\"%'",
+        ];
+        const params = {};
+        if (opts?.milestoneId) {
+            // when_context is a free-text JSON value; substring match preserves the
+            // semantics of `when_context LIKE '%milestoneId%'` on the legacy table.
+            clauses.push("json_extract(structured_fields, '$.when_context') LIKE :milestone_pattern");
+            params[':milestone_pattern'] = `%${opts.milestoneId}%`;
+        }
+        if (opts?.scope) {
+            // Stage 1 used `json_extract` in main (post-merge); preserve that
+            // style here. Exact equality on the JSON value avoids the prefix
+            // collision risk LIKE patterns had (scope=M001 vs scope=M001-S01).
+            clauses.push("json_extract(structured_fields, '$.scope') = :scope");
+            params[':scope'] = opts.scope;
+        }
+        const sql = `SELECT seq, structured_fields FROM memories WHERE ${clauses.join(' AND ')} ORDER BY seq`;
+        const rows = adapter.prepare(sql).all(params);
+        const decisions = [];
+        for (const row of rows) {
+            const seq = row['seq'];
+            const sfRaw = row['structured_fields'];
+            if (!sfRaw)
+                continue;
+            let sf;
+            try {
+                sf = JSON.parse(sfRaw);
+            }
+            catch {
+                continue;
+            }
+            const sourceId = sf['sourceDecisionId'];
+            if (typeof sourceId !== 'string' || sourceId.length === 0)
+                continue;
+            // Decision-level superseded status lives in structured_fields.superseded_by
+            // (written by mirrorDecisionToMemory / memory-backfill.ts). The top-level
+            // memories.superseded_by column is intentionally never set for decision mirrors,
+            // so active-only filtering must be done here in the JS loop.
+            const supersededBy = typeof sf['superseded_by'] === 'string' ? sf['superseded_by'] : null;
+            if (!includeSuperseded && supersededBy)
+                continue;
+            decisions.push({
+                seq,
+                id: sourceId,
+                when_context: typeof sf['when_context'] === 'string' ? sf['when_context'] : '',
+                scope: typeof sf['scope'] === 'string' ? sf['scope'] : '',
+                decision: typeof sf['decision'] === 'string' ? sf['decision'] : '',
+                choice: typeof sf['choice'] === 'string' ? sf['choice'] : '',
+                rationale: typeof sf['rationale'] === 'string' ? sf['rationale'] : '',
+                revisable: typeof sf['revisable'] === 'string' ? sf['revisable'] : '',
+                made_by: (typeof sf['made_by'] === 'string' ? sf['made_by'] : 'agent'),
+                superseded_by: supersededBy,
+            });
+        }
+        return decisions;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * ADR-013 Phase 6 cutover (Stage 1): read **active** decisions from the
+ * `memories` table instead of the legacy `decisions` table. Returns the
+ * same `Decision[]` shape as `queryDecisions` so downstream formatters
+ * work unchanged.
+ *
+ * Filter semantics match `queryDecisions` exactly:
+ * - active only (skips rows where `structured_fields.superseded_by` is set)
+ * - `milestoneId`: substring match on `structured_fields.when_context`
+ * - `scope`: exact match on `structured_fields.scope`
+ *
+ * Used by the prompt-inline path (`inlineDecisionsFromDb` in
+ * `auto-prompts.ts`). For the projection regen (which renders superseded
+ * rows too), see `getAllDecisionsFromMemories`.
+ */
+export function queryDecisionsFromMemories(opts) {
+    return readDecisionsFromMemories(opts, /* includeSuperseded */ false);
+}
+/**
+ * ADR-013 Phase 6 cutover (Stage 2a): read **all** decisions (active +
+ * superseded) from the `memories` table. Used by the DECISIONS.md
+ * projection regen in `saveDecisionToDb`, which must render the full
+ * supersedes-chain for the canonical register format.
+ *
+ * Equivalent to `SELECT * FROM decisions ORDER BY seq` over the legacy
+ * table — but sourced from memories so the legacy table can be retired
+ * in Stage 3. Includes `superseded_by` reconstructed from
+ * `structured_fields.superseded_by` (populated by the backfill's drift
+ * auto-heal pass).
+ */
+export function getAllDecisionsFromMemories() {
+    return readDecisionsFromMemories(undefined, /* includeSuperseded */ true);
+}
 /**
  * Query active (non-superseded) requirements with optional filters.
  * - milestoneId: combined with sliceId for precise filtering (e.g. %M005/S01%)

package/dist/resources/extensions/gsd/crash-recovery.js

@@ -23,7 +23,9 @@
 import { emitJournalEvent, queryJournal, } from "./journal.js";
 import { readFileSync, unlinkSync, existsSync } from "node:fs";
 import { join } from "node:path";
-import { findStaleWorkerForProject, getAllAutoWorkers, } from "./db/auto-workers.js";
+import { findStaleWorkerForProject, getAllAutoWorkers, markWorkerCrashed, markWorkerStopping, markWorkerStoppingByPid, } from "./db/auto-workers.js";
+import { forceReleaseLeasesForWorker } from "./db/milestone-leases.js";
+import { markLatestActiveForWorkerCanceled } from "./db/unit-dispatches.js";
 import { getRuntimeKv, setRuntimeKv, deleteRuntimeKv } from "./db/runtime-kv.js";
 import { _getAdapter, isDbAvailable } from "./gsd-db.js";
 import { gsdRoot, normalizeRealPath } from "./paths.js";
@@ -34,6 +36,16 @@ const SESSION_FILE_KV_KEY = "session_file";
 function lockPath(basePath) {
     return join(gsdRoot(basePath), effectiveLockFile());
 }
+function clearLegacyLockFile(basePath) {
+    try {
+        const p = lockPath(basePath);
+        if (existsSync(p))
+            unlinkSync(p);
+    }
+    catch {
+        // Best-effort.
+    }
+}
 function readLegacyLock(basePath) {
     try {
         const p = lockPath(basePath);
@@ -145,14 +157,21 @@ export function writeLock(basePath, unitType, unitId, sessionFile) {
     catch {
         // Best-effort — never throw from the lock writer.
     }
-    if (!isDbAvailable() || !sessionFile)
+    if (!isDbAvailable())
         return;
     try {
         const projectRoot = normalizeRealPath(basePath);
         const worker = findActiveWorkerForCurrentProcess(projectRoot);
         if (!worker)
             return;
-        setRuntimeKv("worker", worker.worker_id, SESSION_FILE_KV_KEY, sessionFile);
+        if (sessionFile) {
+            setRuntimeKv("worker", worker.worker_id, SESSION_FILE_KV_KEY, sessionFile);
+        }
+        else {
+            // Preliminary unit locks (before runUnit/newSession settles) must clear
+            // any prior pointer so crash recovery cannot ingest stale cross-unit context.
+            deleteRuntimeKv("worker", worker.worker_id, SESSION_FILE_KV_KEY);
+        }
     }
     catch {
         // Best-effort — never throw from the lock writer.
@@ -166,21 +185,50 @@ export function writeLock(basePath, unitType, unitId, sessionFile) {
  * stale session-file pointer.
  */
 export function clearLock(basePath) {
+    clearLegacyLockFile(basePath);
+    if (!isDbAvailable())
+        return;
     try {
-        const p = lockPath(basePath);
-        if (existsSync(p))
-            unlinkSync(p);
+        const projectRoot = normalizeRealPath(basePath);
+        const staleWorker = findStaleWorkerForProject(projectRoot);
+        if (staleWorker) {
+            markWorkerCrashed(staleWorker.worker_id);
+            forceReleaseLeasesForWorker(staleWorker.worker_id);
+            deleteRuntimeKv("worker", staleWorker.worker_id, SESSION_FILE_KV_KEY);
+            return;
+        }
+        const lock = readLegacyLock(basePath);
+        if (lock?.pid)
+            markWorkerStoppingByPid(projectRoot, lock.pid);
+        const worker = findActiveWorkerForCurrentProcess(projectRoot);
+        if (worker)
+            deleteRuntimeKv("worker", worker.worker_id, SESSION_FILE_KV_KEY);
+        const stale = findStaleWorkerForProject(projectRoot);
+        if (stale) {
+            markWorkerStopping(stale.worker_id);
+            deleteRuntimeKv("worker", stale.worker_id, SESSION_FILE_KV_KEY);
+        }
     }
     catch {
         // Best-effort.
     }
+}
+/**
+ * Clear a stale DB-backed worker lock after readCrashLock/findStaleWorkerForProject
+ * has identified a dead worker. Unlike clearLock(), this targets the stale
+ * worker row instead of the current process's active worker.
+ */
+export function clearStaleWorkerLock(basePath) {
+    clearLegacyLockFile(basePath);
     if (!isDbAvailable())
         return;
     try {
         const projectRoot = normalizeRealPath(basePath);
-        const worker = findActiveWorkerForCurrentProcess(projectRoot);
+        const worker = findStaleWorkerForProject(projectRoot);
         if (!worker)
             return;
+        markLatestActiveForWorkerCanceled(worker.worker_id, "crash-recovered");
+        markWorkerCrashed(worker.worker_id);
         deleteRuntimeKv("worker", worker.worker_id, SESSION_FILE_KV_KEY);
     }
     catch {

package/dist/resources/extensions/gsd/db/auto-workers.js

@@ -122,6 +122,27 @@ export function markWorkerStopping(workerId) {
         db.prepare(`UPDATE workers SET status = 'stopping' WHERE worker_id = :worker_id`).run({ ":worker_id": workerId });
     });
 }
+/**
+ * Mark the active worker row for a specific PID/project root as stopping.
+ * Used when we detect a dead PID from lock metadata before heartbeat expiry.
+ */
+export function markWorkerStoppingByPid(projectRootRealpath, pid) {
+    if (!isDbAvailable())
+        return;
+    if (!Number.isInteger(pid) || pid <= 0)
+        return;
+    const db = _getAdapter();
+    transaction(() => {
+        db.prepare(`UPDATE workers
+       SET status = 'stopping'
+       WHERE pid = :pid
+         AND project_root_realpath = :project_root
+         AND status = 'active'`).run({
+            ":pid": pid,
+            ":project_root": projectRootRealpath,
+        });
+    });
+}
 /**
  * Return all workers whose status is 'active' AND whose heartbeat is within
  * the TTL window. Workers older than the TTL are NOT auto-marked crashed
@@ -203,6 +224,15 @@ export function findStaleWorkerForProject(projectRootRealpath) {
     const db = _getAdapter();
     const cutoffMs = Date.now() - HEARTBEAT_TTL_SECONDS * 1000;
     const cutoffIso = new Date(cutoffMs).toISOString();
+    const latestActiveRow = db.prepare(`SELECT worker_id, host, pid, started_at, version,
+            last_heartbeat_at, status, project_root_realpath
+     FROM workers
+     WHERE project_root_realpath = :project_root
+       AND status = 'active'
+     ORDER BY started_at DESC
+     LIMIT 1`).get({ ":project_root": projectRootRealpath });
+    if (latestActiveRow && !isWorkerProcessAlive(latestActiveRow))
+        return latestActiveRow;
     const row = db.prepare(`SELECT worker_id, host, pid, started_at, version,
             last_heartbeat_at, status, project_root_realpath
      FROM workers

package/dist/resources/extensions/gsd/db/milestone-leases.js

@@ -193,6 +193,30 @@ export function releaseMilestoneLease(workerId, milestoneId, fencingToken) {
         return changes === 1;
     });
 }
+/**
+ * Force-release all held leases for a worker.
+ *
+ * Used by crash recovery once PID liveness has confirmed the worker is dead.
+ * No fencing token is required because this path is cleanup-only for a
+ * non-running process.
+ */
+export function forceReleaseLeasesForWorker(workerId) {
+    if (!isDbAvailable())
+        return 0;
+    const db = _getAdapter();
+    let changes = 0;
+    transaction(() => {
+        const result = db.prepare(`UPDATE milestone_leases
+       SET status = 'released'
+       WHERE worker_id = :worker_id
+         AND status = 'held'`).run({ ":worker_id": workerId });
+        changes =
+            typeof result.changes === "number"
+                ? result.changes
+                : 0;
+    });
+    return changes;
+}
 /**
  * Read current lease row for diagnostics. Returns null if no row exists.
  */

package/dist/resources/extensions/gsd/db/unit-dispatches.js

@@ -391,16 +391,17 @@ export function getRecentUnitKeysForProjectRoot(projectRootRealpath, limit = 20)
     if (!isDbAvailable())
         return [];
     const db = _getAdapter();
-    const rows = db.prepare(`SELECT ud.unit_id
+    const rows = db.prepare(`SELECT ud.unit_type, ud.unit_id
      FROM unit_dispatches ud
      INNER JOIN workers w ON w.worker_id = ud.worker_id
      WHERE w.project_root_realpath = :project_root_realpath
+       AND w.status != 'crashed'
      ORDER BY ud.started_at DESC, ud.id DESC
      LIMIT :limit`).all({
         ":project_root_realpath": projectRootRealpath,
         ":limit": limit,
     });
-    return rows.reverse().map((r) => ({ key: r.unit_id }));
+    return rows.reverse().map((r) => ({ key: `${r.unit_type}/${r.unit_id}` }));
 }
 /**
  * Fetch dispatches for a milestone filtered by status. Useful for janitors

package/dist/resources/extensions/gsd/db-base-schema.js

@@ -149,6 +149,7 @@ export function createBaseSchemaObjects(db, hooks) {
       proof_level TEXT NOT NULL DEFAULT '',
       integration_closure TEXT NOT NULL DEFAULT '',
       observability_impact TEXT NOT NULL DEFAULT '',
+      target_repositories TEXT NOT NULL DEFAULT '[]',
       sequence INTEGER DEFAULT 0,
       replan_triggered_at TEXT DEFAULT NULL,
       is_sketch INTEGER NOT NULL DEFAULT 0,
@@ -188,6 +189,7 @@ export function createBaseSchemaObjects(db, hooks) {
       expected_output TEXT NOT NULL DEFAULT '[]',
       observability_impact TEXT NOT NULL DEFAULT '',
       full_plan_md TEXT NOT NULL DEFAULT '',
+      target_repositories TEXT NOT NULL DEFAULT '[]',
       sequence INTEGER DEFAULT 0,
       PRIMARY KEY (milestone_id, slice_id, id),
       FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id)

package/dist/resources/extensions/gsd/db-migration-steps.js

@@ -385,6 +385,10 @@ export function applyMigrationV27ArtifactHash(db) {
 export function applyMigrationV28MemoryLastHitAt(db) {
     ensureColumn(db, "memories", "last_hit_at", "ALTER TABLE memories ADD COLUMN last_hit_at TEXT DEFAULT NULL");
 }
+export function applyMigrationV29RepositoryTargets(db) {
+    ensureColumn(db, "slices", "target_repositories", "ALTER TABLE slices ADD COLUMN target_repositories TEXT NOT NULL DEFAULT '[]'");
+    ensureColumn(db, "tasks", "target_repositories", "ALTER TABLE tasks ADD COLUMN target_repositories TEXT NOT NULL DEFAULT '[]'");
+}
 export function applyMigrationV22QualityGateRepair(db, hooks) {
     const qgInfo = db.prepare("PRAGMA table_info(quality_gates)").all();
     const taskIdCol = qgInfo.find((r) => r["name"] === "task_id");

package/dist/resources/extensions/gsd/db-task-slice-rows.js

@@ -48,6 +48,7 @@ export function rowToSlice(row) {
         replan_triggered_at: row["replan_triggered_at"] ?? null,
         is_sketch: row["is_sketch"] ?? 0,
         sketch_scope: row["sketch_scope"] ?? "",
+        target_repositories: parseTaskArrayColumn(row["target_repositories"]),
     };
 }
 export function rowToTask(row) {
@@ -82,5 +83,6 @@ export function rowToTask(row) {
         escalation_awaiting_review: row["escalation_awaiting_review"] ?? 0,
         escalation_artifact_path: row["escalation_artifact_path"] ?? null,
         escalation_override_applied_at: row["escalation_override_applied_at"] ?? null,
+        target_repositories: parseTaskArrayColumn(row["target_repositories"]),
     };
 }