gsd-pi 2.28.0-dev.e19bf89 → 2.29.0-dev.49d972f

package/dist/resources/extensions/gsd/tests/session-lock.test.ts

@@ -0,0 +1,315 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, writeFileSync, existsSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  acquireSessionLock,
+  releaseSessionLock,
+  updateSessionLock,
+  validateSessionLock,
+  readSessionLockData,
+  isSessionLockHeld,
+  isSessionLockProcessAlive,
+} from "../session-lock.ts";
+
+// ─── acquireSessionLock ──────────────────────────────────────────────────
+
+test("acquireSessionLock succeeds on empty directory", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  const result = acquireSessionLock(dir);
+  assert.equal(result.acquired, true, "should acquire lock on empty dir");
+
+  // Verify lock file was created with correct data
+  const lockPath = join(dir, ".gsd", "auto.lock");
+  assert.ok(existsSync(lockPath), "auto.lock should exist after acquire");
+
+  const data = JSON.parse(readFileSync(lockPath, "utf-8"));
+  assert.equal(data.pid, process.pid, "lock should contain current PID");
+  assert.equal(data.unitType, "starting", "initial unit type should be 'starting'");
+
+  releaseSessionLock(dir);
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("acquireSessionLock rejects when another live process holds lock", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  // Simulate another process holding the lock by writing a lock with parent PID
+  const fakeLockData = {
+    pid: process.ppid,
+    startedAt: new Date().toISOString(),
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    unitStartedAt: new Date().toISOString(),
+    completedUnits: 2,
+  };
+  writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(fakeLockData, null, 2));
+
+  // First acquire to set up proper-lockfile state
+  const result1 = acquireSessionLock(dir);
+
+  // If proper-lockfile is available, it should manage the OS lock.
+  // If not (fallback mode), the PID check should detect the live process.
+  // Either way, we can't fully simulate another process holding an OS lock
+  // from within the same process, so we test the fallback path.
+  if (result1.acquired) {
+    // We got the lock (proper-lockfile saw no OS lock from another process)
+    // This is expected since we're in the same process
+    releaseSessionLock(dir);
+  }
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("acquireSessionLock takes over stale lock from dead process", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  // Write a lock from a dead process
+  const staleLockData = {
+    pid: 9999999,
+    startedAt: "2026-03-01T00:00:00Z",
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    unitStartedAt: "2026-03-01T00:00:00Z",
+    completedUnits: 0,
+  };
+  writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(staleLockData, null, 2));
+
+  const result = acquireSessionLock(dir);
+  assert.equal(result.acquired, true, "should take over lock from dead process");
+
+  // Verify our PID is now in the lock
+  const data = readSessionLockData(dir);
+  assert.ok(data, "lock data should exist after acquire");
+  assert.equal(data!.pid, process.pid, "lock should contain our PID now");
+
+  releaseSessionLock(dir);
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// ─── releaseSessionLock ─────────────────────────────────────────────────
+
+test("releaseSessionLock removes the lock file", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  const result = acquireSessionLock(dir);
+  assert.equal(result.acquired, true);
+
+  releaseSessionLock(dir);
+
+  const lockPath = join(dir, ".gsd", "auto.lock");
+  assert.ok(!existsSync(lockPath), "auto.lock should be removed after release");
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("releaseSessionLock is safe when no lock exists", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  // Should not throw
+  releaseSessionLock(dir);
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// ─── updateSessionLock ──────────────────────────────────────────────────
+
+test("updateSessionLock updates the lock data without re-acquiring", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  const result = acquireSessionLock(dir);
+  assert.equal(result.acquired, true);
+
+  updateSessionLock(dir, "execute-task", "M001/S01/T02", 3, "/tmp/session.jsonl");
+
+  const data = readSessionLockData(dir);
+  assert.ok(data, "lock data should exist after update");
+  assert.equal(data!.pid, process.pid, "PID should still be ours");
+  assert.equal(data!.unitType, "execute-task", "unit type should be updated");
+  assert.equal(data!.unitId, "M001/S01/T02", "unit ID should be updated");
+  assert.equal(data!.completedUnits, 3, "completed count should be updated");
+  assert.equal(data!.sessionFile, "/tmp/session.jsonl", "session file should be recorded");
+
+  releaseSessionLock(dir);
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// ─── validateSessionLock ────────────────────────────────────────────────
+
+test("validateSessionLock returns true when we hold the lock", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  const result = acquireSessionLock(dir);
+  assert.equal(result.acquired, true);
+
+  assert.equal(validateSessionLock(dir), true, "should validate when we hold the lock");
+
+  releaseSessionLock(dir);
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("validateSessionLock returns false after release", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  const result = acquireSessionLock(dir);
+  assert.equal(result.acquired, true);
+  assert.equal(validateSessionLock(dir), true, "should be valid while held");
+
+  // Release the lock — both OS lock and lock file are removed
+  releaseSessionLock(dir);
+
+  // After release, _lockedPath is cleared and lock file is gone
+  assert.equal(isSessionLockHeld(dir), false, "should not be held after release");
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("validateSessionLock returns false when another PID owns the lock", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  // Write lock data with a different PID (parent process)
+  const foreignLockData = {
+    pid: process.ppid,
+    startedAt: new Date().toISOString(),
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    unitStartedAt: new Date().toISOString(),
+    completedUnits: 0,
+  };
+  writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(foreignLockData, null, 2));
+
+  // Without holding the OS lock, validate should check PID
+  assert.equal(validateSessionLock(dir), false, "should fail when another PID owns lock");
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// ─── isSessionLockHeld ──────────────────────────────────────────────────
+
+test("isSessionLockHeld returns true after acquire", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  acquireSessionLock(dir);
+  assert.equal(isSessionLockHeld(dir), true);
+
+  releaseSessionLock(dir);
+  assert.equal(isSessionLockHeld(dir), false, "should return false after release");
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// ─── isSessionLockProcessAlive ──────────────────────────────────────────
+
+test("isSessionLockProcessAlive returns false for dead PID", () => {
+  const data = {
+    pid: 9999999,
+    startedAt: new Date().toISOString(),
+    unitType: "starting",
+    unitId: "bootstrap",
+    unitStartedAt: new Date().toISOString(),
+    completedUnits: 0,
+  };
+  assert.equal(isSessionLockProcessAlive(data), false);
+});
+
+test("isSessionLockProcessAlive returns false for own PID (recycled)", () => {
+  const data = {
+    pid: process.pid,
+    startedAt: new Date().toISOString(),
+    unitType: "starting",
+    unitId: "bootstrap",
+    unitStartedAt: new Date().toISOString(),
+    completedUnits: 0,
+  };
+  // Own PID returns false because it means the lock is from a recycled PID
+  assert.equal(isSessionLockProcessAlive(data), false);
+});
+
+// ─── readSessionLockData ────────────────────────────────────────────────
+
+test("readSessionLockData returns null when no lock exists", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  const data = readSessionLockData(dir);
+  assert.equal(data, null);
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("readSessionLockData reads existing lock data", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  const lockData = {
+    pid: 12345,
+    startedAt: "2026-03-18T00:00:00Z",
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    unitStartedAt: "2026-03-18T00:01:00Z",
+    completedUnits: 2,
+    sessionFile: "/tmp/session.jsonl",
+  };
+  writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(lockData, null, 2));
+
+  const data = readSessionLockData(dir);
+  assert.ok(data, "should read lock data");
+  assert.equal(data!.pid, 12345);
+  assert.equal(data!.unitType, "execute-task");
+  assert.equal(data!.unitId, "M001/S01/T01");
+  assert.equal(data!.completedUnits, 2);
+  assert.equal(data!.sessionFile, "/tmp/session.jsonl");
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// ─── Acquire → Release → Re-Acquire lifecycle ──────────────────────────
+
+test("session lock supports acquire → release → re-acquire cycle", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  // First acquire
+  const r1 = acquireSessionLock(dir);
+  assert.equal(r1.acquired, true, "first acquire should succeed");
+  assert.equal(isSessionLockHeld(dir), true);
+
+  // Release
+  releaseSessionLock(dir);
+  assert.equal(isSessionLockHeld(dir), false);
+
+  // Re-acquire
+  const r2 = acquireSessionLock(dir);
+  assert.equal(r2.acquired, true, "re-acquire after release should succeed");
+  assert.equal(isSessionLockHeld(dir), true);
+
+  releaseSessionLock(dir);
+  rmSync(dir, { recursive: true, force: true });
+});
+
+// ─── Lock creates .gsd/ directory if needed ─────────────────────────────
+
+test("acquireSessionLock creates .gsd/ if it does not exist", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  // Do NOT create .gsd/ — let the lock function do it
+
+  const result = acquireSessionLock(dir);
+  assert.equal(result.acquired, true, "should succeed even without .gsd/");
+  assert.ok(existsSync(join(dir, ".gsd")), ".gsd/ should be created");
+
+  releaseSessionLock(dir);
+  rmSync(dir, { recursive: true, force: true });
+});

package/dist/resources/extensions/gsd/tests/validate-milestone.test.ts

@@ -290,6 +290,61 @@ test("verifyExpectedArtifact fails when VALIDATION.md is missing", () => {
   }
 });
 
+test("verifyExpectedArtifact rejects VALIDATION with missing frontmatter", () => {
+  const base = makeTmpBase();
+  try {
+    // A VALIDATION file without frontmatter should be treated as incomplete —
+    // matching what deriveState expects. Without this, the artifact check passes
+    // but deriveState still returns validating-milestone, causing the hard skip loop.
+    writeValidation(base, "M001", "# Validation\nNo frontmatter here.");
+    clearPathCache();
+    clearParseCache();
+    const result = verifyExpectedArtifact("validate-milestone", "M001", base);
+    assert.equal(result, false, "VALIDATION without frontmatter should fail verification");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact rejects VALIDATION with missing verdict field", () => {
+  const base = makeTmpBase();
+  try {
+    writeValidation(base, "M001", "---\nremediation_round: 0\n---\n\n# Validation");
+    clearPathCache();
+    clearParseCache();
+    const result = verifyExpectedArtifact("validate-milestone", "M001", base);
+    assert.equal(result, false, "VALIDATION without verdict field should fail verification");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact rejects VALIDATION with unrecognized verdict", () => {
+  const base = makeTmpBase();
+  try {
+    writeValidation(base, "M001", "---\nverdict: unknown-value\nremediation_round: 0\n---\n\n# Validation");
+    clearPathCache();
+    clearParseCache();
+    const result = verifyExpectedArtifact("validate-milestone", "M001", base);
+    assert.equal(result, false, "VALIDATION with unrecognized verdict should fail verification");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact passes VALIDATION with needs-attention verdict", () => {
+  const base = makeTmpBase();
+  try {
+    writeValidation(base, "M001", "---\nverdict: needs-attention\nremediation_round: 0\n---\n\n# Validation\nNeeds attention.");
+    clearPathCache();
+    clearParseCache();
+    const result = verifyExpectedArtifact("validate-milestone", "M001", base);
+    assert.equal(result, true, "VALIDATION with needs-attention verdict should pass verification");
+  } finally {
+    cleanup(base);
+  }
+});
+
 // ─── diagnoseExpectedArtifact ─────────────────────────────────────────────
 
 test("diagnoseExpectedArtifact returns validation path for validate-milestone", () => {

package/dist/resources/extensions/gsd/tests/verification-evidence.test.ts

@@ -58,6 +58,7 @@ test("verification-evidence: writeVerificationJSON writes correct JSON shape", (
           stdout: "all good",
           stderr: "",
           durationMs: 2340,
+          blocking: true,
         },
       ],
     });
@@ -105,9 +106,9 @@ test("verification-evidence: writeVerificationJSON maps exitCode to verdict corr
     const result = makeResult({
       passed: false,
       checks: [
-        { command: "lint", exitCode: 0, stdout: "", stderr: "", durationMs: 100 },
-        { command: "test", exitCode: 1, stdout: "", stderr: "fail", durationMs: 200 },
-        { command: "audit", exitCode: 2, stdout: "", stderr: "err", durationMs: 300 },
+        { command: "lint", exitCode: 0, stdout: "", stderr: "", durationMs: 100, blocking: true },
+        { command: "test", exitCode: 1, stdout: "", stderr: "fail", durationMs: 200, blocking: true },
+        { command: "audit", exitCode: 2, stdout: "", stderr: "err", durationMs: 300, blocking: true },
       ],
     });
 
@@ -133,6 +134,7 @@ test("verification-evidence: writeVerificationJSON excludes stdout/stderr from o
           stdout: "hello\n",
           stderr: "some warning",
           durationMs: 50,
+          blocking: true,
         },
       ],
     });
@@ -181,8 +183,8 @@ test("verification-evidence: writeVerificationJSON uses optional unitId when pro
 test("verification-evidence: formatEvidenceTable returns markdown table with correct columns", () => {
   const result = makeResult({
     checks: [
-      { command: "npm run typecheck", exitCode: 0, stdout: "", stderr: "", durationMs: 2340 },
-      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "err", durationMs: 1100 },
+      { command: "npm run typecheck", exitCode: 0, stdout: "", stderr: "", durationMs: 2340, blocking: true },
+      { command: "npm run lint", exitCode: 1, stdout: "", stderr: "err", durationMs: 1100, blocking: true },
     ],
   });
 
@@ -214,9 +216,9 @@ test("verification-evidence: formatEvidenceTable returns no-checks message for e
 test("verification-evidence: formatEvidenceTable formats duration as seconds with 1 decimal", () => {
   const result = makeResult({
     checks: [
-      { command: "fast", exitCode: 0, stdout: "", stderr: "", durationMs: 150 },
-      { command: "slow", exitCode: 0, stdout: "", stderr: "", durationMs: 2340 },
-      { command: "zero", exitCode: 0, stdout: "", stderr: "", durationMs: 0 },
+      { command: "fast", exitCode: 0, stdout: "", stderr: "", durationMs: 150, blocking: true },
+      { command: "slow", exitCode: 0, stdout: "", stderr: "", durationMs: 2340, blocking: true },
+      { command: "zero", exitCode: 0, stdout: "", stderr: "", durationMs: 0, blocking: true },
     ],
   });
 
@@ -230,8 +232,8 @@ test("verification-evidence: formatEvidenceTable uses ✅/❌ emoji for pass/fai
   const result = makeResult({
     passed: false,
     checks: [
-      { command: "pass-cmd", exitCode: 0, stdout: "", stderr: "", durationMs: 100 },
-      { command: "fail-cmd", exitCode: 1, stdout: "", stderr: "", durationMs: 200 },
+      { command: "pass-cmd", exitCode: 0, stdout: "", stderr: "", durationMs: 100, blocking: true },
+      { command: "fail-cmd", exitCode: 1, stdout: "", stderr: "", durationMs: 200, blocking: true },
     ],
   });
 
@@ -335,8 +337,8 @@ test("verification-evidence: integration — VerificationResult → JSON → tab
     const result = makeResult({
       passed: false,
       checks: [
-        { command: "npm run typecheck", exitCode: 0, stdout: "ok", stderr: "", durationMs: 1500 },
-        { command: "npm run test:unit", exitCode: 1, stdout: "", stderr: "1 failed", durationMs: 3200 },
+        { command: "npm run typecheck", exitCode: 0, stdout: "ok", stderr: "", durationMs: 1500, blocking: true },
+        { command: "npm run test:unit", exitCode: 1, stdout: "", stderr: "1 failed", durationMs: 3200, blocking: true },
       ],
       discoverySource: "package-json",
     });
@@ -390,7 +392,7 @@ test("verification-evidence: writeVerificationJSON with retryAttempt and maxRetr
     const result = makeResult({
       passed: false,
       checks: [
-        { command: "npm run lint", exitCode: 1, stdout: "", stderr: "error", durationMs: 300 },
+        { command: "npm run lint", exitCode: 1, stdout: "", stderr: "error", durationMs: 300, blocking: true },
       ],
     });
 
@@ -415,7 +417,7 @@ test("verification-evidence: writeVerificationJSON without retry params omits re
     const result = makeResult({
       passed: true,
       checks: [
-        { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100 },
+        { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100, blocking: true },
       ],
     });
 
@@ -441,7 +443,7 @@ test("verification-evidence: writeVerificationJSON includes runtimeErrors when p
     const result = makeResult({
       passed: false,
       checks: [
-        { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100 },
+        { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100, blocking: true },
       ],
       runtimeErrors: [
         { source: "bg-shell", severity: "crash", message: "Server crashed", blocking: true },
@@ -473,7 +475,7 @@ test("verification-evidence: writeVerificationJSON omits runtimeErrors when abse
     const result = makeResult({
       passed: true,
       checks: [
-        { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 50 },
+        { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 50, blocking: true },
       ],
     });
 
@@ -512,7 +514,7 @@ test("verification-evidence: formatEvidenceTable appends runtime errors section"
   const result = makeResult({
     passed: false,
     checks: [
-      { command: "npm run test", exitCode: 0, stdout: "", stderr: "", durationMs: 100 },
+      { command: "npm run test", exitCode: 0, stdout: "", stderr: "", durationMs: 100, blocking: true },
     ],
     runtimeErrors: [
       { source: "bg-shell", severity: "crash", message: "Server crashed with SIGKILL", blocking: true },
@@ -537,7 +539,7 @@ test("verification-evidence: formatEvidenceTable omits runtime errors section wh
   const result = makeResult({
     passed: true,
     checks: [
-      { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 200 },
+      { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 200, blocking: true },
     ],
   });
 
@@ -552,7 +554,7 @@ test("verification-evidence: formatEvidenceTable truncates runtime error message
   const result = makeResult({
     passed: false,
     checks: [
-      { command: "npm run test", exitCode: 0, stdout: "", stderr: "", durationMs: 100 },
+      { command: "npm run test", exitCode: 0, stdout: "", stderr: "", durationMs: 100, blocking: true },
     ],
     runtimeErrors: [
       { source: "bg-shell", severity: "error", message: longMessage, blocking: false },
@@ -598,7 +600,7 @@ test("verification-evidence: writeVerificationJSON includes auditWarnings when p
     const result = makeResult({
       passed: true,
       checks: [
-        { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100 },
+        { command: "npm run test", exitCode: 0, stdout: "ok", stderr: "", durationMs: 100, blocking: true },
       ],
       auditWarnings: SAMPLE_AUDIT_WARNINGS,
     });
@@ -627,7 +629,7 @@ test("verification-evidence: writeVerificationJSON omits auditWarnings when abse
     const result = makeResult({
       passed: true,
       checks: [
-        { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 50 },
+        { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 50, blocking: true },
       ],
     });
 
@@ -666,7 +668,7 @@ test("verification-evidence: formatEvidenceTable appends audit warnings section"
   const result = makeResult({
     passed: true,
     checks: [
-      { command: "npm run test", exitCode: 0, stdout: "", stderr: "", durationMs: 100 },
+      { command: "npm run test", exitCode: 0, stdout: "", stderr: "", durationMs: 100, blocking: true },
     ],
     auditWarnings: SAMPLE_AUDIT_WARNINGS,
   });
@@ -689,7 +691,7 @@ test("verification-evidence: formatEvidenceTable omits audit warnings section wh
   const result = makeResult({
     passed: true,
     checks: [
-      { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 200 },
+      { command: "npm run lint", exitCode: 0, stdout: "", stderr: "", durationMs: 200, blocking: true },
     ],
   });
 
@@ -705,7 +707,7 @@ test("verification-evidence: integration — VerificationResult with auditWarnin
     const result = makeResult({
       passed: true,
       checks: [
-        { command: "npm run typecheck", exitCode: 0, stdout: "ok", stderr: "", durationMs: 1500 },
+        { command: "npm run typecheck", exitCode: 0, stdout: "ok", stderr: "", durationMs: 1500, blocking: true },
       ],
       auditWarnings: [
         {