@poetic-ai/poetic 1.42.0

package/dist/chunk-34CNP2HB.js

@@ -0,0 +1,148 @@
+// src/utils/variant-identity.ts
+import { createHash } from "crypto";
+var VARIANT_SUFFIX_LENGTH = 8;
+function variantSuffix(provider, model, strategy, mode, workspaceMode, modifiers, reasoningEffort) {
+  const parts = [
+    provider,
+    model || "default",
+    strategy,
+    mode || "local",
+    // default to 'local' for backward compatibility
+    workspaceMode || "default"
+    // include workspace mode if it affects artifacts
+  ];
+  if (reasoningEffort) {
+    parts.push(`effort:${reasoningEffort}`);
+  }
+  if (modifiers) {
+    const sortedKeys = Object.keys(modifiers).sort();
+    for (const key of sortedKeys) {
+      const value = modifiers[key];
+      if (value !== void 0) {
+        parts.push(`${key}=${value}`);
+      }
+    }
+  }
+  const canonical = parts.join(":");
+  return createHash("sha256").update(canonical).digest("hex").slice(0, VARIANT_SUFFIX_LENGTH);
+}
+function variantId(provider, model, strategy, mode, workspaceMode, modifiers, reasoningEffort) {
+  const sanitizedProvider = provider.replace(/[^a-zA-Z0-9-_]/g, "");
+  const sanitizedModel = (model || "default").replace(/[^a-zA-Z0-9]/g, "").slice(0, 20);
+  const sanitizedStrategy = strategy.replace(/[^a-zA-Z0-9-_]/g, "");
+  const sanitizedMode = (mode || "local").replace(/[^a-zA-Z0-9-_]/g, "");
+  const suffix = variantSuffix(
+    provider,
+    model,
+    strategy,
+    mode,
+    workspaceMode,
+    modifiers,
+    reasoningEffort
+  );
+  return `${sanitizedProvider}-${sanitizedModel}-${sanitizedStrategy}-${sanitizedMode}-${suffix}`;
+}
+function taskVariantId(taskId, provider, model, strategy, mode, workspaceMode, modifiers, reasoningEffort) {
+  const sanitizedTaskId = taskId.replace(/[^a-zA-Z0-9-_]/g, "");
+  return `${sanitizedTaskId}-${variantId(provider, model, strategy, mode, workspaceMode, modifiers, reasoningEffort)}`;
+}
+
+// src/utils/branch-naming.ts
+import { createHash as createHash2 } from "crypto";
+var POETIC_BRANCH_PREFIX = "poetic";
+var POETIC_BRANCH_PREFIX_WITH_SLASH = `${POETIC_BRANCH_PREFIX}/`;
+var VALIDATION_BRANCH_PREFIX = "validation";
+var VALIDATION_BRANCH_PREFIX_WITH_SLASH = `${VALIDATION_BRANCH_PREFIX}/`;
+var DEFAULT_PART_MAX_LEN = 48;
+var TASK_ID_PART_MAX_LEN = 80;
+var SUFFIX_LEN = 8;
+function normalizeIdentityPart(value) {
+  return String(value ?? "").trim().toLowerCase();
+}
+function sanitizeRefPart(value, opts) {
+  const fallback = opts?.fallback ?? "x";
+  const maxLen = opts?.maxLen ?? DEFAULT_PART_MAX_LEN;
+  const normalized = String(value ?? "").trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, maxLen);
+  return normalized.length > 0 ? normalized : fallback;
+}
+function stableHexSuffix(seed) {
+  return createHash2("sha256").update(seed).digest("hex").slice(0, SUFFIX_LEN);
+}
+function poeticVariantBranchName(opts) {
+  const taskId = sanitizeRefPart(opts.taskId, { fallback: "task", maxLen: TASK_ID_PART_MAX_LEN });
+  const provider = sanitizeRefPart(opts.provider, { fallback: "provider" });
+  const strategy = sanitizeRefPart(opts.strategy, { fallback: "strategy" });
+  const executionMode = sanitizeRefPart(opts.executionMode, { fallback: "mode", maxLen: 16 });
+  const suffix = variantSuffix(
+    normalizeIdentityPart(opts.provider),
+    opts.model ? normalizeIdentityPart(opts.model) : void 0,
+    normalizeIdentityPart(opts.strategy),
+    normalizeIdentityPart(opts.executionMode),
+    opts.workspaceMode ? normalizeIdentityPart(opts.workspaceMode) : void 0,
+    opts.cursorPromptProfile ? { cursorPromptProfile: normalizeIdentityPart(opts.cursorPromptProfile) } : void 0,
+    opts.reasoningEffort ? normalizeIdentityPart(opts.reasoningEffort) : void 0
+  );
+  return `${POETIC_BRANCH_PREFIX}/var-${taskId}-${provider}-${strategy}-${executionMode}-${suffix}`;
+}
+function poeticVariantBranchPrefix(taskId) {
+  const safeTaskId = sanitizeRefPart(taskId, { fallback: "task", maxLen: TASK_ID_PART_MAX_LEN });
+  return `${POETIC_BRANCH_PREFIX}/var-${safeTaskId}-`;
+}
+function poeticSubtaskBranchName(opts) {
+  const taskId = sanitizeRefPart(opts.taskId, { fallback: "task", maxLen: TASK_ID_PART_MAX_LEN });
+  const provider = sanitizeRefPart(opts.provider, { fallback: "provider" });
+  const subtaskId = sanitizeRefPart(String(opts.subtaskId), { fallback: "subtask", maxLen: 24 });
+  const suffix = stableHexSuffix(
+    `st:${normalizeIdentityPart(opts.taskId)}:${normalizeIdentityPart(opts.provider)}:${normalizeIdentityPart(String(opts.subtaskId))}`
+  );
+  return `${POETIC_BRANCH_PREFIX}/st-${taskId}-${provider}-${subtaskId}-${suffix}`;
+}
+function poeticWorktreeBranchName(opts) {
+  const taskId = sanitizeRefPart(opts.taskId, { fallback: "task", maxLen: TASK_ID_PART_MAX_LEN });
+  const context = sanitizeRefPart(opts.context, { fallback: "wt", maxLen: 24 });
+  const suffix = stableHexSuffix(
+    `wt:${normalizeIdentityPart(opts.taskId)}:${normalizeIdentityPart(opts.context)}`
+  );
+  return `${POETIC_BRANCH_PREFIX}/wt-${taskId}-${context}-${suffix}`;
+}
+function poeticSynthesisBranchName(taskId) {
+  const safeTaskId = sanitizeRefPart(taskId, { fallback: "task", maxLen: TASK_ID_PART_MAX_LEN });
+  const suffix = stableHexSuffix(`synth:${normalizeIdentityPart(taskId)}`);
+  return `${POETIC_BRANCH_PREFIX}/synth-${safeTaskId}-${suffix}`;
+}
+function poeticBackgroundBranchName(taskId) {
+  const safeTaskId = sanitizeRefPart(taskId, { fallback: "task", maxLen: TASK_ID_PART_MAX_LEN });
+  const suffix = stableHexSuffix(`bg:${normalizeIdentityPart(taskId)}`);
+  return `${POETIC_BRANCH_PREFIX}/bg-${safeTaskId}-${suffix}`;
+}
+function isPoeticOwnedBranch(branchName) {
+  if (!branchName.startsWith(POETIC_BRANCH_PREFIX_WITH_SLASH)) {
+    return false;
+  }
+  if (branchName.startsWith("poetic/archive/") || branchName.startsWith("poetic/preflight/")) {
+    return false;
+  }
+  if (branchName.startsWith("poetic/flywheel/") || branchName.startsWith("poetic/flywheel-test/")) {
+    return true;
+  }
+  return /^poetic\/var-[a-z0-9-]+-[a-z0-9-]+-[a-z0-9-]+-[a-z0-9-]+-[a-f0-9]{8}$/.test(branchName) || /^poetic\/st-[a-z0-9-]+-[a-z0-9-]+-[a-z0-9-]+-[a-f0-9]{8}$/.test(branchName) || /^poetic\/synth-[a-z0-9-]+-[a-f0-9]{8}$/.test(branchName) || /^poetic\/bg-[a-z0-9-]+-[a-f0-9]{8}$/.test(branchName) || /^poetic\/wt-[a-z0-9-]+-[a-z0-9-]+-[a-f0-9]{8}$/.test(branchName);
+}
+function isValidationBranch(branchName) {
+  return branchName === VALIDATION_BRANCH_PREFIX || branchName.startsWith(VALIDATION_BRANCH_PREFIX_WITH_SLASH);
+}
+
+export {
+  variantId,
+  taskVariantId,
+  VALIDATION_BRANCH_PREFIX,
+  sanitizeRefPart,
+  poeticVariantBranchName,
+  poeticVariantBranchPrefix,
+  poeticSubtaskBranchName,
+  poeticWorktreeBranchName,
+  poeticSynthesisBranchName,
+  poeticBackgroundBranchName,
+  isPoeticOwnedBranch,
+  isValidationBranch
+};
+//# sourceMappingURL=chunk-34CNP2HB.js.map

package/dist/chunk-35P3W3JX.js

@@ -0,0 +1,456 @@
+import {
+  parseJsonWithContext
+} from "./chunk-QVZMFDYG.js";
+import {
+  isProjectTestPath
+} from "./chunk-UDMS5AD3.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 = "POETIC_CRITERIA_REPORT:";
+function extractAcceptanceCriteria(taskText) {
+  const lines = taskText.split("\n");
+  const criteria = [];
+  for (const line of lines) {
+    const match = line.match(/^\s*[-*]\s*\[(?: |x|X)\]\s+(.*)\s*$/);
+    if (match?.[1]) {
+      const text = match[1].trim();
+      if (text.length > 0) criteria.push(text);
+    }
+  }
+  if (criteria.length === 0) {
+    const sectionHeaderPattern = /^\s*(?:#{1,6}\s*)?(?:(?:key\s+)?acceptance\s+(?:criteria|checks)|acceptance|success\s+(?:criteria|checks)|done\s+when)\s*:?\s*$/i;
+    const startIdx = lines.findIndex((l) => sectionHeaderPattern.test(l));
+    if (startIdx !== -1) {
+      for (let i = startIdx + 1; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        if (/^\s*#{1,6}\s+/.test(line)) break;
+        if (line.trim().length === 0) continue;
+        const bullet = line.match(/^\s*[-*]\s+(.*)\s*$/)?.[1];
+        const numbered = line.match(/^\s*\d+[.)]\s+(.*)\s*$/)?.[1];
+        const text = (bullet ?? numbered)?.trim();
+        if (text) {
+          criteria.push(text);
+        } else {
+          break;
+        }
+      }
+    }
+  }
+  return criteria.filter((c) => c.length > 0).slice(0, 25).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;
+    if (line.startsWith("?? ")) {
+      newFiles.push(line.slice(3).trim());
+      continue;
+    }
+    if (line.length < 3) continue;
+    const xy = line.slice(0, 2);
+    let filePath = line.slice(3).trim();
+    if (filePath.includes("->")) {
+      const parts = filePath.split("->");
+      filePath = (parts.at(-1) ?? filePath).trim();
+    }
+    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;
+    let filePath = line.startsWith("?? ") ? line.slice(3).trim() : line.slice(3).trim();
+    if (filePath.includes("->")) filePath = (filePath.split("->").at(-1) ?? filePath).trim();
+    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 criterionRequestsRemoval(text) {
+  return /\b(?:remove|delete|drop|eliminate)\b/i.test(text);
+}
+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;
+  if (mode === "off") {
+    return {
+      enabled: false,
+      passed: true,
+      coverage: 1,
+      criteria: [],
+      blockingIssues: [],
+      missingReport: false
+    };
+  }
+  const taskText = input.requirementsTaskText ?? "";
+  const extracted = taskText.length > 0 ? extractAcceptanceCriteria(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}`));
+    }
+    if (criterionRequestsRemoval(criterion.text)) {
+      verifiedEvidence.push(
+        ...pathEvidence.filter((item) => !item.exists).map((item) => `host:deleted:${item.relativePath}`)
+      );
+    }
+    let score = 0;
+    if (status === "met") score = 1;
+    else if (status === "partial") score = 0.5;
+    else score = 0;
+    if (requireEvidence && status === "met" && verifiedEvidence.length === 0) {
+      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
+    };
+  });
+  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) {
+        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,
+  extractAcceptanceCriteria,
+  formatAcceptanceCriteriaForPrompt,
+  validateRequirements
+};
+//# sourceMappingURL=chunk-35P3W3JX.js.map

package/dist/chunk-36PEBZAF.js

@@ -0,0 +1,18 @@
+// src/core/providers/shared/atomic-write.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+async function writeFileAtomic(targetPath, contents) {
+  const directory = path.dirname(targetPath);
+  await fs.mkdir(directory, { recursive: true });
+  const tempPath = path.join(
+    directory,
+    `.${path.basename(targetPath)}.${process.pid}.${Date.now()}.tmp`
+  );
+  await fs.writeFile(tempPath, contents, "utf-8");
+  await fs.rename(tempPath, targetPath);
+}
+
+export {
+  writeFileAtomic
+};
+//# sourceMappingURL=chunk-36PEBZAF.js.map

package/dist/chunk-3AOKYKA7.js

@@ -0,0 +1,22 @@
+// src/constants/system-constants.ts
+var GITHUB_API_RETRY_ATTEMPTS = 3;
+var GITHUB_API_RETRY_BACKOFF_CAP_MS = 1e4;
+var EXPONENTIAL_BACKOFF_MULTIPLIER = 2;
+var SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1e3;
+var ONE_HOUR_MS = 60 * 60 * 1e3;
+var MAX_FILE_SIZE_BYTES = 100 * 1024 * 1024;
+var MAX_FILE_COUNT = 1e3;
+var CIRCUIT_BREAKER_WARNING_INTERVAL_MS = 5e3;
+var MS_PER_SECOND = 1e3;
+
+export {
+  GITHUB_API_RETRY_ATTEMPTS,
+  GITHUB_API_RETRY_BACKOFF_CAP_MS,
+  EXPONENTIAL_BACKOFF_MULTIPLIER,
+  SEVEN_DAYS_MS,
+  MAX_FILE_SIZE_BYTES,
+  MAX_FILE_COUNT,
+  CIRCUIT_BREAKER_WARNING_INTERVAL_MS,
+  MS_PER_SECOND
+};
+//# sourceMappingURL=chunk-3AOKYKA7.js.map