gsd-pi 2.45.0 → 2.46.0-dev.cc9d310

package/src/resources/extensions/gsd/workflow-logger.ts

@@ -0,0 +1,243 @@
+// GSD Extension — Workflow Logger
+// Centralized warning/error accumulator for the workflow engine pipeline.
+// Captures structured entries that the auto-loop can drain after each unit
+// to surface root causes for stuck loops, silent degradation, and blocked writes.
+// All entries are also persisted to .gsd/audit-log.jsonl for post-mortem analysis.
+//
+// Stderr policy: every logWarning/logError call writes immediately to stderr
+// for terminal visibility. This is intentional — unlike debug-logger (which is
+// opt-in and zero-overhead when disabled), workflow-logger covers operational
+// warnings/errors that should always be visible. There is no disable flag.
+//
+// Singleton safety: _buffer is module-level and shared across all calls within
+// a process. The auto-loop must call _resetLogs() (or drainAndSummarize()) at
+// the start of each unit to prevent log bleed between units running in the same
+// Node process.
+
+import { appendFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+
+// ─── Types ──────────────────────────────────────────────────────────────
+
+export type LogSeverity = "warn" | "error";
+
+export type LogComponent =
+  | "engine"        // WorkflowEngine afterCommand side effects
+  | "projection"    // Projection rendering
+  | "manifest"      // Manifest write
+  | "event-log"     // Event append
+  | "intercept"     // Write intercept / tool-call blocks
+  | "migration"     // Auto-migration from markdown
+  | "state"         // deriveState fallback/degradation
+  | "tool"          // Tool handler errors
+  | "compaction"    // Event compaction
+  | "reconcile";    // Worktree reconciliation
+
+export interface LogEntry {
+  ts: string;
+  severity: LogSeverity;
+  component: LogComponent;
+  message: string;
+  /** Optional structured context (file path, command name, etc.) */
+  context?: Record<string, string>;
+}
+
+// ─── Buffer & Persistent Audit ──────────────────────────────────────────
+
+const MAX_BUFFER = 100;
+let _buffer: LogEntry[] = [];
+let _auditBasePath: string | null = null;
+
+/**
+ * Set the base path for persistent audit log writes.
+ * Should be called once at engine init with the project root.
+ * Until set, log entries are buffered in-memory only.
+ */
+export function setLogBasePath(basePath: string): void {
+  _auditBasePath = basePath;
+}
+
+// ─── Public API ─────────────────────────────────────────────────────────
+
+/**
+ * Record a warning. Also writes to stderr for terminal visibility.
+ */
+export function logWarning(
+  component: LogComponent,
+  message: string,
+  context?: Record<string, string>,
+): void {
+  _push("warn", component, message, context);
+}
+
+/**
+ * Record an error. Also writes to stderr for terminal visibility.
+ */
+export function logError(
+  component: LogComponent,
+  message: string,
+  context?: Record<string, string>,
+): void {
+  _push("error", component, message, context);
+}
+
+/**
+ * Drain all accumulated entries and clear the buffer.
+ * Returns entries oldest-first.
+ *
+ * WARNING: Call summarizeLogs() or drainAndSummarize() BEFORE calling this
+ * if you need a summary — drainLogs() clears the buffer immediately.
+ */
+export function drainLogs(): LogEntry[] {
+  const entries = _buffer;
+  _buffer = [];
+  return entries;
+}
+
+/**
+ * Atomically summarize then drain — the safe way to consume logs.
+ * Use this in the auto-loop instead of calling summarizeLogs() + drainLogs()
+ * separately to avoid the ordering footgun.
+ */
+export function drainAndSummarize(): { logs: LogEntry[]; summary: string | null } {
+  const summary = summarizeLogs();
+  const logs = drainLogs();
+  return { logs, summary };
+}
+
+/**
+ * Peek at current entries without clearing.
+ */
+export function peekLogs(): readonly LogEntry[] {
+  return _buffer;
+}
+
+/**
+ * Returns true if the buffer contains any error-severity entries.
+ */
+export function hasErrors(): boolean {
+  return _buffer.some((e) => e.severity === "error");
+}
+
+/**
+ * Returns true if the buffer contains any warn-severity entries.
+ * Use hasAnyIssues() if you want to check for either severity.
+ */
+export function hasWarnings(): boolean {
+  return _buffer.some((e) => e.severity === "warn");
+}
+
+/**
+ * Returns true if the buffer contains any entries (warn or error).
+ */
+export function hasAnyIssues(): boolean {
+  return _buffer.length > 0;
+}
+
+/**
+ * Get a one-line summary of accumulated issues for stuck detection messages.
+ * Returns null if no entries.
+ *
+ * Must be called BEFORE drainLogs() — use drainAndSummarize() for safe ordering.
+ */
+export function summarizeLogs(): string | null {
+  if (_buffer.length === 0) return null;
+  const errors = _buffer.filter((e) => e.severity === "error");
+  const warns = _buffer.filter((e) => e.severity === "warn");
+
+  const parts: string[] = [];
+  if (errors.length > 0) {
+    parts.push(`${errors.length} error(s): ${errors.map((e) => e.message).join("; ")}`);
+  }
+  if (warns.length > 0) {
+    parts.push(`${warns.length} warning(s): ${warns.map((e) => e.message).join("; ")}`);
+  }
+  return parts.join(" | ");
+}
+
+/**
+ * Format entries for display (used by auto-loop post-unit notification).
+ * Note: context fields are not included in the formatted output.
+ */
+export function formatForNotification(entries: readonly LogEntry[]): string {
+  if (entries.length === 0) return "";
+  if (entries.length === 1) {
+    const e = entries[0];
+    return `[${e.component}] ${e.message}`;
+  }
+  return entries
+    .map((e) => `[${e.component}] ${e.message}`)
+    .join("\n");
+}
+
+/**
+ * Read all entries from the persistent audit log.
+ * Returns empty array if no basePath is set or the file doesn't exist.
+ */
+export function readAuditLog(basePath?: string): LogEntry[] {
+  const bp = basePath ?? _auditBasePath;
+  if (!bp) return [];
+  const auditPath = join(bp, ".gsd", "audit-log.jsonl");
+  if (!existsSync(auditPath)) return [];
+  try {
+    const content = readFileSync(auditPath, "utf-8");
+    return content
+      .split("\n")
+      .filter((l) => l.length > 0)
+      .map((l) => {
+        try { return JSON.parse(l) as LogEntry; } catch { return null; }
+      })
+      .filter((e): e is LogEntry => e !== null);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Reset buffer. Call at the start of each auto-loop unit to prevent log bleed
+ * between units running in the same process. Also used in tests via _resetLogs().
+ */
+export function _resetLogs(): void {
+  _buffer = [];
+  _auditBasePath = null;
+}
+
+// ─── Internal ───────────────────────────────────────────────────────────
+
+function _push(
+  severity: LogSeverity,
+  component: LogComponent,
+  message: string,
+  context?: Record<string, string>,
+): void {
+  const entry: LogEntry = {
+    ts: new Date().toISOString(),
+    severity,
+    component,
+    message,
+    ...(context ? { context } : {}),
+  };
+
+  // Always forward to stderr so terminal watchers see it (see module header for policy)
+  const prefix = severity === "error" ? "ERROR" : "WARN";
+  const ctxStr = context ? ` ${JSON.stringify(context)}` : "";
+  process.stderr.write(`[gsd:${component}] ${prefix}: ${message}${ctxStr}\n`);
+
+  // Buffer for auto-loop to drain
+  _buffer.push(entry);
+  if (_buffer.length > MAX_BUFFER) {
+    _buffer.shift();
+  }
+
+  // Persist to .gsd/audit-log.jsonl so entries survive context resets
+  if (_auditBasePath) {
+    try {
+      const auditDir = join(_auditBasePath, ".gsd");
+      mkdirSync(auditDir, { recursive: true });
+      appendFileSync(join(auditDir, "audit-log.jsonl"), JSON.stringify(entry) + "\n", "utf-8");
+    } catch (auditErr) {
+      // Best-effort — never let audit write failures bubble up
+      process.stderr.write(`[gsd:audit] failed to persist log entry: ${(auditErr as Error).message}\n`);
+    }
+  }
+}

package/src/resources/extensions/gsd/workflow-manifest.ts

@@ -0,0 +1,334 @@
+import {
+  _getAdapter,
+  transaction,
+  type MilestoneRow,
+  type SliceRow,
+  type TaskRow,
+} from "./gsd-db.js";
+import type { Decision } from "./types.js";
+import { atomicWriteSync } from "./atomic-write.js";
+import { readFileSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+
+// ─── Manifest Types ──────────────────────────────────────────────────────
+
+export interface VerificationEvidenceRow {
+  id: number;
+  task_id: string;
+  slice_id: string;
+  milestone_id: string;
+  command: string;
+  exit_code: number | null;
+  verdict: string;
+  duration_ms: number | null;
+  created_at: string;
+}
+
+export interface StateManifest {
+  version: 1;
+  exported_at: string; // ISO 8601
+  milestones: MilestoneRow[];
+  slices: SliceRow[];
+  tasks: TaskRow[];
+  decisions: Decision[];
+  verification_evidence: VerificationEvidenceRow[];
+}
+
+// ─── helpers ─────────────────────────────────────────────────────────────
+
+function requireDb() {
+  const db = _getAdapter();
+  if (!db) throw new Error("workflow-manifest: No database open");
+  return db;
+}
+
+// ─── snapshotState ───────────────────────────────────────────────────────
+
+/**
+ * Capture complete DB state as a StateManifest.
+ * Reads all rows from milestones, slices, tasks, decisions, verification_evidence.
+ *
+ * Note: rows returned from raw queries are plain objects with TEXT columns for
+ * JSON arrays. We parse them into typed Row objects using the same logic as
+ * gsd-db helper functions.
+ */
+export function snapshotState(): StateManifest {
+  const db = requireDb();
+
+  // Wrap all reads in a deferred transaction so the snapshot is consistent
+  // (all SELECTs see the same DB state even if a concurrent write lands between them).
+  db.exec("BEGIN DEFERRED");
+
+  try {
+  const rawMilestones = db.prepare("SELECT * FROM milestones ORDER BY id").all() as Record<string, unknown>[];
+  const milestones: MilestoneRow[] = rawMilestones.map((r) => ({
+    id: r["id"] as string,
+    title: r["title"] as string,
+    status: r["status"] as string,
+    depends_on: JSON.parse((r["depends_on"] as string) || "[]"),
+    created_at: r["created_at"] as string,
+    completed_at: (r["completed_at"] as string) ?? null,
+    vision: (r["vision"] as string) ?? "",
+    success_criteria: JSON.parse((r["success_criteria"] as string) || "[]"),
+    key_risks: JSON.parse((r["key_risks"] as string) || "[]"),
+    proof_strategy: JSON.parse((r["proof_strategy"] as string) || "[]"),
+    verification_contract: (r["verification_contract"] as string) ?? "",
+    verification_integration: (r["verification_integration"] as string) ?? "",
+    verification_operational: (r["verification_operational"] as string) ?? "",
+    verification_uat: (r["verification_uat"] as string) ?? "",
+    definition_of_done: JSON.parse((r["definition_of_done"] as string) || "[]"),
+    requirement_coverage: (r["requirement_coverage"] as string) ?? "",
+    boundary_map_markdown: (r["boundary_map_markdown"] as string) ?? "",
+  }));
+
+  const rawSlices = db.prepare("SELECT * FROM slices ORDER BY milestone_id, sequence, id").all() as Record<string, unknown>[];
+  const slices: SliceRow[] = rawSlices.map((r) => ({
+    milestone_id: r["milestone_id"] as string,
+    id: r["id"] as string,
+    title: r["title"] as string,
+    status: r["status"] as string,
+    risk: r["risk"] as string,
+    depends: JSON.parse((r["depends"] as string) || "[]"),
+    demo: (r["demo"] as string) ?? "",
+    created_at: r["created_at"] as string,
+    completed_at: (r["completed_at"] as string) ?? null,
+    full_summary_md: (r["full_summary_md"] as string) ?? "",
+    full_uat_md: (r["full_uat_md"] as string) ?? "",
+    goal: (r["goal"] as string) ?? "",
+    success_criteria: (r["success_criteria"] as string) ?? "",
+    proof_level: (r["proof_level"] as string) ?? "",
+    integration_closure: (r["integration_closure"] as string) ?? "",
+    observability_impact: (r["observability_impact"] as string) ?? "",
+    sequence: (r["sequence"] as number) ?? 0,
+    replan_triggered_at: (r["replan_triggered_at"] as string) ?? null,
+  }));
+
+  const rawTasks = db.prepare("SELECT * FROM tasks ORDER BY milestone_id, slice_id, sequence, id").all() as Record<string, unknown>[];
+  const tasks: TaskRow[] = rawTasks.map((r) => ({
+    milestone_id: r["milestone_id"] as string,
+    slice_id: r["slice_id"] as string,
+    id: r["id"] as string,
+    title: r["title"] as string,
+    status: r["status"] as string,
+    one_liner: (r["one_liner"] as string) ?? "",
+    narrative: (r["narrative"] as string) ?? "",
+    verification_result: (r["verification_result"] as string) ?? "",
+    duration: (r["duration"] as string) ?? "",
+    completed_at: (r["completed_at"] as string) ?? null,
+    blocker_discovered: (r["blocker_discovered"] as number) === 1,
+    deviations: (r["deviations"] as string) ?? "",
+    known_issues: (r["known_issues"] as string) ?? "",
+    key_files: JSON.parse((r["key_files"] as string) || "[]"),
+    key_decisions: JSON.parse((r["key_decisions"] as string) || "[]"),
+    full_summary_md: (r["full_summary_md"] as string) ?? "",
+    description: (r["description"] as string) ?? "",
+    estimate: (r["estimate"] as string) ?? "",
+    files: JSON.parse((r["files"] as string) || "[]"),
+    verify: (r["verify"] as string) ?? "",
+    inputs: JSON.parse((r["inputs"] as string) || "[]"),
+    expected_output: JSON.parse((r["expected_output"] as string) || "[]"),
+    observability_impact: (r["observability_impact"] as string) ?? "",
+    full_plan_md: (r["full_plan_md"] as string) ?? "",
+    sequence: (r["sequence"] as number) ?? 0,
+  }));
+
+  const rawDecisions = db.prepare("SELECT * FROM decisions ORDER BY seq").all() as Record<string, unknown>[];
+  const decisions: Decision[] = rawDecisions.map((r) => ({
+    seq: r["seq"] as number,
+    id: r["id"] as string,
+    when_context: (r["when_context"] as string) ?? "",
+    scope: (r["scope"] as string) ?? "",
+    decision: (r["decision"] as string) ?? "",
+    choice: (r["choice"] as string) ?? "",
+    rationale: (r["rationale"] as string) ?? "",
+    revisable: (r["revisable"] as string) ?? "",
+    made_by: (r["made_by"] as string as Decision["made_by"]) ?? "agent",
+    superseded_by: (r["superseded_by"] as string) ?? null,
+  }));
+
+  const rawEvidence = db.prepare("SELECT * FROM verification_evidence ORDER BY id").all() as Record<string, unknown>[];
+  const verification_evidence: VerificationEvidenceRow[] = rawEvidence.map((r) => ({
+    id: r["id"] as number,
+    task_id: r["task_id"] as string,
+    slice_id: r["slice_id"] as string,
+    milestone_id: r["milestone_id"] as string,
+    command: r["command"] as string,
+    exit_code: (r["exit_code"] as number) ?? null,
+    verdict: (r["verdict"] as string) ?? "",
+    duration_ms: (r["duration_ms"] as number) ?? null,
+    created_at: r["created_at"] as string,
+  }));
+
+  const result: StateManifest = {
+    version: 1,
+    exported_at: new Date().toISOString(),
+    milestones,
+    slices,
+    tasks,
+    decisions,
+    verification_evidence,
+  };
+
+  db.exec("COMMIT");
+  return result;
+  } catch (err) {
+    try { db.exec("ROLLBACK"); } catch { /* ignore rollback failure */ }
+    throw err;
+  }
+}
+
+// ─── restore ─────────────────────────────────────────────────────────────
+
+/**
+ * Atomically replace all workflow state from a manifest.
+ * Runs inside a transaction — if any insert fails, no tables are modified.
+ * Only touches engine tables + decisions. Does NOT modify artifacts or memories.
+ */
+function restore(manifest: StateManifest): void {
+  const db = requireDb();
+
+  transaction(() => {
+    // Clear engine tables (order matters for foreign-key-like consistency)
+    db.exec("DELETE FROM verification_evidence");
+    db.exec("DELETE FROM tasks");
+    db.exec("DELETE FROM slices");
+    db.exec("DELETE FROM milestones");
+    db.exec("DELETE FROM decisions WHERE 1=1");
+
+    // Restore milestones
+    const msStmt = db.prepare(
+      `INSERT INTO milestones (id, title, status, depends_on, created_at, completed_at,
+        vision, success_criteria, key_risks, proof_strategy,
+        verification_contract, verification_integration, verification_operational, verification_uat,
+        definition_of_done, requirement_coverage, boundary_map_markdown)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    );
+    for (const m of manifest.milestones) {
+      msStmt.run(
+        m.id, m.title, m.status,
+        JSON.stringify(m.depends_on), m.created_at, m.completed_at,
+        m.vision, JSON.stringify(m.success_criteria), JSON.stringify(m.key_risks),
+        JSON.stringify(m.proof_strategy),
+        m.verification_contract, m.verification_integration, m.verification_operational, m.verification_uat,
+        JSON.stringify(m.definition_of_done), m.requirement_coverage, m.boundary_map_markdown,
+      );
+    }
+
+    // Restore slices
+    const slStmt = db.prepare(
+      `INSERT INTO slices (milestone_id, id, title, status, risk, depends, demo,
+        created_at, completed_at, full_summary_md, full_uat_md,
+        goal, success_criteria, proof_level, integration_closure, observability_impact,
+        sequence, replan_triggered_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    );
+    for (const s of manifest.slices) {
+      slStmt.run(
+        s.milestone_id, s.id, s.title, s.status, s.risk,
+        JSON.stringify(s.depends), s.demo,
+        s.created_at, s.completed_at, s.full_summary_md, s.full_uat_md,
+        s.goal, s.success_criteria, s.proof_level, s.integration_closure, s.observability_impact,
+        s.sequence, s.replan_triggered_at,
+      );
+    }
+
+    // Restore tasks
+    const tkStmt = db.prepare(
+      `INSERT INTO tasks (milestone_id, slice_id, id, title, status,
+        one_liner, narrative, verification_result, duration, completed_at,
+        blocker_discovered, deviations, known_issues, key_files, key_decisions,
+        full_summary_md, description, estimate, files, verify,
+        inputs, expected_output, observability_impact, sequence)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    );
+    for (const t of manifest.tasks) {
+      tkStmt.run(
+        t.milestone_id, t.slice_id, t.id, t.title, t.status,
+        t.one_liner, t.narrative, t.verification_result, t.duration, t.completed_at,
+        t.blocker_discovered ? 1 : 0, t.deviations, t.known_issues,
+        JSON.stringify(t.key_files), JSON.stringify(t.key_decisions),
+        t.full_summary_md, t.description, t.estimate, JSON.stringify(t.files), t.verify,
+        JSON.stringify(t.inputs), JSON.stringify(t.expected_output),
+        t.observability_impact, t.sequence,
+      );
+    }
+
+    // Restore decisions
+    const dcStmt = db.prepare(
+      `INSERT INTO decisions (seq, id, when_context, scope, decision, choice, rationale, revisable, made_by, superseded_by)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    );
+    for (const d of manifest.decisions) {
+      dcStmt.run(d.seq, d.id, d.when_context, d.scope, d.decision, d.choice, d.rationale, d.revisable, d.made_by, d.superseded_by);
+    }
+
+    // Restore verification evidence
+    const evStmt = db.prepare(
+      `INSERT INTO verification_evidence (task_id, slice_id, milestone_id, command, exit_code, verdict, duration_ms, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+    );
+    for (const e of manifest.verification_evidence) {
+      evStmt.run(e.task_id, e.slice_id, e.milestone_id, e.command, e.exit_code, e.verdict, e.duration_ms, e.created_at);
+    }
+  });
+}
+
+// ─── writeManifest ───────────────────────────────────────────────────────
+
+/**
+ * Write current DB state to .gsd/state-manifest.json via atomicWriteSync.
+ * Uses JSON.stringify with 2-space indent for git three-way merge friendliness.
+ */
+export function writeManifest(basePath: string): void {
+  const manifest = snapshotState();
+  const json = JSON.stringify(manifest, null, 2);
+  const dir = join(basePath, ".gsd");
+  mkdirSync(dir, { recursive: true });
+  atomicWriteSync(join(dir, "state-manifest.json"), json);
+}
+
+// ─── readManifest ────────────────────────────────────────────────────────
+
+/**
+ * Read state-manifest.json and return parsed manifest, or null if not found.
+ */
+export function readManifest(basePath: string): StateManifest | null {
+  const manifestPath = join(basePath, ".gsd", "state-manifest.json");
+
+  if (!existsSync(manifestPath)) {
+    return null;
+  }
+
+  const raw = readFileSync(manifestPath, "utf-8");
+  const parsed = JSON.parse(raw) as StateManifest;
+
+  if (parsed.version !== 1) {
+    throw new Error(`Unsupported manifest version: ${parsed.version}`);
+  }
+
+  // Validate required fields to avoid cryptic errors during restore
+  if (!Array.isArray(parsed.milestones) || !Array.isArray(parsed.slices) ||
+      !Array.isArray(parsed.tasks) || !Array.isArray(parsed.decisions) ||
+      !Array.isArray(parsed.verification_evidence)) {
+    throw new Error("Malformed manifest: missing or invalid required arrays");
+  }
+
+  return parsed;
+}
+
+// ─── bootstrapFromManifest ──────────────────────────────────────────────
+
+/**
+ * Read state-manifest.json and restore DB state from it.
+ * Returns true if bootstrap succeeded, false if manifest file doesn't exist.
+ */
+export function bootstrapFromManifest(basePath: string): boolean {
+  const manifest = readManifest(basePath);
+
+  if (!manifest) {
+    return false;
+  }
+
+  restore(manifest);
+  return true;
+}