lsd-pi 1.0.0 → 1.1.0

package/dist/resources/extensions/gsd/workflow-engine.js

@@ -1,7 +0,0 @@
-/**
- * workflow-engine.ts — WorkflowEngine interface.
- *
- * Defines the contract every engine implementation must satisfy.
- * Imports only from the leaf-node engine-types.
- */
-export {};

package/dist/resources/extensions/gsd/workflow-events.js

@@ -1,102 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import { appendFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-import { atomicWriteSync } from "./atomic-write.js";
-// ─── Session ID ───────────────────────────────────────────────────────────
-/**
- * Engine-generated session ID — stable for the lifetime of this process.
- * Agents can reference this to correlate all events from one run.
- */
-const ENGINE_SESSION_ID = randomUUID();
-export function getSessionId() {
-    return ENGINE_SESSION_ID;
-}
-// ─── appendEvent ─────────────────────────────────────────────────────────
-/**
- * Append one event to .gsd/event-log.jsonl.
- * Computes a content hash from cmd+params (deterministic, independent of ts/actor/session).
- * Creates .gsd directory if needed.
- */
-export function appendEvent(basePath, event) {
-    const hash = createHash("sha256")
-        .update(JSON.stringify({ cmd: event.cmd, params: event.params }))
-        .digest("hex")
-        .slice(0, 16);
-    const fullEvent = {
-        ...event,
-        hash,
-        session_id: ENGINE_SESSION_ID,
-    };
-    const dir = join(basePath, ".gsd");
-    mkdirSync(dir, { recursive: true });
-    appendFileSync(join(dir, "event-log.jsonl"), JSON.stringify(fullEvent) + "\n", "utf-8");
-}
-// ─── readEvents ──────────────────────────────────────────────────────────
-/**
- * Read all events from a JSONL file.
- * Returns empty array if file doesn't exist.
- * Corrupted lines are skipped with stderr warning.
- */
-export function readEvents(logPath) {
-    if (!existsSync(logPath)) {
-        return [];
-    }
-    const content = readFileSync(logPath, "utf-8");
-    const lines = content.split("\n").filter((l) => l.length > 0);
-    const events = [];
-    for (const line of lines) {
-        try {
-            events.push(JSON.parse(line));
-        }
-        catch {
-            process.stderr.write(`workflow-events: skipping corrupted event line: ${line.slice(0, 80)}\n`);
-        }
-    }
-    return events;
-}
-// ─── findForkPoint ───────────────────────────────────────────────────────
-/**
- * Find the index of the last common event between two logs by comparing hashes.
- * Returns -1 if the first events differ (completely diverged).
- * If one log is a prefix of the other, returns length of shorter - 1.
- */
-export function findForkPoint(logA, logB) {
-    const minLen = Math.min(logA.length, logB.length);
-    let lastCommon = -1;
-    for (let i = 0; i < minLen; i++) {
-        if (logA[i].hash === logB[i].hash) {
-            lastCommon = i;
-        }
-        else {
-            break;
-        }
-    }
-    return lastCommon;
-}
-// ─── compactMilestoneEvents ─────────────────────────────────────────────────
-/**
- * Archive a milestone's events from the active log to a separate file.
- * Active log retains only events from other milestones.
- * Archived file is kept on disk for forensics.
- *
- * @param basePath - Project root (parent of .gsd/)
- * @param milestoneId - The milestone whose events should be archived
- * @returns { archived: number } — count of events moved to archive
- */
-export function compactMilestoneEvents(basePath, milestoneId) {
-    const logPath = join(basePath, ".gsd", "event-log.jsonl");
-    const archivePath = join(basePath, ".gsd", `event-log-${milestoneId}.jsonl.archived`);
-    const allEvents = readEvents(logPath);
-    const toArchive = allEvents.filter((e) => e.params.milestoneId === milestoneId);
-    const remaining = allEvents.filter((e) => e.params.milestoneId !== milestoneId);
-    if (toArchive.length === 0) {
-        return { archived: 0 };
-    }
-    // Write archived events to .jsonl.archived file (crash-safe)
-    atomicWriteSync(archivePath, toArchive.map((e) => JSON.stringify(e)).join("\n") + "\n");
-    // Truncate active log to remaining events only
-    atomicWriteSync(logPath, remaining.length > 0
-        ? remaining.map((e) => JSON.stringify(e)).join("\n") + "\n"
-        : "");
-    return { archived: toArchive.length };
-}

package/dist/resources/extensions/gsd/workflow-logger.js

@@ -1,192 +0,0 @@
-// 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";
-// ─── Buffer & Persistent Audit ──────────────────────────────────────────
-const MAX_BUFFER = 100;
-let _buffer = [];
-let _auditBasePath = 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) {
-    _auditBasePath = basePath;
-}
-// ─── Public API ─────────────────────────────────────────────────────────
-/**
- * Record a warning. Also writes to stderr for terminal visibility.
- */
-export function logWarning(component, message, context) {
-    _push("warn", component, message, context);
-}
-/**
- * Record an error. Also writes to stderr for terminal visibility.
- */
-export function logError(component, message, context) {
-    _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() {
-    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() {
-    const summary = summarizeLogs();
-    const logs = drainLogs();
-    return { logs, summary };
-}
-/**
- * Peek at current entries without clearing.
- */
-export function peekLogs() {
-    return _buffer;
-}
-/**
- * Returns true if the buffer contains any error-severity entries.
- */
-export function hasErrors() {
-    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() {
-    return _buffer.some((e) => e.severity === "warn");
-}
-/**
- * Returns true if the buffer contains any entries (warn or error).
- */
-export function hasAnyIssues() {
-    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() {
-    if (_buffer.length === 0)
-        return null;
-    const errors = _buffer.filter((e) => e.severity === "error");
-    const warns = _buffer.filter((e) => e.severity === "warn");
-    const parts = [];
-    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) {
-    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) {
-    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);
-            }
-            catch {
-                return null;
-            }
-        })
-            .filter((e) => 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() {
-    _buffer = [];
-}
-// ─── Internal ───────────────────────────────────────────────────────────
-function _push(severity, component, message, context) {
-    const entry = {
-        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.message}\n`);
-        }
-    }
-}

package/dist/resources/extensions/gsd/workflow-manifest.js

@@ -1,263 +0,0 @@
-import { _getAdapter, transaction, } from "./gsd-db.js";
-import { atomicWriteSync } from "./atomic-write.js";
-import { readFileSync, existsSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-// ─── helpers ─────────────────────────────────────────────────────────────
-function requireDb() {
-    const db = _getAdapter();
-    if (!db)
-        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.
- * 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() {
-    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();
-        const milestones = rawMilestones.map((r) => ({
-            id: r["id"],
-            title: r["title"],
-            status: r["status"],
-            depends_on: JSON.parse(r["depends_on"] || "[]"),
-            created_at: r["created_at"],
-            completed_at: r["completed_at"] ?? null,
-            vision: r["vision"] ?? "",
-            success_criteria: JSON.parse(r["success_criteria"] || "[]"),
-            key_risks: JSON.parse(r["key_risks"] || "[]"),
-            proof_strategy: JSON.parse(r["proof_strategy"] || "[]"),
-            verification_contract: r["verification_contract"] ?? "",
-            verification_integration: r["verification_integration"] ?? "",
-            verification_operational: r["verification_operational"] ?? "",
-            verification_uat: r["verification_uat"] ?? "",
-            definition_of_done: JSON.parse(r["definition_of_done"] || "[]"),
-            requirement_coverage: r["requirement_coverage"] ?? "",
-            boundary_map_markdown: r["boundary_map_markdown"] ?? "",
-        }));
-        const rawSlices = db.prepare("SELECT * FROM slices ORDER BY milestone_id, sequence, id").all();
-        const slices = rawSlices.map((r) => ({
-            milestone_id: r["milestone_id"],
-            id: r["id"],
-            title: r["title"],
-            status: r["status"],
-            risk: r["risk"],
-            depends: JSON.parse(r["depends"] || "[]"),
-            demo: r["demo"] ?? "",
-            created_at: r["created_at"],
-            completed_at: r["completed_at"] ?? null,
-            full_summary_md: r["full_summary_md"] ?? "",
-            full_uat_md: r["full_uat_md"] ?? "",
-            goal: r["goal"] ?? "",
-            success_criteria: r["success_criteria"] ?? "",
-            proof_level: r["proof_level"] ?? "",
-            integration_closure: r["integration_closure"] ?? "",
-            observability_impact: r["observability_impact"] ?? "",
-            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();
-        const tasks = rawTasks.map((r) => ({
-            milestone_id: r["milestone_id"],
-            slice_id: r["slice_id"],
-            id: r["id"],
-            title: r["title"],
-            status: r["status"],
-            one_liner: r["one_liner"] ?? "",
-            narrative: r["narrative"] ?? "",
-            verification_result: r["verification_result"] ?? "",
-            duration: r["duration"] ?? "",
-            completed_at: r["completed_at"] ?? null,
-            blocker_discovered: r["blocker_discovered"] === 1,
-            deviations: r["deviations"] ?? "",
-            known_issues: r["known_issues"] ?? "",
-            key_files: JSON.parse(r["key_files"] || "[]"),
-            key_decisions: JSON.parse(r["key_decisions"] || "[]"),
-            full_summary_md: r["full_summary_md"] ?? "",
-            description: r["description"] ?? "",
-            estimate: r["estimate"] ?? "",
-            files: JSON.parse(r["files"] || "[]"),
-            verify: r["verify"] ?? "",
-            inputs: JSON.parse(r["inputs"] || "[]"),
-            expected_output: JSON.parse(r["expected_output"] || "[]"),
-            observability_impact: r["observability_impact"] ?? "",
-            full_plan_md: r["full_plan_md"] ?? "",
-            sequence: toNumeric(r["sequence"], 0),
-        }));
-        const rawDecisions = db.prepare("SELECT * FROM decisions ORDER BY seq").all();
-        const decisions = rawDecisions.map((r) => ({
-            seq: toNumeric(r["seq"], 0),
-            id: r["id"],
-            when_context: r["when_context"] ?? "",
-            scope: r["scope"] ?? "",
-            decision: r["decision"] ?? "",
-            choice: r["choice"] ?? "",
-            rationale: r["rationale"] ?? "",
-            revisable: r["revisable"] ?? "",
-            made_by: r["made_by"] ?? "agent",
-            superseded_by: r["superseded_by"] ?? null,
-        }));
-        const rawEvidence = db.prepare("SELECT * FROM verification_evidence ORDER BY id").all();
-        const verification_evidence = rawEvidence.map((r) => ({
-            id: r["id"],
-            task_id: r["task_id"],
-            slice_id: r["slice_id"],
-            milestone_id: r["milestone_id"],
-            command: r["command"],
-            exit_code: toNumeric(r["exit_code"]),
-            verdict: r["verdict"] ?? "",
-            duration_ms: toNumeric(r["duration_ms"]),
-            created_at: r["created_at"],
-        }));
-        const result = {
-            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) {
-    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) {
-    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) {
-    const manifestPath = join(basePath, ".gsd", "state-manifest.json");
-    if (!existsSync(manifestPath)) {
-        return null;
-    }
-    const raw = readFileSync(manifestPath, "utf-8");
-    const parsed = JSON.parse(raw);
-    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) {
-    const manifest = readManifest(basePath);
-    if (!manifest) {
-        return false;
-    }
-    restore(manifest);
-    return true;
-}