@poetic-ai/poetic 1.42.0

package/dist/chunk-XNO4FM6X.js

@@ -0,0 +1,1124 @@
+import {
+  detectHostConcurrencyBudget
+} from "./chunk-PYITM4N2.js";
+import {
+  parseFailureOutput
+} from "./chunk-ACKIPAOJ.js";
+import {
+  parseVerificationErrorsForChannel
+} from "./chunk-WIRN3F75.js";
+import {
+  prepareWorktreeDependencies
+} from "./chunk-5D4A7E3D.js";
+import {
+  runDeterministicTestGateWithArtifacts,
+  runLintOnDiffWithArtifacts
+} from "./chunk-3ZPQLGV7.js";
+import {
+  runTypecheckWithArtifacts
+} from "./chunk-NS2K2GTP.js";
+import {
+  resolveVerificationChannelScope,
+  selectScopedTestCommands
+} from "./chunk-KP6YILMU.js";
+import {
+  createLogger
+} from "./chunk-PFTQBXS6.js";
+import {
+  mkPoeticTempDir
+} from "./chunk-C57KJOUQ.js";
+import {
+  atomicWriteJson
+} from "./chunk-A3YGID55.js";
+import {
+  isProjectSourcePath
+} from "./chunk-UDMS5AD3.js";
+import {
+  tailLines
+} from "./chunk-TSXGRLPR.js";
+import {
+  describeVerificationCommand
+} from "./chunk-2QLYTVYX.js";
+import {
+  getStateDir
+} from "./chunk-UUH2RVKS.js";
+import {
+  POETIC_VALIDATION_SLOTS,
+  readEnv
+} from "./chunk-5DLKYTQX.js";
+
+// src/core/verification/baseline-store.ts
+import { createHash } from "crypto";
+import { mkdir as mkdir2, readFile as readFile2, rm } from "fs/promises";
+import { dirname, join } from "path";
+import { execa } from "execa";
+
+// src/core/verification/validation-slots.ts
+import { randomUUID } from "crypto";
+import * as fs from "fs/promises";
+import path from "path";
+var logger = createLogger("ValidationSlots");
+var STALE_SLOT_MAX_AGE_MS = 30 * 60 * 1e3;
+var SLOT_HARD_CEILING_MS = 2 * 60 * 60 * 1e3;
+var DEFAULT_MAX_WAIT_MS = 5 * 60 * 1e3;
+var DEFAULT_POLL_INTERVAL_MS = 250;
+var POLL_JITTER_MS = 750;
+function defaultValidationSlotDir() {
+  return path.join(getStateDir(), "validation-slots");
+}
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+async function listSlotFiles(slotDir) {
+  const entries = await fs.readdir(slotDir);
+  return entries.filter((name) => name.endsWith(".slot"));
+}
+async function cleanupStaleSlots(slotDir, now) {
+  const names = await listSlotFiles(slotDir);
+  for (const name of names) {
+    const filePath = path.join(slotDir, name);
+    try {
+      const stat2 = await fs.stat(filePath);
+      const ageMs = now - stat2.mtimeMs;
+      if (ageMs > SLOT_HARD_CEILING_MS) {
+        await fs.unlink(filePath);
+        continue;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(await fs.readFile(filePath, "utf8"));
+      } catch {
+        if (ageMs > STALE_SLOT_MAX_AGE_MS) await fs.unlink(filePath);
+        continue;
+      }
+      if (!isPidAlive(parsed.pid)) {
+        await fs.unlink(filePath);
+      }
+    } catch {
+    }
+  }
+}
+async function slotRank(slotDir, ownName) {
+  const names = await listSlotFiles(slotDir);
+  const ranked = [];
+  for (const name of names) {
+    try {
+      const stat2 = await fs.stat(path.join(slotDir, name));
+      ranked.push({ name, mtimeMs: stat2.mtimeMs });
+    } catch {
+    }
+  }
+  ranked.sort((a, b) => a.mtimeMs - b.mtimeMs || a.name.localeCompare(b.name));
+  return ranked.findIndex((entry) => entry.name === ownName);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var degradedWarned = false;
+function warnDegraded(label, reason, context) {
+  if (degradedWarned && reason === "slot-dir-unavailable") return;
+  if (reason === "slot-dir-unavailable") degradedWarned = true;
+  logger.warn(`Validation slot degraded (${reason}); proceeding unpaced`, { label, ...context });
+}
+function resolveHostLimit(explicit) {
+  if (explicit !== void 0) return Math.max(1, Math.floor(explicit));
+  const env = readEnv(POETIC_VALIDATION_SLOTS).value;
+  if (env !== void 0 && Number.isFinite(env)) {
+    if (env <= 0) return null;
+    return Math.floor(env);
+  }
+  return Math.max(1, detectHostConcurrencyBudget().validationSlots);
+}
+async function acquireHostValidationSlot(label, options = {}) {
+  const slotDir = options.slotDir ?? defaultValidationSlotDir();
+  const hostLimit = resolveHostLimit(options.hostLimit);
+  if (hostLimit === null) {
+    return { degraded: false, release: async () => {
+    } };
+  }
+  const maxWaitMs = options.maxWaitMs ?? DEFAULT_MAX_WAIT_MS;
+  const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const ownName = `${process.pid}-${randomUUID()}.slot`;
+  const ownPath = path.join(slotDir, ownName);
+  const deadline = Date.now() + maxWaitMs;
+  try {
+    await fs.mkdir(slotDir, { recursive: true });
+  } catch (error) {
+    warnDegraded(label, "slot-dir-unavailable", { slotDir, error: String(error) });
+    return { degraded: true, release: async () => {
+    } };
+  }
+  let waitedLogged = false;
+  for (; ; ) {
+    try {
+      await cleanupStaleSlots(slotDir, Date.now());
+      const occupied = (await listSlotFiles(slotDir)).length;
+      if (occupied < hostLimit) {
+        const content = {
+          pid: process.pid,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          label
+        };
+        await fs.writeFile(ownPath, JSON.stringify(content), { flag: "wx" });
+        const rank = await slotRank(slotDir, ownName);
+        if (rank >= 0 && rank < hostLimit) {
+          return {
+            degraded: false,
+            release: async () => {
+              try {
+                await fs.unlink(ownPath);
+              } catch {
+              }
+            }
+          };
+        }
+        await fs.unlink(ownPath).catch(() => {
+        });
+      }
+    } catch (error) {
+      warnDegraded(label, "slot-dir-unavailable", { slotDir, error: String(error) });
+      return { degraded: true, release: async () => {
+      } };
+    }
+    if (Date.now() >= deadline) {
+      warnDegraded(label, "wait-deadline", { slotDir, hostLimit, maxWaitMs });
+      return { degraded: true, release: async () => {
+      } };
+    }
+    if (!waitedLogged) {
+      waitedLogged = true;
+      logger.info("Waiting for a host validation slot", { label, hostLimit });
+    }
+    await sleep(pollIntervalMs + Math.floor(Math.random() * POLL_JITTER_MS));
+  }
+}
+async function withValidationSlot(label, fn, options = {}) {
+  const lease = await acquireHostValidationSlot(label, options);
+  try {
+    return await fn();
+  } finally {
+    await lease.release();
+  }
+}
+
+// src/core/verification/baseline-capture.ts
+var BASELINE_SCHEMA_VERSION = 5;
+var DEFAULT_OPTIONS = {
+  gateTimeoutMs: 6e4,
+  changedSinceRef: "",
+  skipTests: false,
+  skipLint: false,
+  outputTailLines: 100,
+  changedFiles: []
+};
+function resolveGateExitCode(rawExitCode, okHint, didNotRun = false) {
+  if (didNotRun) return 0;
+  if (typeof rawExitCode === "number") return rawExitCode;
+  if (okHint === true) return 0;
+  return 1;
+}
+function channelCommands(channel) {
+  if (Array.isArray(channel.commands) && channel.commands.length > 0) return channel.commands;
+  if (channel.command?.trim()) return [channel.command];
+  return [];
+}
+function commandDominanceRank(result) {
+  const status = result.status;
+  if (status === "timeout" || result.exitCode === 124) return 1;
+  if (status === "unavailable") return 2;
+  if (status === "skipped" || status === "passed" || status === "not_run" || result.exitCode === 0) {
+    return 3;
+  }
+  return 0;
+}
+function selectDominantCommandResult(results) {
+  if (results.length === 0) return void 0;
+  let dominant = results[0];
+  let best = commandDominanceRank(dominant);
+  for (let i = 1; i < results.length; i++) {
+    const candidate = results[i];
+    const rank = commandDominanceRank(candidate);
+    if (rank < best) {
+      dominant = candidate;
+      best = rank;
+    }
+  }
+  return dominant;
+}
+function normalizeTypeError(line) {
+  const match = /^(.+?)\((\d+),(\d+)\):\s*error\s+(TS\d+)/.exec(line);
+  if (match) {
+    return `${match[1]}:${match[2]}:${match[3]}:${match[4]}`;
+  }
+  const altMatch = /^(.+?):(\d+):(\d+)\s*-\s*error\s+(TS\d+)/.exec(line);
+  if (altMatch) {
+    return `${altMatch[1]}:${altMatch[2]}:${altMatch[3]}:${altMatch[4]}`;
+  }
+  return null;
+}
+function extractTypeErrors(output) {
+  const errors = [];
+  for (const line of output.split(/\r?\n/)) {
+    const normalized = normalizeTypeError(line);
+    if (normalized) {
+      errors.push(normalized);
+    }
+  }
+  return errors.slice(0, 100);
+}
+function normalizeLintError(line) {
+  const match = /^(.+?):(\d+):(\d+)\s+(?:error|warning)\s+.+?\s+(\S+)\s*$/.exec(line);
+  if (match) {
+    return `${match[1]}:${match[2]}:${match[3]}:${match[4]}`;
+  }
+  return null;
+}
+function extractLintErrors(output) {
+  const errors = [];
+  for (const line of output.split(/\r?\n/)) {
+    const normalized = normalizeLintError(line);
+    if (normalized) {
+      errors.push(normalized);
+    }
+  }
+  return errors.slice(0, 100);
+}
+function extractBiomeLintSignatures(outputTail) {
+  const raw = String(outputTail ?? "").trim();
+  if (!raw) return [];
+  const start = raw.indexOf("{");
+  const end = raw.lastIndexOf("}");
+  const out = /* @__PURE__ */ new Set();
+  if (start >= 0 && end > start) {
+    const candidate = raw.slice(start, end + 1);
+    try {
+      const json = JSON.parse(candidate);
+      const diagnostics = Array.isArray(json?.diagnostics) ? json.diagnostics : [];
+      for (const diag of diagnostics) {
+        const loc = diag?.location;
+        const filePath = loc?.path;
+        if (typeof filePath !== "string" || filePath.trim().length === 0) continue;
+        const category = typeof diag?.category === "string" ? diag.category : typeof diag?.code === "string" ? diag.code : typeof diag?.rule === "string" ? diag.rule : typeof diag?.severity === "string" ? diag.severity : "issue";
+        const span = loc?.span;
+        const lineNum = span?.start != null ? String(span.start.line ?? "") : "";
+        out.add(`${filePath}:${category}${lineNum ? `:${lineNum}` : ""}`);
+      }
+    } catch {
+    }
+  }
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    const eslintMatch = /^(.+?):(\d+):(\d+)\s+(?:error|warning)\s+.+?\s+(\S+)\s*$/.exec(trimmed);
+    if (eslintMatch) {
+      out.add(`${eslintMatch[1]}:${eslintMatch[2]}:${eslintMatch[3]}:${eslintMatch[4]}`);
+      continue;
+    }
+    const biomePrettyMatch = /^(.+?):(\d+):(\d+)\s+([a-z]+\/\S+)(?:\s|$)/.exec(trimmed);
+    if (biomePrettyMatch) {
+      out.add(
+        `${biomePrettyMatch[1]}:${biomePrettyMatch[2]}:${biomePrettyMatch[3]}:${biomePrettyMatch[4]}`
+      );
+    }
+  }
+  return Array.from(out).slice(0, 200);
+}
+function toCommandSummary(capture) {
+  return {
+    command: capture.command,
+    language: capture.language,
+    exitCode: capture.exitCode,
+    parsed: capture.parsed,
+    outputTail: capture.outputTail,
+    ...capture.failedTests ? { failedTests: capture.failedTests } : {},
+    ...capture.testsRun !== void 0 ? {
+      testsRun: capture.testsRun,
+      testsPassed: capture.testsPassed,
+      testsSkipped: capture.testsSkipped
+    } : {}
+  };
+}
+function budgetTimeoutCapture(command) {
+  const language = describeVerificationCommand(command).language;
+  return {
+    command,
+    language,
+    exitCode: 124,
+    parsed: false,
+    outputTail: "timed out (channel budget exhausted)",
+    status: "timeout",
+    durationMs: 0,
+    errors: [],
+    captureError: "Channel budget exhausted before command ran"
+  };
+}
+async function runCommandsSequentially(commands, gateTimeoutMs, runOne) {
+  if (commands.length === 0) {
+    return [await runOne(void 0, gateTimeoutMs)];
+  }
+  let remaining = gateTimeoutMs;
+  const captures = [];
+  for (const command of commands) {
+    if (remaining <= 0) {
+      captures.push(budgetTimeoutCapture(command));
+      continue;
+    }
+    const capture = await runOne(command, remaining);
+    captures.push(capture);
+    remaining = Math.max(0, remaining - Math.max(0, capture.durationMs));
+  }
+  return captures;
+}
+function aggregateBuildCaptures(captures) {
+  const dominant = selectDominantCommandResult(captures) ?? captures[0];
+  const errors = Array.from(new Set(captures.flatMap((c) => c.errors))).slice(0, 100);
+  const captureErrors = captures.map((c) => c.captureError).filter(Boolean);
+  return {
+    result: {
+      exitCode: dominant?.exitCode ?? 0,
+      count: errors.length,
+      errors,
+      signaturesParseable: dominant?.parsed ?? true,
+      // Representative tail only — full per-command tails live in `commands`.
+      outputTail: dominant?.outputTail ?? ""
+    },
+    captureError: captureErrors[0],
+    language: dominant?.language ?? "unknown",
+    parsed: dominant?.parsed ?? true,
+    commands: captures.map(toCommandSummary)
+  };
+}
+function aggregateLintCaptures(captures) {
+  const dominant = selectDominantCommandResult(captures) ?? captures[0];
+  const errors = Array.from(new Set(captures.flatMap((c) => c.errors))).slice(0, 200);
+  const captureErrors = captures.map((c) => c.captureError).filter(Boolean);
+  return {
+    result: {
+      exitCode: dominant?.exitCode ?? 0,
+      count: errors.length,
+      errors,
+      signaturesParseable: dominant?.parsed ?? true,
+      outputTail: dominant?.outputTail ?? ""
+    },
+    captureError: captureErrors[0],
+    language: dominant?.language ?? "unknown",
+    parsed: dominant?.parsed ?? true,
+    commands: captures.map(toCommandSummary)
+  };
+}
+function aggregateTestCaptures(captures) {
+  const dominant = selectDominantCommandResult(captures) ?? captures[0];
+  const failedTests = Array.from(new Set(captures.flatMap((c) => c.failedTests ?? [])));
+  const captureErrors = captures.map((c) => c.captureError).filter(Boolean);
+  const comparable = captures.every((capture) => capture.testsRun !== void 0);
+  return {
+    result: {
+      exitCode: dominant?.exitCode ?? 0,
+      passed: comparable ? captures.reduce((sum, capture) => sum + (capture.testsPassed ?? 0), 0) : 0,
+      failed: comparable ? captures.reduce((sum, capture) => sum + (capture.testsFailed ?? 0), 0) : 0,
+      ...comparable ? {
+        run: captures.reduce((sum, capture) => sum + (capture.testsRun ?? 0), 0),
+        skipped: captures.reduce((sum, capture) => sum + (capture.testsSkipped ?? 0), 0)
+      } : {},
+      failedTests,
+      outputTail: dominant?.outputTail ?? ""
+    },
+    captureError: captureErrors[0],
+    language: dominant?.language ?? "unknown",
+    parsed: dominant?.parsed ?? true,
+    commands: captures.map(toCommandSummary)
+  };
+}
+async function captureTypecheckOnce(worktreePath, timeoutMs, outputTailLines, scopedCommand) {
+  const started = Date.now();
+  const artifact = await runTypecheckWithArtifacts(worktreePath, {
+    timeoutMs,
+    tailLines: Math.max(50, outputTailLines),
+    ...scopedCommand ? { command: scopedCommand } : {}
+  });
+  const output = String(artifact.output ?? artifact.outputTail ?? "");
+  const exitCode = resolveGateExitCode(artifact.exitCode, artifact.ok);
+  const failed = exitCode !== 0;
+  const language = artifact.language ?? describeVerificationCommand(artifact.command ?? "").language;
+  const parsedResult = parseVerificationErrorsForChannel("build", language, output, failed);
+  const errors = extractTypeErrors(output);
+  const captureError = exitCode === 124 ? "Typecheck timed out during baseline capture" : (artifact.command ?? "").trim().length === 0 ? "Typecheck command missing during baseline capture" : artifact.exitCode == null && artifact.ok !== true ? "Typecheck command did not exit cleanly during baseline capture (fail-closed)" : void 0;
+  const status = exitCode === 124 ? "timeout" : exitCode === 0 ? "passed" : "failed";
+  return {
+    command: artifact.command ?? scopedCommand ?? "",
+    language,
+    exitCode,
+    parsed: parsedResult.parsed,
+    outputTail: tailLines(output, outputTailLines),
+    status,
+    durationMs: artifact.durationMs ?? Math.max(0, Date.now() - started),
+    errors,
+    captureError
+  };
+}
+async function captureLintOnce(worktreePath, sinceRef, timeoutMs, outputTailLines, scopedCommand) {
+  const started = Date.now();
+  const artifact = await runLintOnDiffWithArtifacts(worktreePath, {
+    baseBranch: sinceRef,
+    timeoutMs,
+    tailLines: Math.max(50, outputTailLines),
+    ...scopedCommand ? { command: scopedCommand } : {}
+  });
+  const outputTail = tailLines(artifact.outputTail, outputTailLines);
+  const okHint = artifact.result === null ? void 0 : artifact.exitCode === 0;
+  const exitCode = resolveGateExitCode(artifact.exitCode, okHint);
+  const failed = exitCode !== 0;
+  const language = artifact.language ?? describeVerificationCommand(artifact.command ?? "").language;
+  const parsedResult = parseVerificationErrorsForChannel(
+    "lint",
+    language,
+    artifact.outputTail ?? "",
+    failed
+  );
+  const biome = extractBiomeLintSignatures(artifact.outputTail ?? "");
+  const errors = biome.length > 0 ? biome : extractLintErrors(artifact.outputTail ?? "");
+  const captureError = exitCode === 124 ? "Lint timed out during baseline capture" : failed && artifact.result === null ? "Lint gate returned no parseable result during baseline capture" : void 0;
+  const status = exitCode === 124 ? "timeout" : exitCode === 0 ? "passed" : "failed";
+  return {
+    command: artifact.command ?? scopedCommand ?? "",
+    language,
+    exitCode,
+    parsed: parsedResult.parsed,
+    outputTail,
+    status,
+    durationMs: artifact.durationMs ?? Math.max(0, Date.now() - started),
+    errors,
+    captureError
+  };
+}
+async function captureTestsOnce(worktreePath, sinceRef, timeoutMs, outputTailLines, scopedCommand) {
+  const started = Date.now();
+  const artifact = await runDeterministicTestGateWithArtifacts(worktreePath, {
+    baseRef: sinceRef,
+    timeoutMs,
+    tailLines: Math.max(50, outputTailLines),
+    ...scopedCommand ? { command: scopedCommand } : {}
+  });
+  const status = artifact.status ?? "failed";
+  const ranAndFailed = status === "failed" || status === "error" || status === "timeout";
+  const didNotRun = status === "unavailable" || status === "skipped";
+  const okHint = !ranAndFailed;
+  const exitCode = resolveGateExitCode(artifact.exitCode, okHint, didNotRun);
+  const outputTail = tailLines(artifact.outputTail ?? "", outputTailLines);
+  const language = artifact.language ?? describeVerificationCommand(artifact.command ?? "").language;
+  const parsedResult = parseVerificationErrorsForChannel(
+    "test",
+    language,
+    outputTail,
+    exitCode !== 0,
+    artifact.failingTests ?? []
+  );
+  const parsedCounts = parseFailureOutput(
+    artifact.command ?? scopedCommand ?? "",
+    outputTail,
+    "test"
+  );
+  const suiteFootprint = parsedCounts.parsed ? parsedCounts.suiteFootprint : void 0;
+  const failedCount = suiteFootprint && parsedCounts.errorCount !== null ? parsedCounts.errorCount : void 0;
+  const captureError = status === "timeout" ? "Tests timed out during baseline capture" : status === "error" ? "Tests errored during baseline capture" : ranAndFailed && artifact.exitCode == null ? "Tests reported failure without a clean exit during baseline capture (fail-closed)" : void 0;
+  return {
+    command: artifact.command ?? scopedCommand ?? "",
+    language,
+    exitCode,
+    parsed: parsedResult.parsed,
+    outputTail,
+    status: didNotRun ? "unavailable" : status,
+    durationMs: artifact.durationMs ?? Math.max(0, Date.now() - started),
+    errors: [],
+    failedTests: artifact.failingTests ?? [],
+    ...suiteFootprint && failedCount !== void 0 ? {
+      testsRun: suiteFootprint.executed + suiteFootprint.skipped,
+      testsPassed: Math.max(0, suiteFootprint.executed - failedCount),
+      testsFailed: failedCount,
+      testsSkipped: suiteFootprint.skipped
+    } : {},
+    captureError
+  };
+}
+async function captureVerificationBaseline(worktreePath, baselineRef, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const startTime = Date.now();
+  const captureErrors = [];
+  const sinceRef = opts.changedSinceRef && opts.changedSinceRef.trim().length > 0 ? opts.changedSinceRef.trim() : baselineRef;
+  const scope = resolveVerificationChannelScope(worktreePath, opts.changedFiles);
+  const buildCommands = channelCommands(scope.build);
+  const lintCommands = channelCommands(scope.lint);
+  const testCommands = selectScopedTestCommands(scope);
+  const buildRelevant = scope.build.relevant;
+  const lintRelevant = scope.lint.relevant;
+  const testRelevant = scope.test.relevant;
+  const buildUnavailable = scope.build.availability === "unavailable";
+  const lintUnavailable = scope.lint.availability === "unavailable";
+  const testUnavailable = scope.test.availability === "unavailable";
+  const skippedChannel = (result, reason) => ({
+    result,
+    captureError: void 0,
+    language: "unknown",
+    parsed: true,
+    commands: [
+      {
+        command: "",
+        language: "unknown",
+        exitCode: 0,
+        parsed: true,
+        outputTail: reason
+      }
+    ]
+  });
+  const [typecheck, lint, tests] = await withValidationSlot(
+    `baseline:${worktreePath}`,
+    () => Promise.all([
+      buildRelevant ? runCommandsSequentially(
+        buildCommands,
+        opts.gateTimeoutMs,
+        (command, timeoutMs) => captureTypecheckOnce(worktreePath, timeoutMs, opts.outputTailLines, command)
+      ).then(aggregateBuildCaptures) : Promise.resolve(
+        skippedChannel(
+          {
+            exitCode: 0,
+            count: 0,
+            errors: [],
+            outputTail: buildUnavailable ? "verification unavailable" : "not task-relevant"
+          },
+          buildUnavailable ? "verification unavailable" : "not task-relevant"
+        )
+      ),
+      opts.skipLint || !lintRelevant ? Promise.resolve(
+        skippedChannel(
+          {
+            exitCode: 0,
+            count: 0,
+            errors: [],
+            outputTail: lintUnavailable ? "verification unavailable" : lintRelevant ? "skipped" : "not task-relevant"
+          },
+          lintUnavailable ? "verification unavailable" : lintRelevant ? "skipped" : "not task-relevant"
+        )
+      ) : runCommandsSequentially(
+        lintCommands,
+        opts.gateTimeoutMs,
+        (command, timeoutMs) => captureLintOnce(worktreePath, sinceRef, timeoutMs, opts.outputTailLines, command)
+      ).then(aggregateLintCaptures),
+      opts.skipTests || !testRelevant ? Promise.resolve({
+        result: {
+          exitCode: 0,
+          passed: 0,
+          failed: 0,
+          failedTests: [],
+          outputTail: testUnavailable ? "verification unavailable" : testRelevant ? "skipped" : "not task-relevant"
+        },
+        captureError: void 0,
+        language: "unknown",
+        parsed: true,
+        commands: [
+          {
+            command: "",
+            language: "unknown",
+            exitCode: 0,
+            parsed: true,
+            outputTail: testUnavailable ? "verification unavailable" : testRelevant ? "skipped" : "not task-relevant"
+          }
+        ]
+      }) : runCommandsSequentially(
+        testCommands,
+        opts.gateTimeoutMs,
+        (command, timeoutMs) => captureTestsOnce(worktreePath, sinceRef, timeoutMs, opts.outputTailLines, command)
+      ).then(aggregateTestCaptures)
+    ]),
+    // Same bound as runDeterministicGates: the slot wait must scale with the
+    // caller's own gate budget so pacing cannot breach an outer deadline.
+    { maxWaitMs: Math.min(5 * 60 * 1e3, Math.max(5e3, opts.gateTimeoutMs * 3)) }
+  );
+  if (typecheck.captureError) captureErrors.push(typecheck.captureError);
+  if (lint.captureError) captureErrors.push(lint.captureError);
+  if (tests.captureError) captureErrors.push(tests.captureError);
+  const durationMs = Date.now() - startTime;
+  const gateSummary = {
+    build: {
+      exitCode: typecheck.result.exitCode,
+      parsed: typecheck.parsed,
+      language: typecheck.language,
+      commands: typecheck.commands,
+      availability: buildUnavailable ? "unavailable" : buildRelevant ? "executed" : "out_of_scope"
+    },
+    lint: {
+      exitCode: lint.result.exitCode,
+      parsed: lint.parsed,
+      language: lint.language,
+      commands: lint.commands,
+      availability: lintUnavailable ? "unavailable" : lintRelevant && !opts.skipLint ? "executed" : "out_of_scope"
+    },
+    test: {
+      exitCode: tests.result.exitCode,
+      parsed: tests.parsed,
+      language: tests.language,
+      commands: tests.commands,
+      availability: testUnavailable ? "unavailable" : testRelevant && !opts.skipTests ? "executed" : "out_of_scope"
+    }
+  };
+  const regressionCount = Number(gateSummary.build.exitCode !== 0) + Number(gateSummary.lint.exitCode !== 0) + Number(gateSummary.test.exitCode !== 0);
+  const sentinelPresent = gateSummary.build.exitCode !== 0 && !gateSummary.build.parsed || gateSummary.lint.exitCode !== 0 && !gateSummary.lint.parsed || gateSummary.test.exitCode !== 0 && !gateSummary.test.parsed;
+  const perLanguage = Array.from(
+    new Set(
+      [
+        ...typecheck.commands.map((c) => c.language),
+        ...lint.commands.map((c) => c.language),
+        ...tests.commands.map((c) => c.language)
+      ].filter((language) => language && language !== "unknown")
+    )
+  );
+  return {
+    baselineRef,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    testResults: tests.result,
+    typeErrors: typecheck.result,
+    lintErrors: lint.result,
+    metadata: {
+      durationMs,
+      captureSucceeded: captureErrors.length === 0,
+      captureErrors
+    },
+    summary: {
+      schemaVersion: BASELINE_SCHEMA_VERSION,
+      regressionCount,
+      sentinelPresent,
+      perLanguage,
+      gates: gateSummary
+    }
+  };
+}
+function createEmptyBaseline(baselineRef, reason) {
+  return {
+    baselineRef,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    testResults: {
+      exitCode: 0,
+      passed: 0,
+      failed: 0,
+      failedTests: [],
+      outputTail: ""
+    },
+    typeErrors: {
+      exitCode: 0,
+      count: 0,
+      errors: [],
+      signaturesParseable: true,
+      outputTail: ""
+    },
+    lintErrors: {
+      exitCode: 0,
+      count: 0,
+      errors: [],
+      signaturesParseable: true,
+      outputTail: ""
+    },
+    metadata: {
+      durationMs: 0,
+      captureSucceeded: false,
+      captureErrors: [reason]
+    },
+    summary: {
+      schemaVersion: BASELINE_SCHEMA_VERSION,
+      regressionCount: 0,
+      sentinelPresent: false,
+      perLanguage: [],
+      gates: {
+        build: { exitCode: 0, parsed: true, language: "unknown", commands: [] },
+        lint: { exitCode: 0, parsed: true, language: "unknown", commands: [] },
+        test: { exitCode: 0, parsed: true, language: "unknown", commands: [] }
+      }
+    }
+  };
+}
+
+// src/core/verification/baseline-store.ts
+function scopeHash(changedFiles) {
+  if (!changedFiles || changedFiles.length === 0) return "";
+  const sorted = [...changedFiles].map((file) => file.trim()).filter(Boolean).sort();
+  if (sorted.length === 0) return "";
+  return createHash("sha256").update(sorted.join("\n")).digest("hex").slice(0, 12);
+}
+function cachePathForBaseline(cacheDir, baselineRef, changedSinceRef, changedFiles) {
+  const scope = scopeHash(changedFiles);
+  const scopeSuffix = scope ? `--scope-${scope}` : "";
+  if (changedSinceRef && changedSinceRef !== baselineRef) {
+    return join(cacheDir, `${baselineRef}--since-${changedSinceRef}${scopeSuffix}.json`);
+  }
+  return join(cacheDir, `${baselineRef}${scopeSuffix}.json`);
+}
+async function ensureNodeModulesForBaselineWorktree(repoRoot, worktreePath) {
+  await prepareWorktreeDependencies({ repoRoot, worktreePath, bestEffort: true });
+}
+function isFreshSchemaBaseline(cached) {
+  if (cached.metadata?.captureSucceeded !== true) return false;
+  if (!cached.summary) return false;
+  return cached.summary.schemaVersion === BASELINE_SCHEMA_VERSION;
+}
+async function readCachedBaseline(path3) {
+  try {
+    const raw = await readFile2(path3, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    if (typeof parsed.baselineRef !== "string") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeCachedBaseline(path3, baseline) {
+  await atomicWriteJson(path3, baseline);
+}
+async function addDetachedWorktree(repoRoot, ref) {
+  const base = await mkPoeticTempDir("baseline-worktree");
+  const worktreePath = join(base, ref.slice(0, 12));
+  const result = await execa("git", ["worktree", "add", "--detach", worktreePath, ref], {
+    cwd: repoRoot,
+    reject: false,
+    stdio: "pipe"
+  });
+  if ((result.exitCode ?? 0) !== 0) {
+    await rm(base, { recursive: true, force: true });
+    throw new Error(
+      `Failed to create baseline worktree for ${ref}: ${String(result.stderr ?? result.stdout ?? "")}`
+    );
+  }
+  try {
+    await ensureNodeModulesForBaselineWorktree(repoRoot, worktreePath);
+  } catch (error) {
+    await removeDetachedWorktree(repoRoot, worktreePath);
+    throw error;
+  }
+  return worktreePath;
+}
+async function removeDetachedWorktree(repoRoot, worktreePath) {
+  try {
+    await execa("git", ["worktree", "remove", "--force", worktreePath], {
+      cwd: repoRoot,
+      reject: false,
+      stdio: "pipe"
+    });
+  } finally {
+    const parent = dirname(worktreePath);
+    await rm(parent, { recursive: true, force: true });
+  }
+}
+async function getOrCaptureVerificationBaseline(options) {
+  const cacheFile = cachePathForBaseline(
+    options.cacheDir,
+    options.baselineRef,
+    options.captureOptions?.changedSinceRef,
+    options.captureOptions?.changedFiles
+  );
+  const cached = await readCachedBaseline(cacheFile);
+  if (cached && cached.baselineRef === options.baselineRef && isFreshSchemaBaseline(cached)) {
+    return cached;
+  }
+  await mkdir2(options.cacheDir, { recursive: true });
+  let worktreePath = null;
+  try {
+    worktreePath = await addDetachedWorktree(options.repoRoot, options.baselineRef);
+    const baseline = await captureVerificationBaseline(worktreePath, options.baselineRef, {
+      ...options.captureOptions,
+      // Default anchor matches baselineRef unless caller overrides.
+      changedSinceRef: options.captureOptions?.changedSinceRef ?? options.baselineRef
+    });
+    await writeCachedBaseline(cacheFile, baseline);
+    return baseline;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return createEmptyBaseline(options.baselineRef, message);
+  } finally {
+    if (worktreePath) {
+      await removeDetachedWorktree(options.repoRoot, worktreePath);
+    }
+  }
+}
+
+// src/core/verification/known-pre-existing-failures.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+var logger2 = createLogger("KnownPreExistingFailures");
+var MIN_ERROR_FINGERPRINT_LENGTH = 4;
+var EMPTY_REGISTRY = Object.freeze({
+  schemaVersion: 1,
+  generatedAt: "",
+  baseCommit: "",
+  failures: []
+});
+var _cachedRegistry;
+async function loadKnownPreExistingFailures(repoRoot = process.cwd()) {
+  if (_cachedRegistry !== void 0) {
+    return _cachedRegistry;
+  }
+  const registryPath = process.env.POETIC_KNOWN_FAILURES_PATH ?? path2.join(repoRoot, ".poetic", "verification", "known-pre-existing-failures.json");
+  let raw;
+  try {
+    raw = await fs2.readFile(registryPath, "utf-8");
+  } catch (err) {
+    const isNotFound = err instanceof Error && "code" in err && err.code === "ENOENT";
+    if (!isNotFound) {
+      logger2.warn("Failed to read known-pre-existing-failures registry", {
+        registryPath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+    _cachedRegistry = { ...EMPTY_REGISTRY };
+    return _cachedRegistry;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.failures)) {
+      throw new Error("Registry JSON does not match expected shape");
+    }
+    const registry = parsed;
+    const validFailures = registry.failures.filter(isValidKnownFailureEntry);
+    if (validFailures.length !== registry.failures.length) {
+      logger2.warn("Ignoring invalid known-pre-existing-failures registry entries", {
+        registryPath,
+        ignoredCount: registry.failures.length - validFailures.length
+      });
+    }
+    _cachedRegistry = {
+      ...registry,
+      failures: validFailures
+    };
+    logger2.debug("Loaded known-pre-existing-failures registry", {
+      registryPath,
+      entryCount: _cachedRegistry.failures.length,
+      baseCommit: _cachedRegistry.baseCommit
+    });
+    return _cachedRegistry;
+  } catch (err) {
+    logger2.warn("Malformed known-pre-existing-failures registry \u2014 treating as empty", {
+      registryPath,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    _cachedRegistry = { ...EMPTY_REGISTRY };
+    return _cachedRegistry;
+  }
+}
+function isValidKnownFailureEntry(entry) {
+  return normalizeFingerprint(entry.errorFingerprint) !== null;
+}
+function normalizeFingerprint(fingerprint) {
+  const normalized = fingerprint?.trim();
+  if (!normalized || normalized.length < MIN_ERROR_FINGERPRINT_LENGTH) {
+    return null;
+  }
+  return normalized.toLowerCase();
+}
+function detectRuntimeEnvironment() {
+  if (process.env.CLAUDECODE === "1" || process.env.CLAUDE_CODE === "true" || process.env.AI_SDK === "claude-code") {
+    return "claude-code";
+  }
+  if (process.env.CI === "true" || process.env.CI === "1" || process.env.GITHUB_ACTIONS === "true" || process.env.CIRCLECI === "true" || process.env.TRAVIS === "true") {
+    return "ci";
+  }
+  return "local";
+}
+function looksLikeProjectFileToken(token) {
+  const trimmed = token.trim();
+  if (trimmed.length === 0) return false;
+  if (isProjectSourcePath(trimmed)) return true;
+  return (trimmed.includes("/") || trimmed.includes("\\")) && !/\s/.test(trimmed);
+}
+function parseLiveFailure(raw) {
+  const trimmed = raw.trim();
+  for (const separator of [/\s*>\s*/, /::/]) {
+    const match = separator.exec(trimmed);
+    if (!match || match.index <= 0) continue;
+    const head = trimmed.slice(0, match.index).trim();
+    const tail = trimmed.slice(match.index + match[0].length).trim();
+    if (looksLikeProjectFileToken(head) && tail.length > 0) {
+      return { file: head, testPath: tail, raw };
+    }
+  }
+  const goMatch = /^(.+?):(\d+)$/.exec(trimmed);
+  if (goMatch && looksLikeProjectFileToken(goMatch[1] ?? "")) {
+    return { file: (goMatch[1] ?? "").trim(), testPath: trimmed, raw };
+  }
+  return { file: "", testPath: trimmed, raw };
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var VITEST_FAILURE_MARKER_SOURCE = "(?:\\s*(?:FAIL|FAILURES?|FAILED)\\s+)?[^\\n]*\\.(?:test|spec)\\.[jt]sx?\\s*>\\s+";
+var GENERIC_FAILURE_MARKER_SOURCE = "(?:\\s*(?:FAIL|FAILURES?|FAILED)\\s+)?[^\\n\\s]*[\\\\/][^\\n\\s]*(?:::|\\s>\\s)";
+function findNextFailureMarker(output, startIndex) {
+  const rest = output.slice(startIndex + 1);
+  const match = new RegExp(
+    `\\n(?:${VITEST_FAILURE_MARKER_SOURCE}|${GENERIC_FAILURE_MARKER_SOURCE})`,
+    "i"
+  ).exec(rest);
+  return match ? startIndex + 1 + match.index : output.length;
+}
+function hasFailureMarkers(output) {
+  return new RegExp(
+    `(?:^|\\n)(?:${VITEST_FAILURE_MARKER_SOURCE}|${GENERIC_FAILURE_MARKER_SOURCE})`,
+    "i"
+  ).test(output);
+}
+function extractScopedFailureOutput(live, testOutputTail) {
+  const rawNeedle = live.raw.trim();
+  const candidates = [
+    rawNeedle,
+    live.file && live.testPath ? `${live.file} > ${live.testPath}` : "",
+    live.testPath
+  ].filter((candidate) => candidate.length > 0);
+  for (const candidate of candidates) {
+    const markerPattern = new RegExp(
+      `(?:^|\\n)[^\\n]*${escapeRegExp(candidate)}(?:\\s+\\([^\\n)]*\\))?\\s*(?=\\n|$)`,
+      "i"
+    );
+    const marker = markerPattern.exec(testOutputTail);
+    if (!marker || marker.index === void 0) continue;
+    const start = marker.index;
+    const end = findNextFailureMarker(testOutputTail, start);
+    return testOutputTail.slice(start, end);
+  }
+  return null;
+}
+function matchesRegisteredFailure(live, entry, testOutputTail, runtimeEnvironment = detectRuntimeEnvironment()) {
+  if (live.file !== entry.file) {
+    return false;
+  }
+  const normalizedPath = live.testPath.trim();
+  const normalizedName = entry.testName.trim();
+  if (!normalizedPath.startsWith(normalizedName)) {
+    return false;
+  }
+  const fingerprint = normalizeFingerprint(entry.errorFingerprint);
+  if (!fingerprint) {
+    return false;
+  }
+  const scopedOutput = extractScopedFailureOutput(live, testOutputTail);
+  if (!scopedOutput && hasFailureMarkers(testOutputTail)) {
+    return false;
+  }
+  const searchableOutput = scopedOutput ?? testOutputTail;
+  if (!searchableOutput.toLowerCase().includes(fingerprint)) return false;
+  if (entry.environments !== void 0 && entry.environments.length > 0) {
+    if (!entry.environments.includes(runtimeEnvironment)) {
+      return false;
+    }
+  }
+  return true;
+}
+function allFailuresAreRegistered(liveFailures, registry, testOutputTail, runtimeEnvironment = detectRuntimeEnvironment()) {
+  if (liveFailures.length === 0) return true;
+  if (registry.failures.length === 0) return false;
+  for (const raw of liveFailures) {
+    const live = parseLiveFailure(raw);
+    const matched = registry.failures.some(
+      (entry) => matchesRegisteredFailure(live, entry, testOutputTail, runtimeEnvironment)
+    );
+    if (!matched) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/core/verification/types.ts
+var VERIFICATION_OUTCOME_CONTRACT_VERSION = 1;
+function outcomeStatus(status, exitCode) {
+  return status ?? (exitCode === 0 ? "passed" : "failed");
+}
+function outcomeLanguage(language) {
+  return language ?? "unknown";
+}
+function verificationOutcomesFromGateArtifacts(gates, options = {}) {
+  const testTotals = gates.tests ? comparableTestTotals(gates.tests) : void 0;
+  const build = {
+    channel: "build",
+    status: outcomeStatus(gates.build.status, gates.build.exitCode),
+    exitCode: gates.build.exitCode,
+    outputTail: gates.build.outputTail,
+    language: outcomeLanguage(gates.build.language),
+    parserVersion: VERIFICATION_OUTCOME_CONTRACT_VERSION,
+    command: gates.build.command,
+    commandProvenance: {
+      command: gates.build.command,
+      cwd: options.cwd,
+      source: options.source ?? "deterministic-gate"
+    },
+    stdoutTail: gates.build.stdoutTail,
+    stderrTail: gates.build.stderrTail,
+    verificationCoverage: gates.build.verificationCoverage,
+    commandResults: gates.build.commandResults
+  };
+  return {
+    build,
+    lint: gates.lint ? {
+      channel: "lint",
+      status: outcomeStatus(gates.lint.status, gates.lint.exitCode),
+      exitCode: gates.lint.exitCode,
+      outputTail: gates.lint.outputTail,
+      language: outcomeLanguage(gates.lint.language),
+      parserVersion: VERIFICATION_OUTCOME_CONTRACT_VERSION,
+      command: gates.lint.command,
+      commandProvenance: {
+        command: gates.lint.command,
+        cwd: options.cwd,
+        source: options.source ?? "deterministic-gate"
+      },
+      verificationCoverage: gates.lint.verificationCoverage,
+      commandResults: gates.lint.commandResults
+    } : void 0,
+    tests: gates.tests ? {
+      channel: "test",
+      status: outcomeStatus(gates.tests.status, gates.tests.exitCode),
+      exitCode: gates.tests.exitCode,
+      outputTail: gates.tests.outputTail,
+      language: outcomeLanguage(gates.tests.language),
+      parserVersion: VERIFICATION_OUTCOME_CONTRACT_VERSION,
+      command: gates.tests.command,
+      commandProvenance: {
+        command: gates.tests.command,
+        cwd: options.cwd,
+        source: options.source ?? "deterministic-gate"
+      },
+      failingTests: gates.tests.failingTests,
+      ...testTotals ?? {},
+      verificationCoverage: gates.tests.verificationCoverage,
+      commandResults: gates.tests.commandResults
+    } : void 0
+  };
+}
+function comparableTestTotals(tests) {
+  const evidence = tests.commandResults && tests.commandResults.length > 0 ? tests.commandResults.map((result) => ({
+    command: result.command,
+    output: result.outputTail
+  })) : [{ command: tests.command, output: tests.outputTail }];
+  let testsRun = 0;
+  let testsPassed = 0;
+  let testsSkipped = 0;
+  for (const item of evidence) {
+    const parsed = parseFailureOutput(item.command, item.output, "test");
+    if (!parsed.parsed || parsed.errorCount === null || !parsed.suiteFootprint) {
+      return void 0;
+    }
+    testsRun += parsed.suiteFootprint.executed + parsed.suiteFootprint.skipped;
+    testsPassed += Math.max(0, parsed.suiteFootprint.executed - parsed.errorCount);
+    testsSkipped += parsed.suiteFootprint.skipped;
+  }
+  return { testsRun, testsPassed, testsSkipped };
+}
+
+export {
+  withValidationSlot,
+  getOrCaptureVerificationBaseline,
+  loadKnownPreExistingFailures,
+  allFailuresAreRegistered,
+  verificationOutcomesFromGateArtifacts
+};
+//# sourceMappingURL=chunk-XNO4FM6X.js.map