gsd-pi 2.26.0 → 2.27.0

package/src/resources/extensions/gsd/tests/visualizer-data.test.ts

@@ -418,7 +418,7 @@ assertTrue(
 );
 
 assertTrue(
-  overlaySrc.includes("0 Health"),
+  overlaySrc.includes("0 Export"),
   "overlay has 10 tab labels",
 );
 

package/src/resources/extensions/gsd/tests/visualizer-overlay.test.ts

@@ -24,18 +24,28 @@ assertTrue(
 );
 
 assertTrue(
-  overlaySrc.includes('"5 Agent"'),
-  "has Agent tab label",
+  overlaySrc.includes('"2 Timeline"'),
+  "has Timeline tab label",
 );
 
 assertTrue(
-  overlaySrc.includes('"6 Changes"'),
-  "has Changes tab label",
+  overlaySrc.includes('"3 Deps"'),
+  "has Deps tab label",
 );
 
 assertTrue(
-  overlaySrc.includes('"7 Export"'),
-  "has Export tab label",
+  overlaySrc.includes('"5 Health"'),
+  "has Health tab label",
+);
+
+assertTrue(
+  overlaySrc.includes('"6 Agent"'),
+  "has Agent tab label",
+);
+
+assertTrue(
+  overlaySrc.includes('"7 Changes"'),
+  "has Changes tab label",
 );
 
 assertTrue(
@@ -49,8 +59,8 @@ assertTrue(
 );
 
 assertTrue(
-  overlaySrc.includes('"0 Health"'),
-  "has Health tab label",
+  overlaySrc.includes('"0 Export"'),
+  "has Export tab label",
 );
 
 console.log("\n=== Overlay: Filter Mode ===");
@@ -162,8 +172,8 @@ assertTrue(
 console.log("\n=== Overlay: Export Key Interception ===");
 
 assertTrue(
-  overlaySrc.includes("activeTab === 6"),
-  "export key handling checks for tab 7 (index 6)",
+  overlaySrc.includes("activeTab === 9"),
+  "export key handling checks for tab 0 (index 9)",
 );
 
 assertTrue(
@@ -200,4 +210,28 @@ assertTrue(
   "scroll offsets sized to TAB_COUNT",
 );
 
+console.log("\n=== Overlay: Terminal Resize Handling ===");
+
+assertTrue(
+  overlaySrc.includes('resizeHandler'),
+  "has resizeHandler property",
+);
+
+assertTrue(
+  overlaySrc.includes('"resize"'),
+  "listens for resize events",
+);
+
+assertTrue(
+  overlaySrc.includes('removeListener("resize"'),
+  "removes resize listener on dispose",
+);
+
+console.log("\n=== Overlay: Shared Imports ===");
+
+assertTrue(
+  overlaySrc.includes('from "../shared/format-utils.js"'),
+  "imports from shared format-utils",
+);
+
 report();

package/src/resources/extensions/gsd/tests/worktree.test.ts

@@ -15,6 +15,7 @@ import {
   SLICE_BRANCH_RE,
 } from "../worktree.ts";
 import { readIntegrationBranch } from "../git-service.ts";
+import { _resetHasChangesCache } from "../native-git-bridge.ts";
 import { createTestContext } from './test-helpers.ts';
 
 const { assertEq, assertTrue, report } = createTestContext();
@@ -40,7 +41,8 @@ async function main(): Promise<void> {
   const cleanResult = autoCommitCurrentBranch(base, "execute-task", "M001/S01/T01");
   assertEq(cleanResult, null, "returns null for clean repo");
 
-  // Make dirty
+  // Make dirty — reset the nativeHasChanges cache so the fresh dirt is detected
+  _resetHasChangesCache();
   writeFileSync(join(base, "dirty.txt"), "uncommitted\n", "utf-8");
   const dirtyResult = autoCommitCurrentBranch(base, "execute-task", "M001/S01/T01");
   assertTrue(dirtyResult !== null, "returns commit message for dirty repo");

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

@@ -46,6 +46,44 @@ export interface TaskPlanEntry {
   verify?: string;     // e.g. "run tests" — extracted from "- Verify:" subline
 }
 
+// ─── Verification Gate ─────────────────────────────────────────────────────
+
+/** Result of a single verification command execution */
+export interface VerificationCheck {
+  command: string;       // e.g. "npm run lint"
+  exitCode: number;      // 0 = pass
+  stdout: string;
+  stderr: string;
+  durationMs: number;
+}
+
+/** A runtime error captured from bg-shell processes or browser console */
+export interface RuntimeError {
+  source: "bg-shell" | "browser";
+  severity: "crash" | "error" | "warning";
+  message: string;
+  blocking: boolean;
+}
+
+/** A dependency vulnerability warning from npm audit */
+export interface AuditWarning {
+  name: string;
+  severity: "low" | "moderate" | "high" | "critical";
+  title: string;
+  url: string;
+  fixAvailable: boolean;
+}
+
+/** Aggregate result from the verification gate */
+export interface VerificationResult {
+  passed: boolean;              // true if all checks passed (or no checks discovered)
+  checks: VerificationCheck[];  // per-command results
+  discoverySource: "preference" | "task-plan" | "package-json" | "none";
+  timestamp: number;            // Date.now() at gate start
+  runtimeErrors?: RuntimeError[];  // optional — populated by captureRuntimeErrors()
+  auditWarnings?: AuditWarning[];  // optional — populated by runDependencyAudit()
+}
+
 export interface SlicePlan {
   id: string;          // e.g. "S01"
   title: string;       // from the H1

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

@@ -0,0 +1,183 @@
+/**
+ * Verification Evidence — JSON persistence and markdown table formatting.
+ *
+ * Two pure-ish functions:
+ *   - writeVerificationJSON: persists a machine-readable T##-VERIFY.json artifact
+ *   - formatEvidenceTable:   returns a markdown evidence table string
+ *
+ * JSON schema uses schemaVersion: 1 for forward-compatibility.
+ * stdout/stderr are intentionally excluded from the JSON to avoid unbounded file sizes.
+ */
+
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { VerificationResult } from "./types.ts";
+
+// ─── JSON Evidence Artifact ──────────────────────────────────────────────────
+
+export interface EvidenceCheckJSON {
+  command: string;
+  exitCode: number;
+  durationMs: number;
+  verdict: "pass" | "fail";
+}
+
+export interface RuntimeErrorJSON {
+  source: string;
+  severity: string;
+  message: string;
+  blocking: boolean;
+}
+
+export interface AuditWarningJSON {
+  name: string;
+  severity: string;
+  title: string;
+  url: string;
+  fixAvailable: boolean;
+}
+
+export interface EvidenceJSON {
+  schemaVersion: 1;
+  taskId: string;
+  unitId: string;
+  timestamp: number;
+  passed: boolean;
+  discoverySource: string;
+  checks: EvidenceCheckJSON[];
+  retryAttempt?: number;
+  maxRetries?: number;
+  runtimeErrors?: RuntimeErrorJSON[];
+  auditWarnings?: AuditWarningJSON[];
+}
+
+/**
+ * Write a T##-VERIFY.json artifact to the tasks directory.
+ * Creates the directory with mkdirSync({ recursive: true }) if it doesn't exist.
+ *
+ * stdout/stderr are excluded from the JSON — the full output lives in VerificationResult
+ * in memory and is logged to stderr during the gate run.
+ */
+export function writeVerificationJSON(
+  result: VerificationResult,
+  tasksDir: string,
+  taskId: string,
+  unitId?: string,
+  retryAttempt?: number,
+  maxRetries?: number,
+): void {
+  mkdirSync(tasksDir, { recursive: true });
+
+  const evidence: EvidenceJSON = {
+    schemaVersion: 1,
+    taskId,
+    unitId: unitId ?? taskId,
+    timestamp: result.timestamp,
+    passed: result.passed,
+    discoverySource: result.discoverySource,
+    checks: result.checks.map((check) => ({
+      command: check.command,
+      exitCode: check.exitCode,
+      durationMs: check.durationMs,
+      verdict: check.exitCode === 0 ? "pass" : "fail",
+    })),
+    ...(retryAttempt !== undefined ? { retryAttempt } : {}),
+    ...(maxRetries !== undefined ? { maxRetries } : {}),
+  };
+
+  if (result.runtimeErrors && result.runtimeErrors.length > 0) {
+    evidence.runtimeErrors = result.runtimeErrors.map(e => ({
+      source: e.source,
+      severity: e.severity,
+      message: e.message,
+      blocking: e.blocking,
+    }));
+  }
+
+  if (result.auditWarnings && result.auditWarnings.length > 0) {
+    evidence.auditWarnings = result.auditWarnings.map(w => ({
+      name: w.name,
+      severity: w.severity,
+      title: w.title,
+      url: w.url,
+      fixAvailable: w.fixAvailable,
+    }));
+  }
+
+  const filePath = join(tasksDir, `${taskId}-VERIFY.json`);
+  writeFileSync(filePath, JSON.stringify(evidence, null, 2) + "\n", "utf-8");
+}
+
+// ─── Markdown Evidence Table ─────────────────────────────────────────────────
+
+/**
+ * Format duration in milliseconds as seconds with 1 decimal place.
+ * e.g. 2340 → "2.3s", 150 → "0.2s", 0 → "0.0s"
+ */
+function formatDuration(ms: number): string {
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+
+/**
+ * Generate a markdown evidence table from a VerificationResult.
+ *
+ * Returns a "no checks" note if result.checks is empty.
+ * Otherwise returns a 5-column markdown table: #, Command, Exit Code, Verdict, Duration.
+ */
+export function formatEvidenceTable(result: VerificationResult): string {
+  if (result.checks.length === 0) {
+    return "_No verification checks discovered._";
+  }
+
+  const lines: string[] = [
+    "| # | Command | Exit Code | Verdict | Duration |",
+    "|---|---------|-----------|---------|----------|",
+  ];
+
+  for (let i = 0; i < result.checks.length; i++) {
+    const check = result.checks[i];
+    const num = i + 1;
+    const verdict =
+      check.exitCode === 0 ? "✅ pass" : "❌ fail";
+    const duration = formatDuration(check.durationMs);
+
+    lines.push(
+      `| ${num} | ${check.command} | ${check.exitCode} | ${verdict} | ${duration} |`,
+    );
+  }
+
+  if (result.runtimeErrors && result.runtimeErrors.length > 0) {
+    lines.push("");
+    lines.push("**Runtime Errors**");
+    lines.push("");
+    lines.push("| # | Source | Severity | Blocking | Message |");
+    lines.push("|---|--------|----------|----------|---------|");
+    for (let i = 0; i < result.runtimeErrors.length; i++) {
+      const err = result.runtimeErrors[i];
+      const blockIcon = err.blocking ? "🚫 yes" : "ℹ️ no";
+      lines.push(`| ${i + 1} | ${err.source} | ${err.severity} | ${blockIcon} | ${err.message.slice(0, 100)} |`);
+    }
+  }
+
+  if (result.auditWarnings && result.auditWarnings.length > 0) {
+    const severityEmoji: Record<string, string> = {
+      critical: "🔴",
+      high: "🟠",
+      moderate: "🟡",
+      low: "⚪",
+    };
+    lines.push("");
+    lines.push("**Audit Warnings**");
+    lines.push("");
+    lines.push("| # | Package | Severity | Title | Fix Available |");
+    lines.push("|---|---------|----------|-------|---------------|");
+    for (let i = 0; i < result.auditWarnings.length; i++) {
+      const w = result.auditWarnings[i];
+      const emoji = severityEmoji[w.severity] ?? "⚪";
+      const fix = w.fixAvailable ? "✅ yes" : "❌ no";
+      lines.push(`| ${i + 1} | ${w.name} | ${emoji} ${w.severity} | ${w.title} | ${fix} |`);
+    }
+  }
+
+  return lines.join("\n");
+}