@poetic-ai/poetic 1.42.0

package/dist/chunk-ACDIT7OP.js

@@ -0,0 +1,1376 @@
+import {
+  parsePromptSpec
+} from "./chunk-7T7RUJI7.js";
+import {
+  stripPoeticContextBlocks
+} from "./chunk-VX3UMWB7.js";
+import {
+  redactBlockerContext
+} from "./chunk-XV7NZL4B.js";
+
+// src/planning/blocker-types.ts
+import { z } from "zod";
+var BlockerCategorySchema = z.enum([
+  "credentials",
+  "design_decisions",
+  "external_dependencies",
+  "ambiguities"
+]);
+var BlockerSeveritySchema = z.enum(["must_have", "nice_to_have"]);
+var EnvRefAnswerSchema = z.object({
+  answer_type: z.literal("env_ref"),
+  env_var: z.string().min(1)
+});
+var TextAnswerSchema = z.object({
+  answer_type: z.literal("text"),
+  value: z.string()
+});
+var BlockerAnswerSchema = z.discriminatedUnion("answer_type", [
+  EnvRefAnswerSchema,
+  TextAnswerSchema
+]);
+var BlockerSchema = z.object({
+  id: z.string().min(1),
+  category: BlockerCategorySchema,
+  severity: BlockerSeveritySchema,
+  question: z.string().min(1),
+  stageIds: z.array(z.string()),
+  default: z.preprocess((value) => value == null ? void 0 : value, z.string().optional())
+});
+var BlockerAnalysisPayloadSchema = z.object({
+  blockers: z.array(BlockerSchema)
+}).passthrough();
+var BlockerAnalysisConfidenceSchema = z.enum(["confirmed", "degraded", "failed"]);
+var AnsweredBlockerSchema = z.object({
+  blockerId: z.string(),
+  category: BlockerCategorySchema,
+  severity: BlockerSeveritySchema.optional(),
+  answer: BlockerAnswerSchema,
+  answeredBy: z.enum(["human", "default_accepted"])
+}).refine(
+  (data) => {
+    if (data.category === "credentials" && data.answer.answer_type !== "env_ref") {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: 'Credential blockers must use answer_type "env_ref", never "text"'
+  }
+);
+var BlockerAnswerFileSchema = z.object({
+  runId: z.string(),
+  timestamp: z.number(),
+  answers: z.array(AnsweredBlockerSchema),
+  unanswered: z.array(z.string())
+});
+var PendingBlockerManifestSchema = z.object({
+  runId: z.string(),
+  timestamp: z.number(),
+  intent: z.string().optional(),
+  blockers: z.array(BlockerSchema),
+  unanswered: z.array(z.string())
+});
+var BLOCKER_CONTEXT_START = "<!-- BLOCKER_CONTEXT:START provenance=blocker-injection -->";
+var BLOCKER_CONTEXT_END = "<!-- BLOCKER_CONTEXT:END -->";
+
+// src/planning/blocker-criteria.ts
+function deriveBlockerCriteria(entries) {
+  const criteria = [];
+  const skippedBlockerIds = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (seen.has(entry.blockerId)) {
+      skippedBlockerIds.push(entry.blockerId);
+      continue;
+    }
+    seen.add(entry.blockerId);
+    if (entry.severity !== "must_have") {
+      skippedBlockerIds.push(entry.blockerId);
+      continue;
+    }
+    const text = entry.answerType === "env_ref" ? `Answered blocker ${entry.blockerId}: use environment variable ${entry.value}` : `Answered blocker ${entry.blockerId}: ${entry.value}`;
+    criteria.push({
+      id: `blocker:${entry.blockerId}`,
+      kind: "criterion",
+      text,
+      severity: "must",
+      type: "blocker-answer",
+      blockerCriterion: {
+        blockerId: entry.blockerId,
+        answerType: entry.answerType,
+        source: "blocker-answer"
+      },
+      checkHints: [
+        `Verify the implementation honors answered blocker ${entry.blockerId}`,
+        "Treat contradictions of this answered must-have blocker as criterion failures."
+      ]
+    });
+  }
+  return {
+    criteria,
+    skippedBlockerIds,
+    noCriteriaApplied: criteria.length === 0
+  };
+}
+
+// src/core/judge/requirements-parser.ts
+function parseRequirementsBlock(prompt) {
+  const errors = [];
+  const match = /REQUIREMENTS?:\s*\n?([\s\S]*?)(?:\n\n|$)/i.exec(prompt);
+  if (!match) {
+    return { requirements: null, errors: [], found: false };
+  }
+  const blockContent = match[1]?.trim() ?? "";
+  if (!blockContent) {
+    return { requirements: null, errors: ["Empty REQUIREMENTS block"], found: true };
+  }
+  try {
+    if (blockContent.startsWith("{")) {
+      const parsed = JSON.parse(blockContent);
+      return {
+        requirements: normalizeRequirements(parsed),
+        errors: [],
+        found: true
+      };
+    }
+    const requirements = {};
+    const lines = blockContent.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const listMatch = /^-\s*(\w+)\s*:\s*(.+)$/.exec(trimmed);
+      if (listMatch) {
+        const key = listMatch[1];
+        const value = listMatch[2];
+        if (!key || value === void 0) {
+          errors.push(`Could not parse requirement line: ${trimmed}`);
+          continue;
+        }
+        const parsedValue = parseValue(value);
+        switch (key) {
+          case "fileTargets":
+            requirements.fileTargets = ensureArray(parsedValue);
+            break;
+          case "FILE":
+          case "file":
+            requirements.fileTargets = [
+              ...requirements.fileTargets ?? [],
+              ...ensureArray(parsedValue)
+            ];
+            break;
+          case "providersMustInclude":
+            requirements.providersMustInclude = ensureArray(parsedValue);
+            break;
+          case "constraints":
+            requirements.constraints = ensureArray(parsedValue);
+            break;
+          default:
+            errors.push(`Unknown requirement key: ${key}`);
+        }
+        continue;
+      }
+      if (trimmed.startsWith("-")) {
+        const item = trimmed.substring(1).trim();
+        if (item) {
+          if (isLikelyFileTarget(item)) {
+            requirements.fileTargets = [...requirements.fileTargets ?? [], item];
+          } else {
+            requirements.constraints = [...requirements.constraints ?? [], item];
+          }
+        }
+        continue;
+      }
+      if (trimmed.length > 0) {
+        errors.push(`Could not parse line: ${trimmed}`);
+      }
+    }
+    return {
+      requirements: normalizeRequirements(requirements),
+      errors,
+      found: true
+    };
+  } catch (error) {
+    errors.push(
+      `Failed to parse REQUIREMENTS block: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return { requirements: null, errors, found: true };
+  }
+}
+function isLikelyFileTarget(item) {
+  const normalized = item.trim();
+  if (!normalized) return false;
+  if (normalized.includes("/") || normalized.includes("\\") || normalized.includes("*"))
+    return true;
+  if (/\.[a-z0-9]{1,5}$/i.test(normalized)) return true;
+  return false;
+}
+function parseValue(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (Array.isArray(parsed)) {
+        return parsed.map((item) => String(item));
+      }
+      return String(parsed);
+    } catch {
+    }
+  }
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.substring(1, trimmed.length - 1);
+  }
+  return trimmed;
+}
+function ensureArray(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (value.includes(",")) {
+    return value.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  return [value];
+}
+function normalizeRequirements(raw) {
+  const normalized = {};
+  if (raw.fileTargets && raw.fileTargets.length > 0) {
+    normalized.fileTargets = raw.fileTargets;
+  }
+  if (raw.providersMustInclude && raw.providersMustInclude.length > 0) {
+    normalized.providersMustInclude = raw.providersMustInclude;
+  }
+  if (raw.constraints && raw.constraints.length > 0) {
+    normalized.constraints = raw.constraints;
+  }
+  return normalized;
+}
+function validateRequirementCompliance(requirements, changedFiles, output) {
+  if (!requirements || Object.keys(requirements).length === 0) {
+    return {
+      compliant: true,
+      satisfiedCount: 0,
+      totalCount: 0,
+      penalty: 0,
+      violations: []
+    };
+  }
+  let totalCount = 0;
+  let satisfiedCount = 0;
+  const violations = [];
+  const warnings = [];
+  const normalizedChangedFiles = changedFiles.map(
+    (f) => f.toLowerCase().replace(/^\.\//, "").replace(/\\/g, "/")
+  );
+  if (requirements.fileTargets && requirements.fileTargets.length > 0) {
+    for (const fileTarget of requirements.fileTargets) {
+      totalCount++;
+      const normalized = fileTarget.toLowerCase().replace(/^\.\//, "").replace(/\\/g, "/");
+      const isGlob = normalized.includes("*");
+      let matched = false;
+      if (isGlob) {
+        const pattern = normalized.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]+");
+        const regex = new RegExp(`^${pattern}$`);
+        matched = normalizedChangedFiles.some((f) => regex.test(f));
+      } else {
+        matched = normalizedChangedFiles.includes(normalized);
+      }
+      if (matched) {
+        satisfiedCount++;
+      } else {
+        violations.push(`Missing FILE target: ${fileTarget}`);
+      }
+    }
+  }
+  if (requirements.providersMustInclude && requirements.providersMustInclude.length > 0) {
+    const outputLower = output.toLowerCase();
+    for (const provider of requirements.providersMustInclude) {
+      totalCount++;
+      const providerLower = provider.toLowerCase();
+      if (outputLower.includes(providerLower)) {
+        satisfiedCount++;
+      } else {
+        violations.push(`Missing required provider: ${provider}`);
+      }
+    }
+  }
+  if (requirements.constraints && requirements.constraints.length > 0) {
+    for (const constraint of requirements.constraints) {
+      warnings.push(`Constraint (not scored): ${constraint}`);
+    }
+  }
+  const compliant = satisfiedCount === totalCount;
+  const missedCount = totalCount - satisfiedCount;
+  const penalty = Math.min(30, missedCount * 10);
+  return {
+    compliant,
+    satisfiedCount,
+    totalCount,
+    penalty,
+    violations,
+    warnings: warnings.length > 0 ? warnings : void 0
+  };
+}
+
+// src/core/judge/criteria-registry.ts
+function parseImplicitCriteria(prompt) {
+  const items = [];
+  const text = (prompt ?? "").trim();
+  if (!text) return items;
+  const push = (item) => {
+    items.push({
+      ...item,
+      id: generateCriteriaId(items.length, "criterion"),
+      kind: "criterion"
+    });
+  };
+  const wantsTestsAdded = /\b(add|write|create|include)\b[\s\S]{0,60}\b(unit\s+)?tests?\b/i.test(text) || /\b(unit\s+test|test\s+case)\b/i.test(text);
+  if (wantsTestsAdded) {
+    push({
+      text: "Add or update tests as requested",
+      severity: "must",
+      type: "implicit",
+      checkHints: [
+        "Look for test file changes (e.g. *.test.* / tests/ / __tests__/)",
+        "Prefer variants that add tests relevant to the change"
+      ]
+    });
+  }
+  const wantsTestsToPass = /\b(all\s+tests?\s+pass|tests?\s+pass|ensure\s+tests?\s+pass|make\s+sure\s+tests?\s+pass|tests?\s+(?:must|should|need(?:s)?\s+to)\s+pass)\b/i.test(
+    text
+  );
+  if (wantsTestsToPass) {
+    push({
+      text: "Tests pass (when evidence is present)",
+      severity: "must",
+      type: "implicit",
+      checkHints: [
+        "Treat \u201Ctests pass\u201D as UNKNOWN without test output/provenance",
+        "Prefer variants with verified passing test runs when available"
+      ]
+    });
+  }
+  const wantsDocs = /\b(update|add|write)\b[\s\S]{0,60}\b(documentation|docs?)\b/i.test(text) || /\bdoc\s+comments?\b/i.test(text);
+  if (wantsDocs) {
+    push({
+      text: "Documentation is updated as requested",
+      severity: "should",
+      type: "implicit",
+      checkHints: ["Look for doc file changes (docs/, *.md) or doc-only edits when requested"]
+    });
+  }
+  const looksTechnical = /\b(FILE:|src\/|lib\/|test\/|tests\/|__tests__\/)\b/i.test(text) || /\b\.(?:ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|kt|cs|rb|php)\b/i.test(text) || /\b(code|coding|implement|refactor|bug|fix|tests?|api|function|class|module|package|dependency|build|compile|typescript|javascript|python|node|npm|pnpm|yarn)\b/i.test(
+    text
+  );
+  const wantsMaintainableCode = /\b(maintainable|maintainability|readable|readability|clean(?:er)?|well-structured|easy\s+to\s+understand|production\s+code)\b/i.test(
+    text
+  );
+  if (looksTechnical && wantsMaintainableCode) {
+    push({
+      text: "Prefer maintainable, readable production code",
+      severity: "should",
+      type: "implicit",
+      checkHints: [
+        "Prefer simpler, clearer implementations over cleverness",
+        "Avoid unnecessary changes and keep the diff well-scoped",
+        "Prefer good naming, structure, and sensible abstractions when applicable"
+      ]
+    });
+  }
+  return items;
+}
+var MUST_KEYWORDS = /\b(must|do not|does not|don't|doesn't|required|critical|mandatory)\b/i;
+var MAY_KEYWORDS = /\b(optionally|preferably|if possible|could|nice to have|bonus)\b/i;
+var AC_OPTIONAL_KEYWORDS = /\b(optional(?:ly)?|bonus|nice\s+to\s+have|if\s+possible)\b/i;
+function classifySeverity(text) {
+  if (MUST_KEYWORDS.test(text)) {
+    return "must";
+  }
+  if (MAY_KEYWORDS.test(text)) {
+    return "may";
+  }
+  return "should";
+}
+function classifyAcceptanceCriterionSeverity(text) {
+  if (MUST_KEYWORDS.test(text)) {
+    return "must";
+  }
+  if (AC_OPTIONAL_KEYWORDS.test(text)) {
+    return "may";
+  }
+  return "must";
+}
+function extractNamedSectionBody(prompt, sectionNamePattern) {
+  const headingPattern = new RegExp(
+    `^(?:#{1,4}\\s+)?${sectionNamePattern}(?:\\s*\\(.*?\\))?[:\\s]*$`,
+    "im"
+  );
+  const headingMatch = headingPattern.exec(prompt);
+  if (!headingMatch) {
+    return null;
+  }
+  const bodyStart = (headingMatch.index ?? 0) + headingMatch[0].length;
+  const remaining = prompt.slice(bodyStart);
+  const bodyLines = remaining.split("\n");
+  const sectionLines = [];
+  let consecutiveBlankLines = 0;
+  for (const line of bodyLines) {
+    if (/^#{1,4}\s/.test(line)) break;
+    if (/^(?:SUCCESS\s+if|REQUIREMENTS|Deliverables|Constraints|Dependencies|Acceptance\s+Criteria|How\s+to\s+Verify)\s*:/im.test(
+      line
+    )) {
+      break;
+    }
+    if (line.trim() === "") {
+      consecutiveBlankLines++;
+      if (consecutiveBlankLines >= 2) break;
+    } else {
+      consecutiveBlankLines = 0;
+    }
+    sectionLines.push(line);
+  }
+  return sectionLines.join("\n");
+}
+function parseSectionBulletItems(sectionBody) {
+  const texts = [];
+  for (const line of sectionBody.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const checkboxMatch = /^[-*]\s+\[[ xX]\]\s+(.+)$/.exec(trimmed);
+    if (checkboxMatch) {
+      const text = checkboxMatch[1]?.trim() ?? "";
+      if (text) texts.push(text);
+      continue;
+    }
+    const bulletMatch = /^[-*]\s+(.+)$/.exec(trimmed);
+    if (bulletMatch) {
+      const text = bulletMatch[1]?.trim() ?? "";
+      if (text) texts.push(text);
+      continue;
+    }
+    const numberedMatch = /^\d+[.)]\s+(.+)$/.exec(trimmed);
+    if (numberedMatch) {
+      const text = numberedMatch[1]?.trim() ?? "";
+      if (text) texts.push(text);
+    }
+  }
+  return texts;
+}
+function generateCriteriaId(index, kind) {
+  const prefix = kind === "criterion" ? "CR" : "CN";
+  const n = index + 1;
+  return `${prefix}-${String(n).padStart(3, "0")}`;
+}
+function generateVerificationObligationId(index) {
+  return `VO-${String(index + 1).padStart(3, "0")}`;
+}
+function extractSignificantWords(text) {
+  const stopWords = /* @__PURE__ */ new Set([
+    "a",
+    "an",
+    "the",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "and",
+    "or",
+    "but",
+    "if",
+    "in",
+    "on",
+    "at",
+    "to",
+    "for",
+    "of",
+    "with",
+    "as",
+    "by",
+    "from",
+    "that",
+    "this",
+    "it",
+    "not",
+    "no",
+    "all",
+    "any",
+    "should",
+    "must",
+    "may",
+    "can",
+    "will"
+  ]);
+  const tokens = text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((t) => (t.length > 2 || /^\d+$/.test(t)) && !stopWords.has(t));
+  return new Set(tokens);
+}
+function deduplicateCriteria(items) {
+  const kept = [];
+  const keptWords = [];
+  const severityRank = { must: 3, should: 2, may: 1 };
+  for (const item of items) {
+    const words = extractSignificantWords(item.text);
+    if (words.size === 0) {
+      kept.push(item);
+      keptWords.push(words);
+      continue;
+    }
+    let isDuplicate = false;
+    for (let existingIdx = 0; existingIdx < keptWords.length; existingIdx++) {
+      const existingWords = keptWords[existingIdx];
+      if (!existingWords || existingWords.size === 0) continue;
+      const intersection = new Set([...words].filter((w) => existingWords.has(w)));
+      const union = /* @__PURE__ */ new Set([...words, ...existingWords]);
+      const overlap = intersection.size / union.size;
+      if (overlap > 0.8) {
+        isDuplicate = true;
+        const existingRank = severityRank[kept[existingIdx]?.severity ?? ""] ?? 0;
+        const newRank = severityRank[item.severity] ?? 0;
+        if (newRank > existingRank) {
+          kept[existingIdx] = item;
+          keptWords[existingIdx] = words;
+        }
+        break;
+      }
+    }
+    if (!isDuplicate) {
+      kept.push(item);
+      keptWords.push(words);
+    }
+  }
+  return kept;
+}
+function parseSuccessIfSection(prompt) {
+  const items = [];
+  let criterionIndex = 0;
+  const successIfMatch = /SUCCESS\s+if:\s*\n((?:.*\n)*?)(?:\n\n|$)/im.exec(prompt);
+  if (successIfMatch) {
+    const blockContent = successIfMatch[1] ?? "";
+    const lines = blockContent.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const bulletMatch = /^[-*]\s+(.+)$/.exec(trimmed);
+      if (!bulletMatch) continue;
+      const text = bulletMatch[1]?.trim() ?? "";
+      if (!text) continue;
+      items.push({
+        id: generateCriteriaId(criterionIndex++, "criterion"),
+        kind: "criterion",
+        text,
+        // SUCCESS if: is the strongest form of criteria definition. Treat as MUST by default.
+        severity: "must",
+        type: "explicit"
+      });
+    }
+  }
+  const inlineMatches = Array.from(prompt.matchAll(/^SUCCESS\s+if:[ \t]*(.+)$/gim));
+  for (const match of inlineMatches) {
+    const text = (match[1] ?? "").trim();
+    if (!text) continue;
+    items.push({
+      id: generateCriteriaId(criterionIndex++, "criterion"),
+      kind: "criterion",
+      text,
+      severity: "must",
+      type: "explicit"
+    });
+  }
+  return items;
+}
+function parseAcceptanceCriteria(prompt) {
+  const items = [];
+  const sectionBody = extractNamedSectionBody(prompt, "Acceptance\\s+Criteria");
+  if (sectionBody === null) {
+    return items;
+  }
+  let criterionIndex = 0;
+  for (const text of parseSectionBulletItems(sectionBody)) {
+    items.push({
+      id: generateCriteriaId(criterionIndex++, "criterion"),
+      kind: "criterion",
+      text,
+      severity: classifyAcceptanceCriterionSeverity(text),
+      type: "acceptance-criteria"
+    });
+  }
+  return items;
+}
+function parseHowToVerifyObligations(prompt) {
+  const items = [];
+  const sectionBody = extractNamedSectionBody(prompt, "How\\s+to\\s+Verify");
+  if (sectionBody === null) {
+    return items;
+  }
+  let index = 0;
+  for (const text of parseSectionBulletItems(sectionBody)) {
+    items.push({
+      id: generateVerificationObligationId(index++),
+      kind: "constraint",
+      text,
+      severity: "must",
+      type: "verification-obligation"
+    });
+  }
+  return items;
+}
+function parseDeliverablesSection(prompt) {
+  const items = [];
+  const delivMatch = /Deliverables:\s*\n((?:.*\n)*?)(?:\n\n|$)/im.exec(prompt);
+  if (!delivMatch) {
+    return items;
+  }
+  const blockContent = delivMatch[1] ?? "";
+  const lines = blockContent.split("\n");
+  let criterionIndex = 0;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const bulletMatch = /^[-*]\s+(.+)$/.exec(trimmed);
+    if (bulletMatch) {
+      const text = bulletMatch[1]?.trim() ?? "";
+      if (text) {
+        items.push({
+          id: generateCriteriaId(criterionIndex++, "criterion"),
+          kind: "criterion",
+          text,
+          severity: classifySeverity(text),
+          type: "explicit"
+        });
+      }
+    }
+  }
+  return items;
+}
+function parseRequirementsBlockToRegistry(prompt) {
+  const result = parseRequirementsBlock(prompt);
+  if (!result.requirements) {
+    return [];
+  }
+  const items = [];
+  const req = result.requirements;
+  if (req.fileTargets && req.fileTargets.length > 0) {
+    for (const target of req.fileTargets) {
+      items.push({
+        id: generateCriteriaId(items.length, "constraint"),
+        kind: "constraint",
+        text: `Modify file: ${target}`,
+        severity: "must",
+        type: "scope",
+        checkHints: ["Check if file appears in changedFiles"]
+      });
+    }
+  }
+  if (req.providersMustInclude && req.providersMustInclude.length > 0) {
+    for (const provider of req.providersMustInclude) {
+      items.push({
+        id: generateCriteriaId(items.length, "constraint"),
+        kind: "constraint",
+        text: `Must include provider: ${provider}`,
+        severity: "must",
+        type: "constraint",
+        checkHints: [`Check if "${provider}" appears in output`]
+      });
+    }
+  }
+  if (req.constraints && req.constraints.length > 0) {
+    for (const constraint of req.constraints) {
+      items.push({
+        id: generateCriteriaId(items.length, "constraint"),
+        kind: "constraint",
+        text: constraint,
+        severity: classifySeverity(constraint),
+        type: "generic"
+      });
+    }
+  }
+  return items;
+}
+function fileTargetsToConstraints(targets) {
+  return targets.map((target, index) => ({
+    id: generateCriteriaId(index, "constraint"),
+    kind: "constraint",
+    text: `Modify file: ${target}`,
+    severity: "must",
+    type: "scope",
+    checkHints: ["Check if file appears in changedFiles"]
+  }));
+}
+function deliverableTargetsToConstraints(targets) {
+  return targets.map((target, index) => ({
+    id: generateCriteriaId(index, "constraint"),
+    kind: "constraint",
+    text: `Produce deliverable: ${target}`,
+    severity: "must",
+    type: "scope",
+    checkHints: ["Check if file appears in changedFiles"]
+  }));
+}
+function extractCriteriaFromContract(contract) {
+  const items = [];
+  for (const mustHave of contract.mustHaves) {
+    items.push({
+      id: generateCriteriaId(items.length, "criterion"),
+      kind: "criterion",
+      text: mustHave.text,
+      severity: "must",
+      type: "explicit"
+    });
+  }
+  for (const ac of contract.acceptanceCriteria) {
+    items.push({
+      id: generateCriteriaId(items.length, "criterion"),
+      kind: "criterion",
+      text: ac.text,
+      severity: classifyAcceptanceCriterionSeverity(ac.text),
+      type: "explicit"
+    });
+  }
+  return items;
+}
+function extractConstraintsFromContract(contract) {
+  const items = [];
+  for (const constraint of contract.constraints) {
+    items.push({
+      id: generateCriteriaId(items.length, "constraint"),
+      kind: "constraint",
+      text: constraint.text,
+      severity: classifySeverity(constraint.text),
+      type: "constraint"
+    });
+  }
+  for (const target of contract.targets) {
+    items.push({
+      id: generateCriteriaId(items.length, "constraint"),
+      kind: "constraint",
+      text: `Modify file: ${target}`,
+      severity: "must",
+      type: "scope",
+      checkHints: ["Check if file appears in changedFiles"]
+    });
+  }
+  return items;
+}
+function buildCriteriaRegistry(prompt, options = {}) {
+  const {
+    taskContract,
+    fileTargets = [],
+    deliverableTargets = [],
+    hasNewFileTargets = false,
+    includeBlockerAnswers = true,
+    trustedBlockerAnswers = []
+  } = options;
+  const normalizedPrompt = stripPoeticContextBlocks(redactBlockerContext(prompt ?? ""));
+  const allCriteria = [];
+  const allConstraints = [];
+  const verificationObligations = [];
+  let sourceCount = 0;
+  let blockerCriteria = {
+    count: 0,
+    noCriteriaApplied: true,
+    skippedBlockerIds: []
+  };
+  const successIfItems = parseSuccessIfSection(normalizedPrompt);
+  if (successIfItems.length > 0) {
+    allCriteria.push(...successIfItems);
+    sourceCount++;
+  }
+  const acItems = parseAcceptanceCriteria(normalizedPrompt);
+  if (acItems.length > 0) {
+    allCriteria.push(...acItems);
+    sourceCount++;
+  }
+  const howToVerifyItems = parseHowToVerifyObligations(normalizedPrompt);
+  if (howToVerifyItems.length > 0) {
+    verificationObligations.push(...howToVerifyItems);
+    sourceCount++;
+  }
+  const delivItems = parseDeliverablesSection(normalizedPrompt);
+  if (delivItems.length > 0) {
+    allCriteria.push(...delivItems);
+    sourceCount++;
+  }
+  if (includeBlockerAnswers) {
+    const derived = deriveBlockerCriteria(trustedBlockerAnswers);
+    blockerCriteria = {
+      count: derived.criteria.length,
+      noCriteriaApplied: derived.noCriteriaApplied,
+      skippedBlockerIds: derived.skippedBlockerIds
+    };
+    if (derived.criteria.length > 0) {
+      allCriteria.push(...derived.criteria);
+      sourceCount++;
+    }
+  }
+  const reqItems = parseRequirementsBlockToRegistry(normalizedPrompt);
+  if (reqItems.length > 0) {
+    allConstraints.push(...reqItems);
+    sourceCount++;
+  }
+  if (taskContract) {
+    const contractCriteria = extractCriteriaFromContract(taskContract);
+    const contractConstraints = extractConstraintsFromContract(taskContract);
+    if (contractCriteria.length > 0 || contractConstraints.length > 0) {
+      allCriteria.push(...contractCriteria);
+      allConstraints.push(...contractConstraints);
+      sourceCount++;
+    }
+  }
+  if (fileTargets.length > 0) {
+    const fileConstraints = fileTargetsToConstraints(fileTargets);
+    allConstraints.push(...fileConstraints);
+    sourceCount++;
+  }
+  if (deliverableTargets.length > 0) {
+    const delivConstraints = deliverableTargetsToConstraints(deliverableTargets);
+    allConstraints.push(...delivConstraints);
+    sourceCount++;
+  }
+  if (allCriteria.length === 0) {
+    const implicitItems = parseImplicitCriteria(normalizedPrompt);
+    if (implicitItems.length > 0) {
+      allCriteria.push(...implicitItems);
+      sourceCount++;
+    }
+  }
+  if (allCriteria.length === 0) {
+    allCriteria.push(
+      {
+        id: generateCriteriaId(0, "criterion"),
+        kind: "criterion",
+        text: "Task requirements are met",
+        severity: "must",
+        type: "baseline"
+      },
+      {
+        id: generateCriteriaId(1, "criterion"),
+        kind: "criterion",
+        text: "Deliverable is correct and verifiable",
+        severity: "must",
+        type: "baseline"
+      },
+      {
+        id: generateCriteriaId(2, "criterion"),
+        kind: "criterion",
+        text: "Solution is clear and maintainable",
+        severity: "should",
+        type: "baseline"
+      }
+    );
+    sourceCount++;
+  }
+  if (hasNewFileTargets && fileTargets.length > 0) {
+    allCriteria.push({
+      id: generateCriteriaId(allCriteria.length, "criterion"),
+      kind: "criterion",
+      text: "New production modules should have corresponding test coverage",
+      severity: "should",
+      type: "implicit",
+      checkHints: [
+        "Look for test files (*.test.*, __tests__/*) corresponding to new production files",
+        "Variants creating new modules with tests demonstrate higher quality"
+      ]
+    });
+  }
+  const deduped = deduplicateCriteria(allCriteria);
+  let criterionIndex = 0;
+  const criteria = deduped.map((item) => {
+    if (item.id.startsWith("blocker:")) {
+      return item;
+    }
+    return {
+      ...item,
+      id: generateCriteriaId(criterionIndex++, "criterion")
+    };
+  });
+  const constraints = allConstraints.map((item, index) => ({
+    ...item,
+    id: generateCriteriaId(index, "constraint")
+  }));
+  const hasMustItems = [...criteria, ...constraints].some((item) => item.severity === "must");
+  const renumberedVerificationObligations = verificationObligations.map((item, index) => ({
+    ...item,
+    id: generateVerificationObligationId(index)
+  }));
+  return {
+    criteria,
+    constraints,
+    verificationObligations: renumberedVerificationObligations,
+    metadata: {
+      sourceCount,
+      hasMustItems,
+      hasTaskContract: !!taskContract,
+      blockerCriteria
+    }
+  };
+}
+function computeCompleteness(ledger) {
+  if (ledger.length === 0) {
+    return 1;
+  }
+  const passCount = ledger.filter((e) => e.st === "P").length;
+  const unknownCount = ledger.filter((e) => e.st === "U").length;
+  const total = ledger.length;
+  const unknownCredit = Math.min(unknownCount, passCount);
+  const completeness = (passCount + 0.5 * unknownCredit) / total;
+  return Math.max(0, Math.min(1, completeness));
+}
+
+// src/core/judge/task-contract.ts
+function createEmptyContract() {
+  return {
+    goal: {
+      text: "Unknown goal - extraction failed",
+      source: "inferred",
+      justification: "Default empty contract created due to extraction failure"
+    },
+    deliverableType: "mixed",
+    mustHaves: [],
+    acceptanceCriteria: [],
+    constraints: [],
+    nonGoals: [],
+    targets: [],
+    extraction: {
+      method: "deterministic",
+      confidence: 0,
+      timestamp: /* @__PURE__ */ new Date(),
+      warnings: ["Empty contract created - extraction may have failed"]
+    }
+  };
+}
+function createExplicitItem(text, verbatimQuote) {
+  return {
+    text,
+    source: "explicit",
+    verbatimQuote
+  };
+}
+function createInferredItem(text, justification) {
+  return {
+    text,
+    source: "inferred",
+    justification
+  };
+}
+function createGateVerifiedInferredItem(text, justification) {
+  return {
+    text,
+    source: "inferred",
+    justification,
+    verification: "gate"
+  };
+}
+function expectsCodeEdits(type) {
+  switch (type) {
+    case "implementation":
+    case "test":
+      return true;
+    case "analysis":
+    case "design":
+      return false;
+    case "documentation":
+    case "mixed":
+      return false;
+  }
+}
+
+// src/core/judge/contract-extraction.ts
+var DELIVERABLE_TYPE_PATTERNS = {
+  implementation: [
+    /\b(implement|add|create|build|develop|write\s+code)\b/i,
+    /\b(fix|repair|resolve|patch)\b.*\b(bug|issue|error)\b/i,
+    /\b(refactor|restructure|rewrite|improve)\b/i,
+    // FILE: pattern kept for type detection but not for constraint enforcement
+    // per A/B test results (2026-02-02)
+    /\bFILE:/i
+  ],
+  analysis: [
+    /\b(analyze|analyse|investigate|examine|review)\b/i,
+    /\b(explain|describe|document\s+how)\b/i,
+    /\b(audit|assess|evaluate)\b/i,
+    /\b(find|identify|locate)\s+(where|what|which|all)/i
+  ],
+  design: [
+    /\b(design|architect|plan)\b.*\b(system|architecture|api)\b/i,
+    /\b(propose|draft|outline)\b.*\b(design|approach|solution)\b/i,
+    /\b(technical\s+spec|RFC|ADR)\b/i
+  ],
+  documentation: [
+    /\b(document|write\s+docs?|update\s+readme)\b/i,
+    /\b(README|CHANGELOG|CONTRIBUTING)\b/i,
+    /\bdocs?\//i,
+    /\.md\b/i
+  ],
+  test: [
+    /\b(write|add|create|implement)\s+(unit\s+)?tests?\b/i,
+    /\b(test\s+coverage|increase\s+coverage)\b/i,
+    /\bspec\.(ts|js)\b/i,
+    /\.test\.(ts|js)\b/i
+  ],
+  mixed: []
+  // Fallback - no specific patterns
+};
+function detectDeliverableType(prompt) {
+  const lower = prompt.toLowerCase();
+  const typeChecks = [
+    "test",
+    "analysis",
+    "documentation",
+    "design",
+    "implementation"
+  ];
+  for (const type of typeChecks) {
+    const patterns = DELIVERABLE_TYPE_PATTERNS[type];
+    if (patterns.some((pattern) => pattern.test(lower))) {
+      return type;
+    }
+  }
+  if (/\bFILE:/i.test(prompt)) {
+    return "implementation";
+  }
+  return "mixed";
+}
+function extractExplicitRequirements(prompt) {
+  const mustHaves = [];
+  const acceptanceCriteria = [];
+  const constraints = [];
+  const warnings = [];
+  const requirementSectionPattern = /(?:^|\n)\s*(?:requirements?|must|should):\s*\n((?:\s*(?:[-*]|\d+[.)]).+(?:\n|$))+)/gim;
+  for (const match of prompt.matchAll(requirementSectionPattern)) {
+    const sectionText = match[1] ?? "";
+    const itemPattern = /^\s*(?:[-*]|\d+[.)])\s*(.+)$/gm;
+    for (const itemMatch of sectionText.matchAll(itemPattern)) {
+      const itemText = itemMatch[1]?.trim() ?? "";
+      if (!itemText) continue;
+      const verbatimQuote = findVerbatimQuote(prompt, itemText);
+      if (verbatimQuote) {
+        mustHaves.push(createExplicitItem(itemText, verbatimQuote));
+      } else {
+        warnings.push(
+          `Explicit item dropped (no verbatim quote found): "${itemText.slice(0, 80)}"`
+        );
+        mustHaves.push(createExplicitItem(itemText, itemText));
+      }
+    }
+  }
+  const sharedAcItems = parseAcceptanceCriteria(prompt);
+  for (const item of sharedAcItems) {
+    const itemText = item.text;
+    if (!itemText) continue;
+    const verbatimQuote = findVerbatimQuote(prompt, itemText);
+    if (verbatimQuote) {
+      acceptanceCriteria.push(createExplicitItem(itemText, verbatimQuote));
+    } else {
+      acceptanceCriteria.push(
+        createInferredItem(
+          itemText,
+          "Extracted from acceptance criteria section without an exact verbatim quote"
+        )
+      );
+    }
+  }
+  const legacyAcceptanceSectionPattern = /(?:^|\n)\s*(?:success\s+criteria|done\s+when):\s*\n((?:\s*(?:[-*]|\d+[.)]).+(?:\n|$))+)/gim;
+  for (const match of prompt.matchAll(legacyAcceptanceSectionPattern)) {
+    const sectionText = match[1] ?? "";
+    const itemPattern = /^\s*(?:[-*]|\d+[.)])\s*(.+)$/gm;
+    for (const itemMatch of sectionText.matchAll(itemPattern)) {
+      const itemText = itemMatch[1]?.trim() ?? "";
+      if (!itemText) continue;
+      if (acceptanceCriteria.some((ac) => ac.text === itemText)) continue;
+      const verbatimQuote = findVerbatimQuote(prompt, itemText);
+      if (verbatimQuote) {
+        acceptanceCriteria.push(createExplicitItem(itemText, verbatimQuote));
+      } else {
+        acceptanceCriteria.push(
+          createInferredItem(
+            itemText,
+            "Extracted from acceptance criteria section without an exact verbatim quote"
+          )
+        );
+      }
+    }
+  }
+  const constraintPatterns = [
+    /(?:^|\n)\s*(?:constraints?|limitations?):\s*\n((?:\s*(?:[-*]|\d+[.)]).+(?:\n|$))+)/gim,
+    /(?:don'?t|do\s+not|avoid|without)\s+([^.!?\n]+[.!?]?)/gi
+  ];
+  const sectionPattern = constraintPatterns[0];
+  if (sectionPattern) {
+    for (const match of prompt.matchAll(sectionPattern)) {
+      const sectionText = match[1] ?? "";
+      const itemPattern = /^\s*(?:[-*]|\d+[.)])\s*(.+)$/gm;
+      for (const itemMatch of sectionText.matchAll(itemPattern)) {
+        const itemText = itemMatch[1]?.trim() ?? "";
+        if (!itemText) continue;
+        const verbatimQuote = findVerbatimQuote(prompt, itemText);
+        if (verbatimQuote) {
+          constraints.push(createExplicitItem(itemText, verbatimQuote));
+        } else {
+          warnings.push(
+            `Explicit item dropped (no verbatim quote found): "${itemText.slice(0, 80)}"`
+          );
+        }
+      }
+    }
+  }
+  const inlinePattern = constraintPatterns[1];
+  if (inlinePattern) {
+    for (const match of prompt.matchAll(inlinePattern)) {
+      const fullMatch = match[0]?.trim() ?? "";
+      if (!fullMatch || fullMatch.length < 10) continue;
+      const verbatimQuote = findVerbatimQuote(prompt, fullMatch);
+      if (verbatimQuote) {
+        constraints.push(createExplicitItem(fullMatch, verbatimQuote));
+      } else {
+        warnings.push(
+          `Explicit item dropped (no verbatim quote found): "${fullMatch.slice(0, 80)}"`
+        );
+      }
+    }
+  }
+  return { mustHaves, acceptanceCriteria, constraints, warnings };
+}
+function extractGoal(prompt) {
+  const taskMatch = prompt.match(/(?:^|\n)\s*(?:task|goal|objective):\s*(.+?)(?:\n|$)/i);
+  if (taskMatch?.[1]) {
+    const goalText = taskMatch[1].trim();
+    const verbatimQuote = findVerbatimQuote(prompt, goalText);
+    if (verbatimQuote) {
+      return createExplicitItem(goalText, verbatimQuote);
+    }
+  }
+  const lines = prompt.split(/\r?\n/);
+  let firstContentLine = "";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (/^FILES?(_ONLY)?:/i.test(trimmed)) continue;
+    if (/^[-*]\s+\S+$/.test(trimmed)) continue;
+    firstContentLine = trimmed;
+    break;
+  }
+  if (firstContentLine) {
+    const sentenceMatch = firstContentLine.match(/^([^.!?\n]+[.!?]?)/);
+    const goalText = sentenceMatch?.[1]?.trim() || firstContentLine.slice(0, 200);
+    const verbatimQuote = findVerbatimQuote(prompt, goalText);
+    if (verbatimQuote) {
+      return createExplicitItem(goalText, verbatimQuote);
+    }
+    return createInferredItem(goalText, "Extracted from first content line of prompt");
+  }
+  return createInferredItem("Complete the requested task", "No clear goal found in prompt");
+}
+function inferRequirements(prompt, existingMustHaves) {
+  const inferredMustHaves = [];
+  const inferredAcceptanceCriteria = [];
+  const lower = prompt.toLowerCase();
+  if (/\b(test|spec)\b/i.test(lower) && !existingMustHaves.some((m) => /test/i.test(m.text))) {
+    if (/\b(add|write|create|implement)\s+(unit\s+)?tests?\b/i.test(lower)) {
+      inferredMustHaves.push(
+        createInferredItem("Include tests for new functionality", "Prompt mentions writing tests")
+      );
+    }
+  }
+  const promptWithoutUrls = prompt.replace(/https?:\/\/\S+/gi, " ").replace(/\bwww\.\S+/gi, " ");
+  if (/\.tsx?\b/.test(promptWithoutUrls)) {
+    inferredAcceptanceCriteria.push(
+      createGateVerifiedInferredItem(
+        "TypeScript compiles without errors",
+        "Task involves TypeScript files - type safety expected"
+      )
+    );
+  }
+  if (/\.go\b/.test(promptWithoutUrls)) {
+    inferredAcceptanceCriteria.push(
+      createGateVerifiedInferredItem(
+        "Go code compiles without errors",
+        "Task involves Go files - compile safety expected"
+      )
+    );
+  }
+  if (/\.rs\b/.test(promptWithoutUrls)) {
+    inferredAcceptanceCriteria.push(
+      createGateVerifiedInferredItem(
+        "Rust code compiles without errors",
+        "Task involves Rust files - compile safety expected"
+      )
+    );
+  }
+  if (/\.java\b/.test(promptWithoutUrls)) {
+    inferredAcceptanceCriteria.push(
+      createGateVerifiedInferredItem(
+        "Java code compiles without errors",
+        "Task involves Java files - compile safety expected"
+      )
+    );
+  }
+  if (/\.py\b/.test(promptWithoutUrls) && (/\bmypy\b/i.test(lower) || /\btype\s+hints?\b/i.test(lower))) {
+    inferredAcceptanceCriteria.push(
+      createGateVerifiedInferredItem(
+        "Python type checks pass without errors",
+        "Task involves typed Python (mypy/type hints) - type safety expected"
+      )
+    );
+  }
+  const ensurePatterns = /(?:ensure|make\s+sure|verify\s+that)\s+([^.!?\n]+[.!?]?)/gi;
+  for (const match of lower.matchAll(ensurePatterns)) {
+    const requirement = match[1]?.trim() ?? "";
+    if (requirement.length > 10 && requirement.length < 200) {
+      inferredAcceptanceCriteria.push(
+        createInferredItem(requirement, 'Extracted from "ensure/make sure" phrase')
+      );
+    }
+  }
+  return {
+    mustHaves: inferredMustHaves,
+    acceptanceCriteria: inferredAcceptanceCriteria
+  };
+}
+function extractNonGoals(prompt) {
+  const nonGoals = [];
+  const nonGoalPatterns = [
+    /(?:out\s+of\s+scope|not\s+in\s+scope):\s*([^.\n]+)/gi,
+    /(?:don'?t\s+worry\s+about|not\s+(?:in\s+)?this\s+(?:PR|task|issue)):\s*([^.\n]+)/gi,
+    /\bnot\s+(?:needed|required|necessary):\s*([^.\n]+)/gi
+  ];
+  for (const pattern of nonGoalPatterns) {
+    for (const match of prompt.matchAll(pattern)) {
+      const text = match[1]?.trim() ?? "";
+      if (!text || text.length < 5) continue;
+      const verbatimQuote = findVerbatimQuote(prompt, match[0]?.trim() ?? "");
+      if (verbatimQuote) {
+        nonGoals.push(createExplicitItem(text, verbatimQuote));
+      }
+    }
+  }
+  return nonGoals;
+}
+function findVerbatimQuote(prompt, text) {
+  if (!text || !prompt) return null;
+  const normalizedText = text.replace(/\s+/g, " ").trim();
+  const normalizedPrompt = prompt.replace(/\s+/g, " ");
+  if (normalizedPrompt.includes(normalizedText)) {
+    return normalizedText;
+  }
+  if (prompt.includes(text)) {
+    return text;
+  }
+  const lowerPrompt = normalizedPrompt.toLowerCase();
+  const lowerText = normalizedText.toLowerCase();
+  if (lowerPrompt.includes(lowerText)) {
+    const startIndex = lowerPrompt.indexOf(lowerText);
+    return normalizedPrompt.slice(startIndex, startIndex + normalizedText.length);
+  }
+  return null;
+}
+function validateContractFidelity(contract, prompt) {
+  const allItems = [
+    contract.goal,
+    ...contract.mustHaves,
+    ...contract.acceptanceCriteria,
+    ...contract.constraints,
+    ...contract.nonGoals
+  ];
+  const explicitItems = allItems.filter((item) => item.source === "explicit");
+  const invalidQuotes = [];
+  for (const item of explicitItems) {
+    if (item.verbatimQuote) {
+      const found = findVerbatimQuote(prompt, item.verbatimQuote);
+      if (!found) {
+        invalidQuotes.push(item.verbatimQuote);
+      }
+    }
+  }
+  const totalExplicit = explicitItems.length;
+  const validExplicit = totalExplicit - invalidQuotes.length;
+  const fidelityScore = totalExplicit > 0 ? validExplicit / totalExplicit : 1;
+  return {
+    isValid: invalidQuotes.length === 0,
+    invalidQuotes,
+    totalExplicit,
+    validExplicit,
+    fidelityScore
+  };
+}
+function extractTaskContract(prompt, options = {}) {
+  const {
+    includeInferred = true,
+    maxMustHaves = 10,
+    maxAcceptanceCriteria = 6,
+    validateQuotes = true
+  } = options;
+  if (!prompt || prompt.trim().length === 0) {
+    return createEmptyContract();
+  }
+  const warnings = [];
+  const promptSpec = parsePromptSpec(prompt);
+  const targets = promptSpec.fileConstraint.targets;
+  const deliverableType = detectDeliverableType(prompt);
+  const goal = extractGoal(prompt);
+  const explicit = extractExplicitRequirements(prompt);
+  warnings.push(...explicit.warnings);
+  let inferredMustHaves = [];
+  let inferredAcceptanceCriteria = [];
+  if (includeInferred) {
+    const inferred = inferRequirements(prompt, explicit.mustHaves);
+    inferredMustHaves = inferred.mustHaves;
+    inferredAcceptanceCriteria = inferred.acceptanceCriteria;
+  }
+  const nonGoals = extractNonGoals(prompt);
+  const mustHaves = [...explicit.mustHaves, ...inferredMustHaves].slice(0, maxMustHaves);
+  const acceptanceCriteria = [...explicit.acceptanceCriteria, ...inferredAcceptanceCriteria].slice(
+    0,
+    maxAcceptanceCriteria
+  );
+  const constraints = explicit.constraints.slice(0, 5);
+  const contract = {
+    goal,
+    deliverableType,
+    mustHaves,
+    acceptanceCriteria,
+    constraints,
+    nonGoals,
+    targets,
+    extraction: {
+      method: "deterministic",
+      confidence: 0.7,
+      // Base confidence for deterministic extraction
+      timestamp: /* @__PURE__ */ new Date(),
+      warnings
+    }
+  };
+  if (validateQuotes) {
+    const validation = validateContractFidelity(contract, prompt);
+    if (!validation.isValid) {
+      warnings.push(
+        `${validation.invalidQuotes.length} explicit quotes not found in prompt: ${validation.invalidQuotes.slice(0, 3).join(", ")}`
+      );
+      contract.extraction.confidence *= validation.fidelityScore;
+    }
+  }
+  if (mustHaves.length === 0 && acceptanceCriteria.length === 0) {
+    contract.extraction.confidence *= 0.6;
+    warnings.push("No explicit requirements extracted - using inference only");
+  }
+  if (goal.source === "inferred") {
+    contract.extraction.confidence *= 0.9;
+  }
+  contract.extraction.warnings = warnings;
+  return contract;
+}
+
+export {
+  BlockerAnalysisPayloadSchema,
+  BLOCKER_CONTEXT_START,
+  BLOCKER_CONTEXT_END,
+  parseRequirementsBlock,
+  validateRequirementCompliance,
+  generateCriteriaId,
+  parseAcceptanceCriteria,
+  buildCriteriaRegistry,
+  computeCompleteness,
+  expectsCodeEdits,
+  extractTaskContract
+};
+//# sourceMappingURL=chunk-ACDIT7OP.js.map