gsd-pi 2.58.0 → 2.59.0-dev.023bd39

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/watch/header-renderer.js

@@ -0,0 +1,241 @@
+// GSD Watch — Header renderer: ASCII logo, session info, MCP status, remote questions
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { visibleWidth, truncateToWidth } from "@gsd/pi-tui";
+import { loadEffectiveGSDPreferences } from "../preferences.js";
+// ─── Constants ────────────────────────────────────────────────────────────────
+/**
+ * GSD ASCII logo — inlined here because the canonical src/logo.ts is outside
+ * the resources rootDir and cannot be imported directly.
+ */
+const GSD_LOGO = [
+    '   ██████╗ ███████╗██████╗ ',
+    '  ██╔════╝ ██╔════╝██╔══██╗',
+    '  ██║  ███╗███████╗██║  ██║',
+    '  ██║   ██║╚════██║██║  ██║',
+    '  ╚██████╔╝███████║██████╔╝',
+    '   ╚═════╝ ╚══════╝╚═════╝ ',
+];
+/** Separator character for the horizontal divider line. */
+const SEPARATOR_CHAR = "─";
+/** Vertical bar between logo and info panel. */
+const PANEL_DIVIDER = "│";
+/** Label column width for Model/Provider/Directory/Branch rows. */
+const LABEL_COL_WIDTH = 10;
+// ─── Data Readers ─────────────────────────────────────────────────────────────
+/**
+ * Read the configured execution model from GSD preferences.
+ * Falls back through execution -> planning -> research -> first found.
+ * Returns "default" if nothing is configured.
+ */
+export function readModelFromPreferences() {
+    try {
+        const prefs = loadEffectiveGSDPreferences();
+        if (!prefs?.preferences.models)
+            return "default";
+        const m = prefs.preferences.models;
+        // Try common phases in priority order
+        for (const phase of ["execution", "planning", "research", "discuss", "subagent"]) {
+            const val = m[phase];
+            if (typeof val === "string")
+                return val;
+            if (val && typeof val === "object" && "model" in val) {
+                const model = val.model;
+                if (typeof model === "string")
+                    return model;
+            }
+        }
+    }
+    catch {
+        // Non-fatal
+    }
+    return "default";
+}
+/**
+ * Derive provider name from model ID prefix.
+ */
+export function deriveProvider(modelId) {
+    if (modelId.startsWith("claude"))
+        return "anthropic";
+    if (modelId.startsWith("gpt") || modelId.startsWith("o1") || modelId.startsWith("o3"))
+        return "openai";
+    if (modelId.startsWith("gemini"))
+        return "google";
+    if (modelId.startsWith("deepseek"))
+        return "deepseek";
+    if (modelId === "default")
+        return "anthropic";
+    return "unknown";
+}
+/**
+ * Shorten a directory path by replacing the home directory with ~.
+ */
+export function shortenPath(fullPath) {
+    const home = homedir();
+    if (fullPath.startsWith(home)) {
+        return "~" + fullPath.slice(home.length);
+    }
+    return fullPath;
+}
+/**
+ * Read the current git branch name. Returns "unknown" on failure.
+ */
+export function readGitBranch(projectRoot) {
+    try {
+        return execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+            cwd: projectRoot,
+            encoding: "utf-8",
+            timeout: 2000,
+        }).trim();
+    }
+    catch {
+        return "unknown";
+    }
+}
+/**
+ * Read MCP server names from .mcp.json or .gsd/mcp.json.
+ * Returns array of server name strings.
+ */
+export function readMcpServerNames(projectRoot) {
+    const configPaths = [
+        join(projectRoot, ".mcp.json"),
+        join(projectRoot, ".gsd", "mcp.json"),
+    ];
+    const names = [];
+    const seen = new Set();
+    for (const configPath of configPaths) {
+        try {
+            if (!existsSync(configPath))
+                continue;
+            const raw = readFileSync(configPath, "utf-8");
+            const data = JSON.parse(raw);
+            const mcpServers = (data.mcpServers ?? data.servers);
+            if (!mcpServers || typeof mcpServers !== "object")
+                continue;
+            for (const name of Object.keys(mcpServers)) {
+                if (!seen.has(name)) {
+                    seen.add(name);
+                    names.push(name);
+                }
+            }
+        }
+        catch {
+            // Non-fatal
+        }
+    }
+    return names;
+}
+/**
+ * Gather all header data from filesystem and preferences.
+ */
+export function gatherHeaderData(projectRoot) {
+    const model = readModelFromPreferences();
+    const provider = deriveProvider(model);
+    const directory = shortenPath(projectRoot);
+    const branch = readGitBranch(projectRoot);
+    const mcpServers = readMcpServerNames(projectRoot);
+    return { model, provider, directory, branch, mcpServers };
+}
+/**
+ * Build an info panel line: "Label     value" with proper padding.
+ * Returns empty string if value is empty.
+ */
+function formatInfoLine(label, value, availableWidth) {
+    const bold = `\x1b[1m${label}\x1b[0m`;
+    const labelVis = visibleWidth(bold);
+    const padding = " ".repeat(Math.max(1, LABEL_COL_WIDTH - labelVis));
+    const maxValueWidth = Math.max(1, availableWidth - LABEL_COL_WIDTH);
+    const truncValue = truncateToWidth(value, maxValueWidth, "…");
+    return bold + padding + truncValue;
+}
+/**
+ * Format MCP server names as a dot-separated row with checkmarks.
+ * e.g. "Brave ✓  ·  Answers ✓  ·  Context7 ✓"
+ */
+export function formatMcpRow(servers, width) {
+    if (servers.length === 0)
+        return "";
+    // Capitalize first letter of each server name
+    const items = servers.map(s => {
+        const cap = s.charAt(0).toUpperCase() + s.slice(1);
+        return `${cap} ✓`;
+    });
+    const full = items.join("  ·  ");
+    if (visibleWidth(full) <= width)
+        return full;
+    // Truncate if too wide
+    return truncateToWidth(full, width, "…");
+}
+/**
+ * Render the full header as an array of terminal-safe strings.
+ *
+ * Layout: GSD ASCII logo on the left, info panel on the right separated by │.
+ * Below: MCP server row, remote questions row, separator line.
+ */
+export function renderHeaderLines(data, width) {
+    const lines = [];
+    // Logo is 6 lines tall. Info panel has: title + blank + model + provider + directory + branch = 6 lines
+    const logoLines = GSD_LOGO;
+    const logoWidth = Math.max(...logoLines.map(l => visibleWidth(l)));
+    // Calculate available width for the info panel
+    // Layout: logo + " " + "│" + " " = logoWidth + 3
+    const dividerOverhead = 3; // " │ "
+    const infoPanelWidth = width - logoWidth - dividerOverhead;
+    // If terminal is too narrow for side-by-side, fall back to stacked layout
+    if (infoPanelWidth < 20) {
+        return renderStackedHeader(data, width);
+    }
+    // Build info panel lines (6 lines to match logo height)
+    const infoLines = [
+        `\x1b[1mGet Shit Done\x1b[0m`,
+        "",
+        formatInfoLine("Model", data.model, infoPanelWidth),
+        formatInfoLine("Provider", data.provider, infoPanelWidth),
+        formatInfoLine("Directory", data.directory, infoPanelWidth),
+        formatInfoLine("Branch", data.branch, infoPanelWidth),
+    ];
+    // Merge logo and info panel side by side
+    const maxLines = Math.max(logoLines.length, infoLines.length);
+    for (let i = 0; i < maxLines; i++) {
+        const logoLine = i < logoLines.length ? logoLines[i] : "";
+        const infoLine = i < infoLines.length ? infoLines[i] : "";
+        // Pad logo line to consistent width
+        const logoPad = " ".repeat(Math.max(0, logoWidth - visibleWidth(logoLine)));
+        lines.push(`${logoLine}${logoPad} ${PANEL_DIVIDER} ${infoLine}`);
+    }
+    // Blank line after logo+info block
+    lines.push("");
+    // MCP server row
+    const mcpRow = formatMcpRow(data.mcpServers, width);
+    if (mcpRow) {
+        lines.push(` ${mcpRow}`);
+    }
+    // Separator line
+    lines.push(SEPARATOR_CHAR.repeat(width));
+    return lines;
+}
+/**
+ * Fallback stacked layout for narrow terminals (< 20 cols for info panel).
+ */
+function renderStackedHeader(data, width) {
+    const lines = [];
+    // Title
+    lines.push(`\x1b[1mGet Shit Done\x1b[0m`);
+    lines.push("");
+    // Info
+    lines.push(formatInfoLine("Model", data.model, width));
+    lines.push(formatInfoLine("Provider", data.provider, width));
+    lines.push(formatInfoLine("Directory", data.directory, width));
+    lines.push(formatInfoLine("Branch", data.branch, width));
+    lines.push("");
+    // MCP
+    const mcpRow = formatMcpRow(data.mcpServers, width);
+    if (mcpRow)
+        lines.push(` ${mcpRow}`);
+    // Separator
+    lines.push(SEPARATOR_CHAR.repeat(width));
+    return lines;
+}

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 = {