lsd-pi 1.0.0 → 1.1.1

package/src/resources/extensions/gsd/context-injector.ts

@@ -1,100 +0,0 @@
-/**
- * context-injector.ts — Inject prior step artifacts as context into step prompts.
- *
- * Reads the frozen DEFINITION.yaml from a run directory, finds the current step's
- * `contextFrom` references, locates each referenced step's `produces` artifacts
- * on disk, reads their content (truncated to 10k chars), and prepends formatted
- * context blocks to the step prompt.
- *
- * Observability:
- * - Truncation is logged via console.warn when it occurs, preventing silent overflow.
- * - Missing artifact files are skipped silently (the step may not have produced them yet).
- * - Unknown step IDs in contextFrom produce a console.warn for diagnosis.
- * - The frozen DEFINITION.yaml on disk is the single source of truth for contextFrom config.
- */
-
-import { readFileSync, existsSync } from "node:fs";
-import { join, resolve, sep } from "node:path";
-import type { StepDefinition } from "./definition-loader.js";
-import { readFrozenDefinition } from "./custom-workflow-engine.js";
-
-/** Maximum characters per artifact to prevent context window blowout. */
-const MAX_CONTEXT_CHARS = 10_000;
-
-/**
- * Inject context from prior step artifacts into a step's prompt.
- *
- * Reads the frozen DEFINITION.yaml from `runDir`, finds the step matching
- * `stepId`, and for each step ID in its `contextFrom` array, looks up that
- * step's `produces` paths, reads them from disk (relative to `runDir`),
- * truncates to MAX_CONTEXT_CHARS, and prepends as labeled context blocks.
- *
- * @param runDir — absolute path to the workflow run directory
- * @param stepId — the step ID whose prompt to enrich
- * @param prompt — the original step prompt
- * @returns The prompt with context blocks prepended, or unchanged if no context applies
- * @throws Error if DEFINITION.yaml is missing or unreadable
- */
-export function injectContext(
-  runDir: string,
-  stepId: string,
-  prompt: string,
-): string {
-  const def = readFrozenDefinition(runDir);
-
-  const step = def.steps.find((s: StepDefinition) => s.id === stepId);
-  if (!step || !step.contextFrom || step.contextFrom.length === 0) {
-    return prompt;
-  }
-
-  const contextBlocks: string[] = [];
-
-  for (const refStepId of step.contextFrom) {
-    const refStep = def.steps.find((s: StepDefinition) => s.id === refStepId);
-    if (!refStep) {
-      console.warn(
-        `context-injector: step "${stepId}" references unknown step "${refStepId}" in contextFrom — skipping`,
-      );
-      continue;
-    }
-
-    if (!refStep.produces || refStep.produces.length === 0) {
-      continue;
-    }
-
-    for (const relPath of refStep.produces) {
-      const absPath = resolve(runDir, relPath);
-      // Path traversal guard: ensure resolved path stays within runDir
-      if (!absPath.startsWith(resolve(runDir) + sep) && absPath !== resolve(runDir)) {
-        console.warn(
-          `context-injector: artifact path "${relPath}" resolves outside runDir — skipping`,
-        );
-        continue;
-      }
-      if (!existsSync(absPath)) {
-        // Artifact not yet produced or optional — skip silently
-        continue;
-      }
-
-      let content = readFileSync(absPath, "utf-8");
-
-      if (content.length > MAX_CONTEXT_CHARS) {
-        console.warn(
-          `context-injector: truncating artifact "${relPath}" from step "${refStepId}" ` +
-            `(${content.length} chars → ${MAX_CONTEXT_CHARS} chars)`,
-        );
-        content = content.slice(0, MAX_CONTEXT_CHARS) + "\n...[truncated]";
-      }
-
-      contextBlocks.push(
-        `--- Context from step "${refStepId}" (file: ${relPath}) ---\n${content}\n---`,
-      );
-    }
-  }
-
-  if (contextBlocks.length === 0) {
-    return prompt;
-  }
-
-  return contextBlocks.join("\n\n") + "\n\n" + prompt;
-}

package/src/resources/extensions/gsd/context-store.ts

@@ -1,196 +0,0 @@
-// GSD Context Store — Query Layer & Formatters
-//
-// Typed query functions for decisions and requirements from the DB views,
-// with optional filtering. Format functions produce prompt-injectable markdown.
-// All functions degrade gracefully: return empty results when DB unavailable, never throw.
-
-import { isDbAvailable, _getAdapter } from './gsd-db.js';
-import type { Decision, Requirement } from './types.js';
-
-// ─── Query Functions ───────────────────────────────────────────────────────
-
-export interface DecisionQueryOpts {
-  milestoneId?: string;
-  scope?: string;
-}
-
-export interface RequirementQueryOpts {
-  sliceId?: string;
-  status?: string;
-}
-
-/**
- * Query active (non-superseded) decisions with optional filters.
- * - milestoneId: filters where when_context LIKE '%milestoneId%'
- * - scope: filters where scope = :scope (exact match)
- *
- * Returns [] if DB is not available. Never throws.
- */
-export function queryDecisions(opts?: DecisionQueryOpts): Decision[] {
-  if (!isDbAvailable()) return [];
-  const adapter = _getAdapter();
-  if (!adapter) return [];
-
-  try {
-    const clauses: string[] = ['superseded_by IS NULL'];
-    const params: Record<string, unknown> = {};
-
-    if (opts?.milestoneId) {
-      clauses.push('when_context LIKE :milestone_pattern');
-      params[':milestone_pattern'] = `%${opts.milestoneId}%`;
-    }
-
-    if (opts?.scope) {
-      clauses.push('scope = :scope');
-      params[':scope'] = opts.scope;
-    }
-
-    const sql = `SELECT * FROM decisions WHERE ${clauses.join(' AND ')} ORDER BY seq`;
-    const rows = adapter.prepare(sql).all(params);
-
-    return rows.map(row => ({
-      seq: row['seq'] as number,
-      id: row['id'] as string,
-      when_context: row['when_context'] as string,
-      scope: row['scope'] as string,
-      decision: row['decision'] as string,
-      choice: row['choice'] as string,
-      rationale: row['rationale'] as string,
-      revisable: row['revisable'] as string,
-      made_by: (row['made_by'] as string as import('./types.js').DecisionMadeBy) ?? 'agent',
-      superseded_by: null,
-    }));
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Query active (non-superseded) requirements with optional filters.
- * - sliceId: filters where primary_owner LIKE '%sliceId%' OR supporting_slices LIKE '%sliceId%'
- * - status: filters where status = :status (exact match)
- *
- * Returns [] if DB is not available. Never throws.
- */
-export function queryRequirements(opts?: RequirementQueryOpts): Requirement[] {
-  if (!isDbAvailable()) return [];
-  const adapter = _getAdapter();
-  if (!adapter) return [];
-
-  try {
-    const clauses: string[] = ['superseded_by IS NULL'];
-    const params: Record<string, unknown> = {};
-
-    if (opts?.sliceId) {
-      clauses.push('(primary_owner LIKE :slice_pattern OR supporting_slices LIKE :slice_pattern)');
-      params[':slice_pattern'] = `%${opts.sliceId}%`;
-    }
-
-    if (opts?.status) {
-      clauses.push('status = :status');
-      params[':status'] = opts.status;
-    }
-
-    const sql = `SELECT * FROM requirements WHERE ${clauses.join(' AND ')} ORDER BY id`;
-    const rows = adapter.prepare(sql).all(params);
-
-    return rows.map(row => ({
-      id: row['id'] as string,
-      class: row['class'] as string,
-      status: row['status'] as string,
-      description: row['description'] as string,
-      why: row['why'] as string,
-      source: row['source'] as string,
-      primary_owner: row['primary_owner'] as string,
-      supporting_slices: row['supporting_slices'] as string,
-      validation: row['validation'] as string,
-      notes: row['notes'] as string,
-      full_content: row['full_content'] as string,
-      superseded_by: null,
-    }));
-  } catch {
-    return [];
-  }
-}
-
-// ─── Format Functions ──────────────────────────────────────────────────────
-
-/**
- * Format decisions as a markdown table matching DECISIONS.md format.
- * Returns empty string for empty input.
- */
-export function formatDecisionsForPrompt(decisions: Decision[]): string {
-  if (decisions.length === 0) return '';
-
-  const header = '| # | When | Scope | Decision | Choice | Rationale | Revisable? | Made By |';
-  const separator = '|---|------|-------|----------|--------|-----------|------------|---------|';
-  const rows = decisions.map(d =>
-    `| ${d.id} | ${d.when_context} | ${d.scope} | ${d.decision} | ${d.choice} | ${d.rationale} | ${d.revisable} | ${d.made_by ?? 'agent'} |`,
-  );
-
-  return [header, separator, ...rows].join('\n');
-}
-
-/**
- * Format requirements as structured H3 sections matching REQUIREMENTS.md format.
- * Returns empty string for empty input.
- */
-export function formatRequirementsForPrompt(requirements: Requirement[]): string {
-  if (requirements.length === 0) return '';
-
-  return requirements.map(r => {
-    const lines: string[] = [
-      `### ${r.id}: ${r.description}`,
-      '',
-      `- **Class:** ${r.class}`,
-      `- **Status:** ${r.status}`,
-      `- **Why:** ${r.why}`,
-      `- **Source:** ${r.source}`,
-      `- **Primary Owner:** ${r.primary_owner}`,
-    ];
-
-    if (r.supporting_slices) {
-      lines.push(`- **Supporting Slices:** ${r.supporting_slices}`);
-    }
-
-    lines.push(`- **Validation:** ${r.validation}`);
-
-    if (r.notes) {
-      lines.push(`- **Notes:** ${r.notes}`);
-    }
-
-    return lines.join('\n');
-  }).join('\n\n');
-}
-
-// ─── Artifact Query Functions ──────────────────────────────────────────────
-
-/**
- * Query a hierarchy artifact by its relative path.
- * Returns the full_content string or null if not found/unavailable.
- * Never throws.
- */
-export function queryArtifact(path: string): string | null {
-  if (!isDbAvailable()) return null;
-  const adapter = _getAdapter();
-  if (!adapter) return null;
-
-  try {
-    const row = adapter.prepare('SELECT full_content FROM artifacts WHERE path = :path').get({ ':path': path });
-    if (!row) return null;
-    const content = row['full_content'] as string;
-    return content || null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Query PROJECT.md content from the artifacts table.
- * PROJECT.md is stored with the relative path 'PROJECT.md' by the importer.
- * Returns the content string or null if not found/unavailable.
- * Never throws.
- */
-export function queryProject(): string | null {
-  return queryArtifact('PROJECT.md');
-}

package/src/resources/extensions/gsd/crash-recovery.ts

@@ -1,120 +0,0 @@
-/**
- * GSD Crash Recovery
- *
- * Detects interrupted auto-mode sessions via a lock file.
- * Written on auto-start, updated on each unit dispatch, deleted on clean stop.
- * If the lock file exists on next startup, the previous session crashed.
- *
- * The lock records the pi session file path so crash recovery can read the
- * surviving JSONL (pi appends entries incrementally via appendFileSync,
- * so the file on disk reflects every tool call up to the crash point).
- */
-
-import { readFileSync, unlinkSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { gsdRoot } from "./paths.js";
-import { atomicWriteSync } from "./atomic-write.js";
-import { effectiveLockFile } from "./session-lock.js";
-
-export interface LockData {
-  pid: number;
-  startedAt: string;
-  unitType: string;
-  unitId: string;
-  unitStartedAt: string;
-  /** Path to the pi session JSONL file that was active when this unit started. */
-  sessionFile?: string;
-}
-
-function lockPath(basePath: string): string {
-  return join(gsdRoot(basePath), effectiveLockFile());
-}
-
-/** Write or update the lock file with current auto-mode state. */
-export function writeLock(
-  basePath: string,
-  unitType: string,
-  unitId: string,
-  sessionFile?: string,
-): void {
-  try {
-    const data: LockData = {
-      pid: process.pid,
-      startedAt: new Date().toISOString(),
-      unitType,
-      unitId,
-      unitStartedAt: new Date().toISOString(),
-      sessionFile,
-    };
-    const lp = lockPath(basePath);
-    atomicWriteSync(lp, JSON.stringify(data, null, 2));
-  } catch (e) { /* non-fatal: lock write failure */ void e; }
-}
-
-/** Remove the lock file on clean stop. */
-export function clearLock(basePath: string): void {
-  try {
-    const p = lockPath(basePath);
-    if (existsSync(p)) unlinkSync(p);
-  } catch (e) { /* non-fatal: lock clear failure */ void e; }
-}
-
-/** Check if a crash lock exists and return its data. */
-export function readCrashLock(basePath: string): LockData | null {
-  try {
-    const p = lockPath(basePath);
-    if (!existsSync(p)) return null;
-    const raw = readFileSync(p, "utf-8");
-    return JSON.parse(raw) as LockData;
-  } catch (e) {
-    /* non-fatal: corrupt or unreadable lock file */ void e;
-    return null;
-  }
-}
-
-/**
- * Check whether the process that wrote the lock is still running.
- * Uses `process.kill(pid, 0)` which sends no signal but checks liveness.
- * Returns true if the PID matches our own — we are the lock holder (#2470).
- */
-export function isLockProcessAlive(lock: LockData): boolean {
-  const pid = lock.pid;
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  // Our own PID means WE hold this lock — we are alive. (#2470)
-  // Callers that need to distinguish "our lock" from "someone else's lock"
-  // (e.g. startAuto checking for a prior crashed session with a recycled PID)
-  // already guard with `crashLock.pid !== process.pid` before calling us.
-  if (pid === process.pid) return true;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    // EPERM means the process exists but we lack permission — treat as alive.
-    // ESRCH means the process does not exist — treat as dead (stale lock).
-    if ((err as NodeJS.ErrnoException).code === "EPERM") return true;
-    return false;
-  }
-}
-
-/** Format crash info for display or injection into a prompt. */
-export function formatCrashInfo(lock: LockData): string {
-  const lines = [
-    `Previous auto-mode session was interrupted.`,
-    `  Was executing: ${lock.unitType} (${lock.unitId})`,
-    `  Started at: ${lock.unitStartedAt}`,
-    `  PID: ${lock.pid}`,
-  ];
-
-  // Add recovery guidance based on what was happening when it crashed
-  if (lock.unitType === "starting" && lock.unitId === "bootstrap") {
-    lines.push(`No work was lost. Run /gsd auto to restart.`);
-  } else if (lock.unitType.includes("research") || lock.unitType.includes("plan")) {
-    lines.push(`The ${lock.unitType} unit may be incomplete. Run /gsd auto to re-run it.`);
-  } else if (lock.unitType.includes("execute")) {
-    lines.push(`Task execution was interrupted. Run /gsd auto to resume — completed work is preserved.`);
-  } else if (lock.unitType.includes("complete")) {
-    lines.push(`Slice/milestone completion was interrupted. Run /gsd auto to finish.`);
-  }
-
-  return lines.join("\n");
-}

package/src/resources/extensions/gsd/custom-execution-policy.ts

@@ -1,74 +0,0 @@
-/**
- * custom-execution-policy.ts — ExecutionPolicy for custom workflows.
- *
- * Delegates verification to the step-level verification module which reads
- * the frozen DEFINITION.yaml and dispatches to the appropriate policy handler.
- *
- * Observability:
- * - verify() returns the outcome from runCustomVerification() — four policies
- *   are supported: content-heuristic, shell-command, prompt-verify, human-review.
- * - selectModel() returns null — defers to loop defaults.
- * - recover() returns retry — simple default recovery strategy.
- */
-
-import type { ExecutionPolicy } from "./execution-policy.js";
-import type { RecoveryAction, CloseoutResult } from "./engine-types.js";
-import { runCustomVerification } from "./custom-verification.js";
-import { parseUnitId } from "./unit-id.js";
-
-export class CustomExecutionPolicy implements ExecutionPolicy {
-  private readonly runDir: string;
-
-  constructor(runDir: string) {
-    this.runDir = runDir;
-  }
-
-  /** No workspace preparation needed for custom workflows. */
-  async prepareWorkspace(_basePath: string, _milestoneId: string): Promise<void> {
-    // No-op — custom workflows don't need worktree setup
-  }
-
-  /** Defer model selection to loop defaults. */
-  async selectModel(
-    _unitType: string,
-    _unitId: string,
-    _context: { basePath: string },
-  ): Promise<{ tier: string; modelDowngraded: boolean } | null> {
-    return null;
-  }
-
-  /**
-   * Verify step output by dispatching to the step's configured verification policy.
-   *
-   * Extracts the step ID from unitId (format: "<workflowName>/<stepId>")
-   * and calls runCustomVerification() which reads the frozen DEFINITION.yaml
-   * to determine which policy to apply.
-   */
-  async verify(
-    _unitType: string,
-    unitId: string,
-    _context: { basePath: string },
-  ): Promise<"continue" | "retry" | "pause"> {
-    const { milestone, slice, task } = parseUnitId(unitId);
-    const stepId = task ?? slice ?? milestone;
-    return runCustomVerification(this.runDir, stepId);
-  }
-
-  /** Default recovery: retry the step. */
-  async recover(
-    _unitType: string,
-    _unitId: string,
-    _context: { basePath: string },
-  ): Promise<RecoveryAction> {
-    return { outcome: "retry", reason: "Default retry" };
-  }
-
-  /** No-op closeout — no commits or artifact capture. */
-  async closeout(
-    _unitType: string,
-    _unitId: string,
-    _context: { basePath: string; startedAt: number },
-  ): Promise<CloseoutResult> {
-    return { committed: false, artifacts: [] };
-  }
-}

package/src/resources/extensions/gsd/custom-verification.ts

@@ -1,182 +0,0 @@
-/**
- * custom-verification.ts — Step verification for custom workflows.
- *
- * Reads the frozen DEFINITION.yaml from a run directory, finds the step's
- * `verify` policy, and dispatches to the appropriate handler. Four policies:
- *
- *   - content-heuristic: file existence + optional minSize + optional pattern match
- *   - shell-command: spawnSync with 30s timeout, exit 0 → continue, else retry
- *   - prompt-verify: always "pause" (defers to agent)
- *   - human-review: always "pause" (waits for manual inspection)
- *   - (no policy): returns "continue" (passthrough)
- *
- * Observability:
- * - Return value is the typed verification outcome ("continue" | "retry" | "pause").
- * - shell-command captures stderr from spawnSync — callers can inspect on retry.
- * - content-heuristic logs the specific failure (missing file, below minSize, pattern mismatch).
- * - The frozen DEFINITION.yaml on disk is the single source of truth for step policies.
- */
-
-import { readFileSync, existsSync, statSync } from "node:fs";
-import { join, resolve, sep } from "node:path";
-import { spawnSync } from "node:child_process";
-import type { StepDefinition, VerifyPolicy } from "./definition-loader.js";
-import { readFrozenDefinition } from "./custom-workflow-engine.js";
-import { rewriteCommandWithRtk } from "../shared/rtk.js";
-
-/** Verification outcome type — matches ExecutionPolicy.verify() return type. */
-export type VerificationOutcome = "continue" | "retry" | "pause";
-
-/**
- * Run custom verification for a specific step in a workflow run.
- *
- * Reads the frozen DEFINITION.yaml from `runDir`, finds the step with the
- * given `stepId`, and dispatches to the appropriate verification handler
- * based on the step's `verify.policy` field.
- *
- * @param runDir — absolute path to the workflow run directory
- * @param stepId — the step ID to verify (e.g. "step-1")
- * @returns "continue" if verification passes, "retry" if it should retry, "pause" if it needs review
- * @throws Error if DEFINITION.yaml is missing or unreadable
- */
-export function runCustomVerification(
-  runDir: string,
-  stepId: string,
-): VerificationOutcome {
-  const def = readFrozenDefinition(runDir);
-
-  const step = def.steps.find((s: StepDefinition) => s.id === stepId);
-  if (!step) {
-    // Step not found in definition — nothing to verify, continue
-    return "continue";
-  }
-
-  if (!step.verify) {
-    // No verification policy configured — passthrough
-    return "continue";
-  }
-
-  return dispatchPolicy(runDir, step, step.verify);
-}
-
-/**
- * Dispatch to the correct policy handler.
- */
-function dispatchPolicy(
-  runDir: string,
-  step: StepDefinition,
-  verify: VerifyPolicy,
-): VerificationOutcome {
-  switch (verify.policy) {
-    case "content-heuristic":
-      return handleContentHeuristic(runDir, step, verify);
-    case "shell-command":
-      return handleShellCommand(runDir, verify);
-    case "prompt-verify":
-      return "pause";
-    case "human-review":
-      return "pause";
-    default:
-      // Unknown policy — safe default is pause
-      return "pause";
-  }
-}
-
-/**
- * content-heuristic handler.
- *
- * For each path in the step's `produces` array:
- * 1. Check that the file exists (resolved relative to runDir)
- * 2. If `minSize` is set, check that file size >= minSize bytes
- * 3. If `pattern` is set, check that file content matches the regex
- *
- * Returns "continue" if all checks pass, "pause" if any fail.
- * If `produces` is empty or undefined, returns "continue" (nothing to check).
- */
-function handleContentHeuristic(
-  runDir: string,
-  step: StepDefinition,
-  verify: { policy: "content-heuristic"; minSize?: number; pattern?: string },
-): VerificationOutcome {
-  const produces = step.produces;
-  if (!produces || produces.length === 0) {
-    return "continue";
-  }
-
-  for (const relPath of produces) {
-    const absPath = resolve(runDir, relPath);
-    // Path traversal guard
-    if (!absPath.startsWith(resolve(runDir) + sep) && absPath !== resolve(runDir)) {
-      return "pause";
-    }
-
-    // 1. File existence
-    if (!existsSync(absPath)) {
-      return "pause";
-    }
-
-    // 2. Minimum size check
-    if (verify.minSize !== undefined) {
-      const stat = statSync(absPath);
-      if (stat.size < verify.minSize) {
-        return "pause";
-      }
-    }
-
-    // 3. Pattern match check (with timeout guard against ReDoS)
-    if (verify.pattern !== undefined) {
-      const content = readFileSync(absPath, "utf-8");
-      try {
-        if (!new RegExp(verify.pattern).test(content)) {
-          return "pause";
-        }
-      } catch {
-        // Invalid regex at runtime — treat as verification failure
-        return "pause";
-      }
-    }
-  }
-
-  return "continue";
-}
-
-/**
- * shell-command handler.
- *
- * Runs the command via `sh -c` with cwd set to the run directory
- * and a 30-second timeout. Returns "continue" if exit code 0,
- * "retry" otherwise (including timeout/signal kills).
- *
- * SECURITY: The command string comes from a frozen DEFINITION.yaml written
- * at run-creation time. The trust boundary is the workflow definition author.
- * Commands run with the same privileges as the GSD process. Only use
- * shell-command verification with definitions you trust.
- */
-function handleShellCommand(
-  runDir: string,
-  verify: { policy: "shell-command"; command: string },
-): VerificationOutcome {
-  // Guard: reject commands containing shell expansion patterns that suggest injection
-  const dangerousPatterns = /\$\(|`|;\s*(rm|curl|wget|nc|bash|sh|eval)\b/;
-  if (dangerousPatterns.test(verify.command)) {
-    console.warn(
-      `custom-verification: shell-command contains suspicious pattern, skipping: ${verify.command}`,
-    );
-    return "pause";
-  }
-
-  const rewrittenCommand = rewriteCommandWithRtk(verify.command);
-  const result = spawnSync("sh", ["-c", rewrittenCommand], {
-    cwd: runDir,
-    timeout: 30_000,
-    encoding: "utf-8",
-    stdio: "pipe",
-    env: { ...process.env, PATH: process.env.PATH },
-  });
-
-  if (result.status === 0) {
-    return "continue";
-  }
-
-  return "retry";
-}