@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-OTXLMJKP.js

@@ -0,0 +1,438 @@
+import {
+  extractAcceptanceCriteria
+} from "./chunk-XON4ZCYX.js";
+import {
+  parseJsonWithContext
+} from "./chunk-P6SSWAKY.js";
+import {
+  isProjectTestPath
+} from "./chunk-RPIMAMV7.js";
+import {
+  parsePorcelainLinePath
+} from "./chunk-5KQETTNS.js";
+
+// src/orchestrator/autoloop-policy.ts
+function detectAutoloopStaticRiskSignals(taskText) {
+  const normalized = taskText.trim();
+  const lower = normalized.toLowerCase();
+  const charCount = normalized.length;
+  const wordCount = normalized.length === 0 ? 0 : normalized.split(/\s+/u).length;
+  const codeFenceCount = (normalized.match(/```/gu) ?? []).length;
+  const hasUnbalancedCodeFences = codeFenceCount % 2 === 1;
+  const hasExecutionIntent = /\b(fix|implement|patch|edit|modify|update|refactor|repair|add|run|execute|verify|test|ship|build)\b/u.test(
+    lower
+  ) || /\bwrite\s+(tests?|code|implementation|patch|fix)\b/u.test(lower);
+  const hasAnalysisIntent = /\b(analysis|analy[sz]e|investigat(e|ion)|research|diagnos(e|is)|root\s+cause|rca|postmortem|write[-\s]?up|design|architecture)\b/u.test(
+    lower
+  ) && !hasExecutionIntent;
+  const hasContextPressure = charCount >= 8e3 || wordCount >= 1200 || codeFenceCount >= 6;
+  return {
+    charCount,
+    wordCount,
+    codeFenceCount,
+    hasUnbalancedCodeFences,
+    hasAnalysisIntent,
+    hasContextPressure
+  };
+}
+function recommendInitialAutoloopPolicy(input) {
+  const signals = detectAutoloopStaticRiskSignals(input.taskText);
+  const reasons = [];
+  const corePatch = {};
+  const promptPatch = {};
+  let level = "baseline";
+  if (signals.hasUnbalancedCodeFences) {
+    reasons.push("unbalanced_code_fences");
+    level = "guarded";
+  }
+  if (signals.hasAnalysisIntent) {
+    reasons.push("analysis_intent");
+    level = "guarded";
+  }
+  if (signals.hasContextPressure && input.userProvidedNoHistory !== true) {
+    reasons.push("context_pressure");
+    promptPatch.enableFreshPromptMode = true;
+    promptPatch.disableSemanticFeedback = true;
+    level = "guarded";
+  }
+  if (level !== "baseline") {
+    if (input.userProvidedValidationMode === void 0) {
+      corePatch.validationMode = "heuristic";
+    }
+    if (input.userProvidedAIJudge === void 0) {
+      corePatch.useAIJudge = true;
+    }
+  }
+  return { level, corePatch, promptPatch, reasons };
+}
+function nextLevel(current) {
+  switch (current) {
+    case "baseline":
+      return "guarded";
+    case "guarded":
+      return "safe";
+    default:
+      return null;
+  }
+}
+function computeMonotonicAutoloopEscalation(input) {
+  const to = nextLevel(input.currentLevel);
+  if (!to) return null;
+  const reasons = [input.signal];
+  const corePatch = {};
+  if (input.currentValidationMode === "none") {
+    corePatch.validationMode = "heuristic";
+  }
+  if (!input.currentUseAIJudge) {
+    corePatch.useAIJudge = true;
+  }
+  if (input.runQualityGates) {
+    if (to === "safe") {
+      if (input.currentQualityGatesMode === "fast") {
+        corePatch.qualityGatesMode = "safe";
+      }
+    }
+  }
+  return {
+    from: input.currentLevel,
+    to,
+    signal: input.signal,
+    corePatch,
+    reasons
+  };
+}
+var prepareInitialAutoloopPolicy = recommendInitialAutoloopPolicy;
+
+// src/orchestrator/requirements-validator.ts
+import { existsSync } from "fs";
+import * as path from "path";
+
+// src/utils/exec-with-timeout.ts
+import { execSync } from "child_process";
+function execWithTimeout(command, options = {}) {
+  const { timeout = 3e4, returnEmptyOnError = false, ...execOptions } = options;
+  const finalOptions = {
+    encoding: "utf-8",
+    ...execOptions,
+    timeout
+  };
+  try {
+    const result = execSync(command, finalOptions);
+    return typeof result === "string" ? result : result.toString("utf-8");
+  } catch (error) {
+    if (returnEmptyOnError) {
+      return "";
+    }
+    throw error;
+  }
+}
+
+// src/orchestrator/requirements-validator.ts
+var CRITERIA_REPORT_MARKER = "BUILD_CRITERIA_REPORT:";
+function extractAcceptanceCriteria2(taskText) {
+  return extractAcceptanceCriteria(taskText).map((text, idx) => ({
+    id: `AC${idx + 1}`,
+    text
+  }));
+}
+function formatAcceptanceCriteriaForPrompt(criteria) {
+  if (criteria.length === 0) return "";
+  return criteria.map((c) => `- [ ] (${c.id}) ${c.text}`).join("\n");
+}
+function safeStringifyUnknown(value) {
+  if (typeof value === "string") return value;
+  if (value === null || value === void 0) return "";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function extractCriteriaReportJson(outputText) {
+  const markerIndex = outputText.indexOf(CRITERIA_REPORT_MARKER);
+  if (markerIndex === -1) return void 0;
+  const tail = outputText.slice(markerIndex + CRITERIA_REPORT_MARKER.length).trimStart();
+  const firstBrace = tail.indexOf("{");
+  if (firstBrace === -1) return void 0;
+  let depth = 0;
+  let inString = false;
+  let escapeNext = false;
+  let endIndex = -1;
+  for (let i = firstBrace; i < tail.length; i++) {
+    const ch = tail[i];
+    if (escapeNext) {
+      escapeNext = false;
+      continue;
+    }
+    if (ch === "\\" && inString) {
+      escapeNext = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        endIndex = i;
+        break;
+      }
+    }
+  }
+  if (endIndex === -1) return void 0;
+  const json = tail.slice(firstBrace, endIndex + 1);
+  try {
+    const parsed = parseJsonWithContext(json, "autoloop criteria report");
+    if (!parsed || typeof parsed !== "object") return void 0;
+    const criteria = parsed.criteria;
+    if (!Array.isArray(criteria)) return void 0;
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+function getGitStatusPorcelain(cwd) {
+  return execWithTimeout("git status --porcelain --untracked-files=all", {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 1e4,
+    maxBuffer: 2 * 1024 * 1024,
+    returnEmptyOnError: true
+  });
+}
+function parseNewFilesFromGitStatus(porcelain) {
+  const newFiles = [];
+  for (const rawLine of porcelain.split("\n")) {
+    const line = rawLine.replace(/\r$/, "");
+    if (line.trim().length === 0) continue;
+    const filePath = parsePorcelainLinePath(line);
+    if (line.startsWith("?? ")) {
+      newFiles.push(filePath);
+      continue;
+    }
+    if (line.length < 3) continue;
+    const xy = line.slice(0, 2);
+    if (xy[0] === "A" || xy[0] === "R" || xy[0] === "C" || xy[1] === "A" || xy[1] === "R" || xy[1] === "C") {
+      newFiles.push(filePath);
+    }
+  }
+  return Array.from(new Set(newFiles)).filter((p) => p.length > 0);
+}
+function parseChangedFilesFromGitStatus(porcelain) {
+  const files = [];
+  for (const rawLine of porcelain.split("\n")) {
+    const line = rawLine.replace(/\r$/, "");
+    if (line.trim().length === 0) continue;
+    const filePath = parsePorcelainLinePath(line);
+    if (filePath.length > 0) files.push(filePath.replaceAll("\\", "/"));
+  }
+  return Array.from(new Set(files));
+}
+function normalizeEvidencePath(value) {
+  const unquoted = value.trim().replace(/^([`'"])|([`'"])$/g, "");
+  const candidate = unquoted.match(/^([^\s:#]+(?:\/[^\s:#]+)*)(?::\d+(?::\d+)?)?(?:\s|$|:)/)?.[1];
+  if (!candidate || path.isAbsolute(candidate) || path.win32.isAbsolute(candidate))
+    return void 0;
+  const normalized = path.posix.normalize(candidate.replaceAll("\\", "/")).replace(/^\.\//, "");
+  if (normalized === ".." || normalized.startsWith("../")) return void 0;
+  return normalized;
+}
+function collectHostObservedPathEvidence(input) {
+  const root = path.resolve(input.workingDir);
+  return input.evidence.flatMap((claim) => {
+    const relativePath = normalizeEvidencePath(claim);
+    if (!relativePath || !input.changedFiles.has(relativePath)) return [];
+    const resolved = path.resolve(root, relativePath);
+    if (!resolved.startsWith(`${root}${path.sep}`)) return [];
+    return [{ claim, relativePath, exists: existsSync(resolved) }];
+  });
+}
+function criterionRequestsTestArtifactChange(text) {
+  return /\b(?:add|create|write|introduce|update|modify|extend|expand)\s+(?:(?:the|new|existing|relevant|associated|missing|unit|integration|end-to-end|e2e|regression|focused|additional|corresponding|comprehensive|appropriate)\s+){0,4}(?:tests?|specs?)\b/i.test(
+    text
+  ) || /\b(?:tests?|specs?)\s+(?:(?:are|were|have\s+been|must\s+be|should\s+be)\s+)?(?:added|created|written|introduced|updated|modified|extended|expanded)\b/i.test(
+    text
+  );
+}
+function requestedRemovalPath(text) {
+  const directive = text.trim().match(/^(?:remove|delete|drop|eliminate)\s+(\S+)$/i);
+  return directive?.[1] ? normalizeEvidencePath(directive[1].replace(/\.$/, "")) : void 0;
+}
+function existingChangedTestPaths(input) {
+  const root = path.resolve(input.workingDir);
+  return Array.from(input.changedFiles).filter((relativePath) => {
+    if (!isProjectTestPath(relativePath)) return false;
+    const resolved = path.resolve(root, relativePath);
+    return resolved.startsWith(`${root}${path.sep}`) && existsSync(resolved);
+  });
+}
+function findNewRepoRootMarkdownFiles(newFiles) {
+  return newFiles.filter((p) => /^[^/\\]+\.md$/i.test(p));
+}
+function validateRequirements(input) {
+  const mode = input.config?.mode ?? "auto";
+  const minCoverage = clamp01(input.config?.minCoverage ?? 0.9);
+  const requireEvidence = input.config?.requireEvidence ?? true;
+  const blockNewRepoRootMarkdown = input.config?.blockNewRepoRootMarkdown ?? true;
+  const creditProviderClaims = input.config?.creditProviderClaimsWhenHostGatesPass === true;
+  if (mode === "off") {
+    return {
+      enabled: false,
+      passed: true,
+      coverage: 1,
+      criteria: [],
+      blockingIssues: [],
+      missingReport: false
+    };
+  }
+  const taskText = input.requirementsTaskText ?? "";
+  const extracted = taskText.length > 0 ? extractAcceptanceCriteria2(taskText) : [];
+  const enabled = extracted.length > 0;
+  if (!enabled) {
+    return {
+      enabled: false,
+      passed: true,
+      coverage: 1,
+      criteria: [],
+      blockingIssues: [],
+      missingReport: false
+    };
+  }
+  const outputText = safeStringifyUnknown(input.providerOutputText);
+  const report = extractCriteriaReportJson(outputText);
+  const missingReport = report === void 0;
+  const reportById = /* @__PURE__ */ new Map();
+  for (const entry of report?.criteria ?? []) {
+    if (!entry || typeof entry !== "object") continue;
+    const id = typeof entry.id === "string" ? entry.id.trim() : "";
+    if (id) reportById.set(id, entry);
+  }
+  const porcelain = getGitStatusPorcelain(input.workingDir);
+  const changedFiles = new Set(
+    (input.changedFiles ?? parseChangedFilesFromGitStatus(porcelain)).map((file) => normalizeEvidencePath(file)).filter((file) => file !== void 0)
+  );
+  const changedTestPaths = existingChangedTestPaths({
+    changedFiles,
+    workingDir: input.workingDir
+  });
+  const criteriaResults = extracted.map((criterion) => {
+    const entry = reportById.get(criterion.id);
+    const rawStatus = entry?.status;
+    const status = rawStatus === "met" || rawStatus === "partial" || rawStatus === "not_met" ? rawStatus : "unknown";
+    const evidence = Array.isArray(entry?.evidence) ? entry?.evidence?.filter(
+      (e) => typeof e === "string" && e.trim().length > 0
+    ) ?? [] : [];
+    const pathEvidence = collectHostObservedPathEvidence({
+      evidence,
+      workingDir: input.workingDir,
+      changedFiles
+    });
+    const testCriterion = detectTestRequirements([criterion]);
+    const testArtifactChangeRequired = criterionRequestsTestArtifactChange(criterion.text);
+    const passingTestGate = input.testVerification?.status === "passed" && input.testVerification.checksRun > 0;
+    const verifiedEvidence = [];
+    if (testCriterion && passingTestGate && !testArtifactChangeRequired) {
+      verifiedEvidence.push(`host:test-gate:${input.testVerification?.checksRun ?? 0}`);
+    }
+    if (testArtifactChangeRequired && passingTestGate && changedTestPaths.length > 0) {
+      verifiedEvidence.push(`host:test-gate:${input.testVerification?.checksRun ?? 0}`);
+      verifiedEvidence.push(...changedTestPaths.map((file) => `host:test-artifact:${file}`));
+    }
+    const removalPath = requestedRemovalPath(criterion.text);
+    if (removalPath) {
+      verifiedEvidence.push(
+        ...pathEvidence.filter((item) => !item.exists && item.relativePath === removalPath).map((item) => `host:deleted:${item.relativePath}`)
+      );
+    }
+    let score = 0;
+    if (status === "met") score = 1;
+    else if (status === "partial") score = 0.5;
+    else score = 0;
+    const removalContradicted = removalPath !== void 0 && existsSync(path.resolve(input.workingDir, removalPath));
+    const gatesPassedClaim = creditProviderClaims && status === "met" && verifiedEvidence.length === 0 && input.hostGatesPassed === true && passingTestGate && !removalContradicted;
+    if (requireEvidence && status === "met" && verifiedEvidence.length === 0 && !gatesPassedClaim) {
+      score = 0.5;
+    }
+    if (testCriterion && status === "met" && (input.testVerification?.status !== "passed" || input.testVerification.checksRun === 0)) {
+      score = 0;
+    }
+    if (testArtifactChangeRequired && status === "met" && changedTestPaths.length === 0) {
+      score = 0;
+    }
+    return {
+      id: criterion.id,
+      text: criterion.text,
+      status,
+      score,
+      evidence,
+      verifiedEvidence,
+      ...gatesPassedClaim && score === 1 ? { provenance: "provider_claimed_host_gates_passed" } : {}
+    };
+  });
+  const blockingIssues = [];
+  if (missingReport) {
+    blockingIssues.push(
+      `Missing ${CRITERIA_REPORT_MARKER} JSON report in provider output; cannot verify acceptance criteria coverage.`
+    );
+  }
+  if (requireEvidence) {
+    for (const criterion of criteriaResults) {
+      if (criterion.status === "met" && criterion.verifiedEvidence.length === 0 && criterion.provenance === void 0) {
+        blockingIssues.push(
+          `Criterion '${criterion.id}' is provider-claimed met but has no host-verified evidence.`
+        );
+      }
+    }
+  }
+  const newFiles = parseNewFilesFromGitStatus(porcelain);
+  if (blockNewRepoRootMarkdown) {
+    const newRootMarkdown = findNewRepoRootMarkdownFiles(newFiles);
+    if (newRootMarkdown.length > 0) {
+      blockingIssues.push(
+        `Policy violation: new repo-root markdown file(s) created (${newRootMarkdown.slice(0, 5).join(", ")}).`
+      );
+    }
+  }
+  const coverage = criteriaResults.length === 0 ? 1 : criteriaResults.reduce((sum, c) => sum + c.score, 0) / criteriaResults.length;
+  const passed = coverage >= minCoverage && blockingIssues.length === 0;
+  return {
+    enabled: true,
+    passed,
+    coverage: clamp01(coverage),
+    criteria: criteriaResults,
+    blockingIssues,
+    missingReport
+  };
+}
+function clamp01(value) {
+  if (!Number.isFinite(value)) return 0;
+  if (value < 0) return 0;
+  if (value > 1) return 1;
+  return value;
+}
+function detectTestRequirements(criteria) {
+  const testKeywords = [
+    /\btest\b/i,
+    /\btests\b/i,
+    /\bspec\b/i,
+    /\bspecs\b/i,
+    /\bcoverage\b/i,
+    /\bunit test/i,
+    /\bintegration test/i,
+    /\be2e test/i
+  ];
+  return criteria.some((criterion) => testKeywords.some((pattern) => pattern.test(criterion.text)));
+}
+
+export {
+  computeMonotonicAutoloopEscalation,
+  prepareInitialAutoloopPolicy,
+  execWithTimeout,
+  extractAcceptanceCriteria2 as extractAcceptanceCriteria,
+  formatAcceptanceCriteriaForPrompt,
+  validateRequirements
+};
+//# sourceMappingURL=chunk-OTXLMJKP.js.map

package/dist/chunk-OV5PKQMA.js

@@ -0,0 +1,213 @@
+import {
+  autoloopPresetIncludesGateKind
+} from "./chunk-GQIP72ZJ.js";
+import {
+  detectProjectCapabilities
+} from "./chunk-AHU3FKPA.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+import {
+  envWithoutAmbientGitRepository
+} from "./chunk-XDM65LBX.js";
+
+// src/orchestrator/autoloop-helpers.ts
+import { execSync } from "child_process";
+import { randomUUID } from "crypto";
+function getGitRepoRoot(cwd = process.cwd()) {
+  try {
+    const result = execSync("git rev-parse --show-toplevel", {
+      cwd,
+      encoding: "utf-8",
+      env: envWithoutAmbientGitRepository(process.env),
+      stdio: ["pipe", "pipe", "ignore"]
+      // Suppress stderr
+    });
+    return result.trim();
+  } catch {
+    return cwd;
+  }
+}
+var MAX_REPORTED_AUTO_GATE_COMMANDS = 8;
+var QUALITY_GATE_KIND_BUCKETS = {
+  lint: ["lint", "typecheck", "format"],
+  unit: ["test", "testFallback", "coverage"],
+  security: ["audit"]
+};
+function commandsOutsideQualityGateMode(verification, mode) {
+  const buckets = verification;
+  const run = /* @__PURE__ */ new Set();
+  for (const [kind, bucketNames] of Object.entries(QUALITY_GATE_KIND_BUCKETS)) {
+    if (!autoloopPresetIncludesGateKind(mode, kind)) continue;
+    for (const bucket of bucketNames) for (const command of buckets[bucket] ?? []) run.add(command);
+  }
+  const notRun = /* @__PURE__ */ new Set();
+  for (const commands of Object.values(buckets)) {
+    for (const command of commands ?? []) if (!run.has(command)) notRun.add(command);
+  }
+  return [...notRun];
+}
+async function detectAutoloopAutoQualityGates(worktreePath, mode = "fast") {
+  try {
+    const capabilities = detectProjectCapabilities(worktreePath);
+    const detectedCommands = [];
+    for (const commands of Object.values(capabilities.verification)) {
+      for (const command of commands ?? []) {
+        if (!detectedCommands.includes(command)) {
+          detectedCommands.push(command);
+        }
+      }
+    }
+    return detectedCommands.length > 0 ? {
+      enabled: true,
+      mode,
+      detectedCommands: detectedCommands.slice(0, MAX_REPORTED_AUTO_GATE_COMMANDS),
+      notRunByMode: commandsOutsideQualityGateMode(capabilities.verification, mode),
+      unsatisfiedInstalls: capabilities.dependencyInstall
+    } : { enabled: false, mode: null, detectedCommands: [] };
+  } catch (_error) {
+    return { enabled: false, mode: null, detectedCommands: [] };
+  }
+}
+function createAutoloopCompletionToken(options) {
+  if (options.promiseText) {
+    const token2 = `<build-completion-promise>${options.promiseText}</build-completion-promise>`;
+    return {
+      token: token2,
+      completionSignal: `xml:${token2}`
+    };
+  }
+  const uuid = randomUUID();
+  const token = `<build-task-complete id="${uuid}"/>`;
+  return {
+    token,
+    completionSignal: `xml:${token}`
+  };
+}
+function shouldInjectCompletionPromise(validationMode, userProvidedSignalOrPromise) {
+  if (validationMode === "deterministic") {
+    return false;
+  }
+  if (userProvidedSignalOrPromise) {
+    return false;
+  }
+  return true;
+}
+function extractCompletedAssistantTextFromJsonLines(stdout) {
+  const messages = [];
+  for (const line of stdout.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed.type !== "assistant") continue;
+      if (typeof parsed.timestamp_ms === "number") continue;
+      const message = parsed.message && typeof parsed.message === "object" ? parsed.message : void 0;
+      const content = Array.isArray(message?.content) ? message.content : [];
+      for (const entry of content) {
+        if (!entry || typeof entry !== "object") continue;
+        const record = entry;
+        if (record.type !== "text" || typeof record.text !== "string") continue;
+        const text = record.text.trim();
+        if (text.length > 0) messages.push(text);
+      }
+    } catch {
+    }
+  }
+  return messages.length > 0 ? messages.join("\n\n") : void 0;
+}
+function selectProviderEngineStdout(result) {
+  if (typeof result?.stdout === "string" && result.stdout.length > 0) {
+    return extractCompletedAssistantTextFromJsonLines(result.stdout) ?? result.stdout;
+  }
+  if (typeof result?.rawStdout === "string") {
+    return extractCompletedAssistantTextFromJsonLines(result.rawStdout) ?? result.rawStdout;
+  }
+  return "";
+}
+function formatAutoloopFailureRecovery(options) {
+  if (options.worktreePresent) {
+    return {
+      kind: "worktree",
+      lines: [
+        `
+Autoloop worktree preserved at: ${options.worktreePath}`,
+        `   Branch locked: ${options.branch}`
+      ]
+    };
+  }
+  return {
+    kind: "branch-only",
+    lines: [
+      "\nAutoloop worktree directory is no longer on disk.",
+      `   Changes are on branch: ${options.branch}`,
+      `   Review with: git switch ${options.branch}`
+    ]
+  };
+}
+async function worktreeHasUncommittedChanges(worktreePath) {
+  try {
+    const status = await execGit(["status", "--porcelain", "--untracked-files=all"], {
+      cwd: worktreePath
+    });
+    return status.exitCode !== 0 || status.stdout.trim().length > 0;
+  } catch {
+    return true;
+  }
+}
+async function branchHasLoopCommits(worktreePath, baseRef) {
+  if (!baseRef) return void 0;
+  try {
+    const count = await execGit(["rev-list", "--count", `${baseRef}..HEAD`], {
+      cwd: worktreePath
+    });
+    if (count.exitCode !== 0) return void 0;
+    return Number.parseInt(count.stdout.trim(), 10) > 0;
+  } catch {
+    return void 0;
+  }
+}
+async function finalizeFailedAutoloopWorktree(options) {
+  const { worktreePath, branch } = options;
+  if (options.preserveWorktrees) {
+    await options.cleanup(worktreePath, true);
+    return formatAutoloopFailureRecovery({
+      worktreePath,
+      branch,
+      worktreePresent: options.worktreePresent(worktreePath)
+    }).lines;
+  }
+  if (await worktreeHasUncommittedChanges(worktreePath)) {
+    await options.cleanup(worktreePath, true);
+    return [
+      "\nAutoloop failed: worktree kept because it has uncommitted changes (--no-preserve-worktrees).",
+      `   Worktree: ${worktreePath}`,
+      `   Branch: ${branch}`,
+      `   Review with: git -C ${worktreePath} status`,
+      `   Discard with: git worktree remove --force ${worktreePath}`
+    ];
+  }
+  const hasCommits = await branchHasLoopCommits(worktreePath, options.baseRef);
+  await options.cleanup(worktreePath, false);
+  const lines = ["\nAutoloop failed: worktree cleaned up (--no-preserve-worktrees)."];
+  if (hasCommits === true) {
+    lines.push(`   Changes remain on branch: ${branch}`, `   Review with: git switch ${branch}`);
+  } else if (hasCommits === false) {
+    lines.push(`   No loop changes were committed to branch: ${branch}`);
+  } else {
+    lines.push(`   Branch: ${branch}`);
+  }
+  return lines;
+}
+
+export {
+  getGitRepoRoot,
+  commandsOutsideQualityGateMode,
+  detectAutoloopAutoQualityGates,
+  createAutoloopCompletionToken,
+  shouldInjectCompletionPromise,
+  selectProviderEngineStdout,
+  formatAutoloopFailureRecovery,
+  finalizeFailedAutoloopWorktree
+};
+//# sourceMappingURL=chunk-OV5PKQMA.js.map

package/dist/chunk-OXK5HA4B.js

@@ -0,0 +1,31 @@
+import {
+  isDependencyManifestPath,
+  isGeneratedLockfilePath
+} from "./chunk-D4VJFCGZ.js";
+
+// src/core/project/verifiable-code-surface.ts
+import path from "path";
+var NON_CODE_SURFACE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".adoc",
+  ".md",
+  ".rst",
+  ".txt",
+  ".yaml",
+  ".yml",
+  ".json",
+  ".jsonc",
+  ".toml"
+]);
+function changesHaveVerifiableCodeSurface(changedFiles) {
+  if (changedFiles.length === 0) return false;
+  return changedFiles.some((file) => {
+    if (isDependencyManifestPath(file) || isGeneratedLockfilePath(file)) return false;
+    const extension = path.extname(file.replace(/\\/g, "/")).toLowerCase();
+    return !NON_CODE_SURFACE_EXTENSIONS.has(extension);
+  });
+}
+
+export {
+  changesHaveVerifiableCodeSurface
+};
+//# sourceMappingURL=chunk-OXK5HA4B.js.map