gsd-pi 2.58.0 → 2.59.0-dev.3de3832

package/src/resources/extensions/gsd/undo.ts

@@ -5,7 +5,7 @@
 
 import type { ExtensionCommandContext, ExtensionAPI } from "@gsd/pi-coding-agent";
 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";
@@ -133,7 +133,7 @@ export async function handleUndo(args: string, ctx: ExtensionCommandContext, _pi
   }
 
   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/src/resources/extensions/gsd/unit-ownership.ts

@@ -3,18 +3,20 @@
 //
 // 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);
 
 // ─── Types ───────────────────────────────────────────────────────────────
 
@@ -23,7 +25,133 @@ export interface UnitClaim {
   claimed_at: string;
 }
 
-type ClaimsMap = Record<string, UnitClaim>;
+// ─── SQLite Provider (mirrors gsd-db.ts pattern) ─────────────────────────
+
+interface StmtLike {
+  run(...params: unknown[]): unknown;
+  get(...params: unknown[]): Record<string, unknown> | undefined;
+}
+
+interface DbLike {
+  exec(sql: string): void;
+  prepare(sql: string): StmtLike;
+  close(): void;
+}
+
+type ProviderName = "node:sqlite" | "better-sqlite3";
+
+let providerName: ProviderName | null = null;
+let providerModule: unknown = null;
+let loadAttempted = false;
+
+function suppressSqliteWarning(): void {
+  const origEmit = process.emit;
+  // @ts-expect-error overriding process.emit for warning filter
+  process.emit = function (event: string, ...args: unknown[]): boolean {
+    if (
+      event === "warning" &&
+      args[0] &&
+      typeof args[0] === "object" &&
+      "name" in args[0] &&
+      (args[0] as { name: string }).name === "ExperimentalWarning" &&
+      "message" in args[0] &&
+      typeof (args[0] as { message: string }).message === "string" &&
+      (args[0] as { message: string }).message.includes("SQLite")
+    ) {
+      return false;
+    }
+    return origEmit.apply(process, [event, ...args] as Parameters<typeof process.emit>) as unknown as boolean;
+  };
+}
+
+function loadProvider(): void {
+  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: unknown): Record<string, unknown> | undefined {
+  if (row == null) return undefined;
+  if (Object.getPrototypeOf(row) === null) {
+    return { ...(row as Record<string, unknown>) };
+  }
+  return row as Record<string, unknown>;
+}
+
+function openRawDb(path: string): unknown {
+  loadProvider();
+  if (!providerModule || !providerName) return null;
+
+  if (providerName === "node:sqlite") {
+    const { DatabaseSync } = providerModule as {
+      DatabaseSync: new (path: string) => unknown;
+    };
+    return new DatabaseSync(path);
+  }
+
+  const Database = providerModule as new (path: string) => unknown;
+  return new Database(path);
+}
+
+function wrapDb(rawDb: unknown): DbLike {
+  const db = rawDb as {
+    exec(sql: string): void;
+    prepare(sql: string): {
+      run(...args: unknown[]): unknown;
+      get(...args: unknown[]): unknown;
+    };
+    close(): void;
+  };
+  return {
+    exec(sql: string): void { db.exec(sql); },
+    prepare(sql: string): StmtLike {
+      const raw = db.prepare(sql);
+      return {
+        run(...params: unknown[]): unknown { return raw.run(...params); },
+        get(...params: unknown[]): Record<string, unknown> | undefined {
+          return normalizeRow(raw.get(...params));
+        },
+      };
+    },
+    close(): void { db.close(); },
+  };
+}
+
+// ─── Per-basePath DB pool ────────────────────────────────────────────────
+
+const dbPool = new Map<string, DbLike>();
+
+function claimsDbPath(basePath: string): string {
+  return join(basePath, ".gsd", "unit-claims.db");
+}
+
+function getDb(basePath: string): DbLike | null {
+  const existing = dbPool.get(basePath);
+  if (existing) return existing;
+  return null;
+}
 
 // ─── Key Builders ────────────────────────────────────────────────────────
 
@@ -35,60 +163,103 @@ export function sliceUnitKey(milestoneId: string, sliceId: string): string {
   return `${milestoneId}/${sliceId}`;
 }
 
-// ─── File Path ───────────────────────────────────────────────────────────
+// ─── Lifecycle ───────────────────────────────────────────────────────────
 
-function claimsPath(basePath: string): string {
-  return join(basePath, ".gsd", "unit-claims.json");
-}
+/**
+ * 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: string): void {
+  if (dbPool.has(basePath)) return;
 
-// ─── Read Claims ─────────────────────────────────────────────────────────
+  const dir = join(basePath, ".gsd");
+  mkdirSync(dir, { recursive: true });
 
-function readClaims(basePath: string): ClaimsMap | null {
-  const path = claimsPath(basePath);
-  if (!existsSync(path)) return null;
-  try {
-    return JSON.parse(readFileSync(path, "utf-8")) as ClaimsMap;
-  } catch {
-    return null;
+  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);
+}
+
+/**
+ * Close the ownership database for a given basePath.
+ * Safe to call even if not initialized.
+ */
+export function closeOwnershipDb(basePath: string): void {
+  const db = dbPool.get(basePath);
+  if (!db) return;
+  try { 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: string, unitKey: string, agentName: string): void {
-  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");
+export function claimUnit(basePath: string, unitKey: string, agentName: string): boolean {
+  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 as string | undefined;
+
+  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: string, unitKey: string): void {
-  const claims = readClaims(basePath);
-  if (!claims || !(unitKey in claims)) return;
-  delete claims[unitKey];
-  atomicWriteSync(claimsPath(basePath), JSON.stringify(claims, null, 2) + "\n");
+  const db = getDb(basePath);
+  if (!db) return;
+  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: string, unitKey: string): string | null {
-  const claims = readClaims(basePath);
-  if (!claims) return null;
-  return claims[unitKey]?.agent ?? null;
+  const db = getDb(basePath);
+  if (!db) return null;
+  const row = db.prepare("SELECT agent_name FROM unit_claims WHERE unit_key = ?").get(unitKey);
+  return (row?.agent_name as string) ?? 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(
@@ -98,7 +269,7 @@ export function checkOwnership(
 ): string | null {
   if (!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
+  if (owner === null) return null; // unit unclaimed
   if (owner === actorName) return null; // actor is the owner
   return `Unit ${unitKey} is owned by ${owner}, not ${actorName}`;
 }

package/src/resources/extensions/gsd/verdict-parser.ts

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

package/src/resources/extensions/gsd/watch/header-renderer.ts

@@ -0,0 +1,275 @@
+// 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: readonly string[] = [
+  '   ██████╗ ███████╗██████╗ ',
+  '  ██╔════╝ ██╔════╝██╔══██╗',
+  '  ██║  ███╗███████╗██║  ██║',
+  '  ██║   ██║╚════██║██║  ██║',
+  '  ╚██████╔╝███████║██████╔╝',
+  '   ╚═════╝ ╚══════╝╚═════╝ ',
+];
+
+/** 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(): string {
+  try {
+    const prefs = loadEffectiveGSDPreferences();
+    if (!prefs?.preferences.models) return "default";
+    const m = prefs.preferences.models as Record<string, unknown>;
+    // 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 as { model: string }).model;
+        if (typeof model === "string") return model;
+      }
+    }
+  } catch {
+    // Non-fatal
+  }
+  return "default";
+}
+
+/**
+ * Derive provider name from model ID prefix.
+ */
+export function deriveProvider(modelId: string): string {
+  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: string): string {
+  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: string): string {
+  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: string): string[] {
+  const configPaths = [
+    join(projectRoot, ".mcp.json"),
+    join(projectRoot, ".gsd", "mcp.json"),
+  ];
+  const names: string[] = [];
+  const seen = new Set<string>();
+
+  for (const configPath of configPaths) {
+    try {
+      if (!existsSync(configPath)) continue;
+      const raw = readFileSync(configPath, "utf-8");
+      const data = JSON.parse(raw) as Record<string, unknown>;
+      const mcpServers = (data.mcpServers ?? data.servers) as
+        | Record<string, unknown>
+        | undefined;
+      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;
+}
+
+// ─── Header Layout ────────────────────────────────────────────────────────────
+
+export interface HeaderData {
+  model: string;
+  provider: string;
+  directory: string;
+  branch: string;
+  mcpServers: string[];
+}
+
+/**
+ * Gather all header data from filesystem and preferences.
+ */
+export function gatherHeaderData(projectRoot: string): HeaderData {
+  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: string, value: string, availableWidth: number): string {
+  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: string[], width: number): string {
+  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: HeaderData, width: number): string[] {
+  const lines: string[] = [];
+
+  // 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: string[] = [
+    `\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: HeaderData, width: number): string[] {
+  const lines: string[] = [];
+
+  // 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/src/resources/extensions/gsd/workflow-logger.ts

@@ -31,7 +31,9 @@ export type LogComponent =
   | "state"         // deriveState fallback/degradation
   | "tool"          // Tool handler errors
   | "compaction"    // Event compaction
-  | "reconcile";    // Worktree reconciliation
+  | "reconcile"     // Worktree reconciliation
+  | "db"            // Database operations (gsd-db)
+  | "dispatch";     // Auto-dispatch rule evaluation
 
 export interface LogEntry {
   ts: string;