@poetic-ai/poetic 1.42.0

package/dist/chunk-GFGYB2ZU.js

@@ -0,0 +1,1689 @@
+import {
+  classifyTask,
+  stripPromptInjections
+} from "./chunk-FQ7FSZRW.js";
+import {
+  TaskTypeAliasMap,
+  TaskTypeRegistry
+} from "./chunk-LO3X5NLS.js";
+import {
+  getP1SemanticChecks
+} from "./chunk-XPK2I4NC.js";
+import {
+  hasUnfilledMarkers
+} from "./chunk-P6VQROCO.js";
+import {
+  getTask
+} from "./chunk-5LTN43AS.js";
+import {
+  buildPromptFromTask,
+  parseTaskBody
+} from "./chunk-LIVJ6266.js";
+import {
+  classifyIntent
+} from "./chunk-4RCCF5BR.js";
+import {
+  applyExecutionPolicy,
+  describeExecutionPolicyStampMismatch,
+  isCurrentExecutionPolicyWorkflow,
+  isExecutionPolicyEngaged
+} from "./chunk-PIKLF7BM.js";
+import {
+  resolveExecutionRoles
+} from "./chunk-YB3JD4E6.js";
+import {
+  classifyTaskDependency
+} from "./chunk-3BCUNHKF.js";
+import {
+  getPlanningRoot
+} from "./chunk-OPYFYTWQ.js";
+import {
+  getBucketArchivePathByKind,
+  getBucketPathByKind
+} from "./chunk-HOYBYAOA.js";
+import {
+  getWorkflowYamlPath
+} from "./chunk-CQM3A35X.js";
+import {
+  expectsCodeEdits,
+  extractTaskContract
+} from "./chunk-ACDIT7OP.js";
+import {
+  parsePromptSpec
+} from "./chunk-7T7RUJI7.js";
+import {
+  detectExplicitNoEditDirective
+} from "./chunk-JOSYEJKY.js";
+import {
+  listMarkdownFilesRecursive,
+  readMarkdownFile
+} from "./chunk-OIS7J26S.js";
+import {
+  resolveDefaultProvider,
+  resolveJudgeType
+} from "./chunk-XPU2XADL.js";
+import {
+  checkVerifyCommandSafety
+} from "./chunk-LO23NABI.js";
+import {
+  resolveExecutionBoundary
+} from "./chunk-7R2WLDOS.js";
+import {
+  getProjectReferencePathExtensions
+} from "./chunk-UDMS5AD3.js";
+
+// src/planning/stage-contract-adapter.ts
+function resolveStageContract({
+  text,
+  title,
+  metadataExecutionIntent,
+  policyExecutionIntent
+}) {
+  if (metadataExecutionIntent) {
+    return fromIntent(metadataExecutionIntent, "metadata", metadataExecutionIntent === "analysis");
+  }
+  if (policyExecutionIntent === "analysis") {
+    return fromIntent("analysis", "task-type-policy", true);
+  }
+  const stageText = [title, text].filter(Boolean).join("\n\n");
+  if (detectExplicitNoEditDirective(stageText)) {
+    return fromIntent("analysis", "explicit-no-edit", true);
+  }
+  if (policyExecutionIntent === "edit") {
+    return fromIntent("edit", "task-type-policy", false);
+  }
+  if (detectExplicitEdit(stageText)) {
+    return fromIntent("edit", "explicit-edit", false);
+  }
+  const promptSpec = parsePromptSpec(stageText);
+  if (promptSpec.isAnalysisIntent || promptSpec.editsRequired === false) {
+    return fromIntent("analysis", "prompt-spec", true);
+  }
+  if (promptSpec.fileConstraint.mode !== "none") {
+    return fromIntent("edit", "file-marker", false);
+  }
+  const contract = extractTaskContract(stageText, { validateQuotes: false });
+  if (expectsCodeEdits(contract.deliverableType)) {
+    return fromIntent("edit", "task-contract", false);
+  }
+  if (isAnalysisStageSemantics(stageText)) {
+    return fromIntent("analysis", "stage-semantics", true);
+  }
+  return fromIntent("edit", "stage-semantics", false);
+}
+function fromIntent(intent, source, authoritativeAnalysis) {
+  return {
+    capabilities: intent === "analysis" ? {
+      modifiesFiles: false,
+      producesText: true,
+      executionIntent: intent
+    } : {
+      modifiesFiles: true,
+      executionIntent: intent
+    },
+    source,
+    authoritativeAnalysis
+  };
+}
+function detectExplicitEdit(text) {
+  return /\b(implement|fix|repair|patch|add|create|write|update|modify|refactor|rewrite)\b/i.test(
+    text
+  );
+}
+function isAnalysisStageSemantics(text) {
+  return /\b(plan|design|analy[sz]e|inspect|investigate|review|audit|assess|evaluate|verify|validate|diagnose|research)\b/i.test(
+    text
+  );
+}
+
+// src/planning/sprint-to-workflow.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as yaml from "js-yaml";
+
+// src/core/routing/fusion-default-activities.ts
+var FUSION_DEFAULT_ACTIVITIES = /* @__PURE__ */ new Set([
+  "architecture",
+  "design",
+  "research",
+  "planning"
+]);
+
+// src/core/routing/select-execution-strategy.ts
+var COMPETE_ACTIVITIES = /* @__PURE__ */ new Set([
+  ...FUSION_DEFAULT_ACTIVITIES,
+  "development",
+  "debugging"
+]);
+var SINGLE_PASS_CATEGORIES = /* @__PURE__ */ new Set(["analyze", "review", "document"]);
+function hasExplicitFlywheelConfig(task) {
+  return Boolean(task.flywheel?.type || task.flywheel?.competition || task.flywheel?.autoloop);
+}
+function selectExecutionStrategy(task) {
+  const reasons = [];
+  const alternatives = [];
+  let strategy;
+  let confidence;
+  const hasExplicitConfig = hasExplicitFlywheelConfig(task);
+  if (hasExplicitConfig) {
+    const explicitType = task.flywheel?.type;
+    const hasCompetition = Boolean(task.flywheel?.competition);
+    if (explicitType === "competition" || hasCompetition) {
+      strategy = "compete";
+      reasons.push("Explicit flywheel.competition or type=competition configured");
+    } else if (explicitType === "standard") {
+      strategy = "single-pass";
+      reasons.push("Explicit flywheel.type=standard configured");
+    } else if (explicitType === "verify") {
+      strategy = "single-pass";
+      reasons.push("Explicit flywheel.type=verify configured (local verification)");
+    } else {
+      strategy = "compete";
+      reasons.push("Explicit flywheel config present");
+    }
+    return {
+      strategy,
+      reasons,
+      confidence: 100,
+      hasExplicitConfig: true
+    };
+  }
+  const activity = task.taskClassification?.activity;
+  if (activity && COMPETE_ACTIVITIES.has(activity)) {
+    strategy = "compete";
+    reasons.push(`activity=${activity}: Benefits from multi-perspective Fusion/competition`);
+    confidence = 90;
+    if (FUSION_DEFAULT_ACTIVITIES.has(activity)) {
+      alternatives.push({
+        strategy: "single-pass",
+        reason: "Could use single-pass if time/cost constrained"
+      });
+    }
+    if (activity === "debugging") {
+      alternatives.push({
+        strategy: "autoloop",
+        reason: "Iterative debugging could be more effective for complex bugs"
+      });
+    }
+    return { strategy, reasons, confidence, alternatives, hasExplicitConfig: false };
+  }
+  const executionIntent = task.metadata?.executionIntent;
+  if (executionIntent === "analysis") {
+    strategy = "single-pass";
+    reasons.push("executionIntent=analysis: Single provider sufficient for generic analysis");
+    confidence = 90;
+    alternatives.push({
+      strategy: "compete",
+      reason: "Use Fusion/competition when the task is architecture, design, research, or planning"
+    });
+    return { strategy, reasons, confidence, alternatives, hasExplicitConfig: false };
+  }
+  if (executionIntent === "edit") {
+    reasons.push("executionIntent=edit: Code changes benefit from multi-variant competition");
+  }
+  const category = task.taskClassification?.category;
+  if (!executionIntent && category && SINGLE_PASS_CATEGORIES.has(category)) {
+    strategy = "single-pass";
+    reasons.push(`category=${category}: Single provider sufficient for non-edit oriented work`);
+    confidence = 75;
+    alternatives.push({
+      strategy: "compete",
+      reason: "Competition could provide higher confidence at higher cost"
+    });
+    return { strategy, reasons, confidence, alternatives, hasExplicitConfig: false };
+  }
+  if (executionIntent === "edit") {
+    strategy = "compete";
+    confidence = 75;
+    reasons.push("Default for edit tasks: Competition for quality assurance");
+  } else {
+    strategy = "compete";
+    confidence = 60;
+    reasons.push("No classification signals: Defaulting to competition for quality assurance");
+  }
+  alternatives.push(
+    { strategy: "single-pass", reason: "For simple, well-defined tasks with low risk" },
+    { strategy: "autoloop", reason: "For complex tasks requiring iterative refinement" },
+    { strategy: "parallel", reason: "For independent subtasks that can run concurrently" }
+  );
+  return { strategy, reasons, confidence, alternatives, hasExplicitConfig: false };
+}
+function getDefaultCompetitionVariantsForProvider(provider) {
+  const resolvedProvider = typeof provider === "string" && provider.trim().length > 0 && provider !== "multi" ? provider.trim() : resolveDefaultProvider().value;
+  return [
+    { provider: resolvedProvider, strategy: "conservative" },
+    { provider: resolvedProvider, strategy: "innovative" }
+  ];
+}
+
+// src/core/task-types/resolver.ts
+function normalizeText(text) {
+  return text.toLowerCase();
+}
+function isNegatedDocConstraint(text) {
+  const normalized = normalizeText(text);
+  return /\b(?:do not|don't|no)\s+(?:edit|touch|change|modify|update|write|create|add)?\s*docs?\b/.test(
+    normalized
+  ) || /\bdocs?\s+(?:should|must)\s+not\s+be\s+(?:edited|changed|modified|updated|touched)\b/.test(
+    normalized
+  );
+}
+function hasStrongCodeOnlySignals(text) {
+  const normalized = normalizeText(text);
+  return normalized.includes("code-only") || normalized.includes("src/") || normalized.includes("tests/") || /\b(?:test|tests|cli|command|commands|handler|warning|error|validation)\b/.test(normalized);
+}
+function hasDirectDocumentationDeliverableIntent(text) {
+  return /\b(?:fix|create|update|add|write|generate|improve)\b.{0,40}\b(?:doc|docs|documentation|readme|guideline|guide|instructions|specification)\b/i.test(
+    text
+  ) || /\b(?:doc|docs|documentation|readme|guideline|guide|instructions|specification)\b.{0,40}\b(?:file|page|section|content|reference)\b/i.test(
+    text
+  ) || /(?:^|[\s`'"])(?:docs\/[^\s`'"]+|(?:readme|changelog|claude|agents|gemini)\.md)\b/i.test(text);
+}
+function countKeywordMatches(text, keywords) {
+  const normalized = normalizeText(text);
+  const matched = [];
+  for (const keyword of keywords) {
+    const k = keyword.trim().toLowerCase();
+    if (!k) continue;
+    if (normalized.includes(k)) {
+      matched.push(keyword);
+    }
+  }
+  return { count: matched.length, matched };
+}
+function countRegexMatches(text, regexStrings) {
+  const matched = [];
+  for (const raw of regexStrings) {
+    try {
+      const re = new RegExp(raw, "i");
+      if (re.test(text)) {
+        matched.push(raw);
+      }
+    } catch {
+    }
+  }
+  return { count: matched.length, matched };
+}
+function canonicalMatches(classification, match) {
+  if (!classification || !match?.canonical) return { ok: true, reasons: [], matched: false };
+  const reasons = [];
+  let matchedAny = false;
+  if (Array.isArray(match.canonical.category) && match.canonical.category.length > 0) {
+    const ok = match.canonical.category.includes(classification.category);
+    if (!ok) {
+      return {
+        ok: false,
+        reasons: [`canonical.category mismatch (${classification.category})`],
+        matched: false
+      };
+    }
+    matchedAny = true;
+    reasons.push(`canonical.category=${classification.category}`);
+  }
+  if (Array.isArray(match.canonical.judgeTaskKind) && match.canonical.judgeTaskKind.length > 0) {
+    const ok = match.canonical.judgeTaskKind.includes(classification.judgeTaskKind);
+    if (!ok) {
+      return {
+        ok: false,
+        reasons: [`canonical.judgeTaskKind mismatch (${classification.judgeTaskKind})`],
+        matched: false
+      };
+    }
+    matchedAny = true;
+    reasons.push(`canonical.judgeTaskKind=${classification.judgeTaskKind}`);
+  }
+  return { ok: true, reasons, matched: matchedAny };
+}
+function getPriority(typeDef) {
+  const raw = typeDef.match?.priority;
+  return typeof raw === "number" && Number.isFinite(raw) ? raw : 0;
+}
+function resolveTaskTypeFromCandidates(options) {
+  const { taskText, candidates, classification, fallbackId = "general" } = options;
+  const scored = [];
+  for (const candidate of candidates) {
+    const match = candidate.match;
+    if (!match) {
+      continue;
+    }
+    if (match.suppressWhenCodeOnly === true && hasStrongCodeOnlySignals(taskText)) {
+      if (isNegatedDocConstraint(taskText) || !hasDirectDocumentationDeliverableIntent(taskText)) {
+        continue;
+      }
+    }
+    const {
+      ok: canonicalOk,
+      reasons: canonicalReasons,
+      matched: canonicalMatched
+    } = canonicalMatches(classification, match);
+    if (!canonicalOk) {
+      continue;
+    }
+    const keywords = Array.isArray(match.keywords) ? match.keywords : [];
+    const regex = Array.isArray(match.regex) ? match.regex : [];
+    const keywordMatches = countKeywordMatches(taskText, keywords);
+    const regexMatches = countRegexMatches(taskText, regex);
+    const hasAnySignal = keywordMatches.count > 0 || regexMatches.count > 0;
+    if (!hasAnySignal) {
+      continue;
+    }
+    const reasons = [];
+    reasons.push(...canonicalReasons);
+    for (const k of keywordMatches.matched) reasons.push(`keyword:${k}`);
+    for (const r of regexMatches.matched) reasons.push(`regex:${r}`);
+    const priority = getPriority(candidate);
+    const confidence = Math.min(
+      1,
+      (canonicalMatched ? 0.3 : 0) + Math.min(0.5, keywordMatches.count * 0.1) + Math.min(0.3, regexMatches.count * 0.1)
+    );
+    scored.push({ id: candidate.id, priority, confidence, reasons });
+  }
+  if (scored.length === 0) {
+    return { id: fallbackId, resolvedBy: "fallback", reasons: ["no matcher candidates"] };
+  }
+  scored.sort((a, b) => {
+    if (b.priority !== a.priority) return b.priority - a.priority;
+    if (b.confidence !== a.confidence) return b.confidence - a.confidence;
+    return a.id.localeCompare(b.id);
+  });
+  const best = scored[0];
+  if (!best) {
+    return { id: fallbackId, resolvedBy: "fallback", reasons: ["no matcher candidates"] };
+  }
+  return {
+    id: best.id,
+    resolvedBy: "matcher",
+    confidence: best.confidence,
+    reasons: best.reasons
+  };
+}
+function hasInvestigationSignals(text) {
+  return /\b(investigat|analy[sz]e|audit|assess|review|root\s*cause)\b/i.test(text);
+}
+function classificationForTaskTypeMatching(taskText, classification) {
+  let category = classification.category;
+  let judgeTaskKind = classification.judgeTaskKind;
+  if (isNegatedDocConstraint(taskText) && hasStrongCodeOnlySignals(taskText)) {
+    if (category === "document") {
+      category = "execute";
+    }
+    if ((category === "execute" || category === "test") && !["implementation", "bugfix", "refactor"].includes(judgeTaskKind)) {
+      judgeTaskKind = "implementation";
+    }
+  }
+  if (category === "document" && hasInvestigationSignals(taskText)) {
+    category = "analyze";
+    judgeTaskKind = "analysis";
+  }
+  return { category, judgeTaskKind };
+}
+function resolveTaskTypeWithDeclaration(options) {
+  const hasId = options.hasId ?? (() => true);
+  const explicitId = options.explicitId?.trim();
+  if (explicitId && hasId(explicitId)) {
+    const resolvedBy = options.explicitResolvedBy ?? "frontmatter";
+    return { id: explicitId, resolvedBy, reasons: [`${resolvedBy} override`] };
+  }
+  const declaredType = typeof options.declaredType === "string" && options.declaredType.length > 0 ? options.declaredType : void 0;
+  if (declaredType && options.resolveDeclared) {
+    const mappedId = options.resolveDeclared(declaredType);
+    if (typeof mappedId === "string" && mappedId.length > 0 && hasId(mappedId)) {
+      return {
+        id: mappedId,
+        resolvedBy: "declared",
+        reasons: [`declared:${declaredType}`]
+      };
+    }
+  }
+  const infer = options.inferFallback ?? resolveTaskTypeForText;
+  return infer({
+    taskText: options.taskText,
+    candidates: options.candidates,
+    fallbackId: options.fallbackId,
+    stripInjections: options.stripInjections
+  });
+}
+function resolveTaskTypeForText(options) {
+  const stripInjections = options.stripInjections ?? true;
+  const matcherText = stripInjections ? stripPromptInjections(options.taskText) : options.taskText;
+  const classification = classifyTask(matcherText, {
+    stripInjections: false
+  });
+  const matcherClassification = classificationForTaskTypeMatching(matcherText, classification);
+  return resolveTaskTypeFromCandidates({
+    taskText: matcherText,
+    candidates: options.candidates,
+    classification: matcherClassification,
+    fallbackId: options.fallbackId
+  });
+}
+
+// src/planning/sprint-to-workflow.ts
+var DEFAULT_SPRINT_WORKFLOW_DENYLIST = [
+  // Node
+  "package.json",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "bun.lockb",
+  // Rust
+  "Cargo.toml",
+  "Cargo.lock",
+  // Go
+  "go.mod",
+  "go.sum",
+  // Python
+  "pyproject.toml",
+  "poetry.lock",
+  "uv.lock",
+  "requirements.txt",
+  // Ruby
+  "Gemfile",
+  "Gemfile.lock",
+  // PHP
+  "composer.json",
+  "composer.lock",
+  // .NET (glob-less matcher: *.csproj cannot be expressed; root MSBuild props can)
+  "Directory.Build.props",
+  // CI
+  ".github/workflows/"
+];
+var IGNORED_TARGET_PREFIXES = [
+  ".poetic/planning/",
+  ".poetic/tmp/",
+  ".poetic/cache/",
+  ".poetic/state/",
+  ".poetic/telemetry/",
+  ".poetic/runs/",
+  ".poetic/artifacts/",
+  ".poetic/workflows/",
+  "node_modules/",
+  "dist/",
+  "build/",
+  "coverage/"
+];
+var PATH_REFERENCE_EXTENSION_ALTERNATION = getProjectReferencePathExtensions().map((ext) => ext.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+var PATH_TOKEN_PATTERN = new RegExp(
+  String.raw`(?:^|[\s\u0060'"])((?:\.?\.\/)?(?:[A-Za-z0-9_.-]+\/)+[A-Za-z0-9_.-]*\.(?:${PATH_REFERENCE_EXTENSION_ALTERNATION}))(?:$|[\s\u0060'",.;:)])`,
+  "gi"
+);
+function extractLikelyPathReferences(text) {
+  const candidates = /* @__PURE__ */ new Set();
+  for (const match of text.matchAll(PATH_TOKEN_PATTERN)) {
+    const raw = match[1]?.trim();
+    if (!raw) continue;
+    candidates.add(raw.replace(/^\.\//, ""));
+  }
+  return Array.from(candidates);
+}
+function quoteVerifyArg(value) {
+  if (/^[A-Za-z0-9_./:@%+=,-]+$/.test(value)) return value;
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function extractExactOneLineContent(text) {
+  const match = text.match(/\bexactly\s+one\s+line\s*:\s*([^\n]+)/i);
+  let content = match?.[1]?.trim();
+  if (!content) return void 0;
+  const openingQuote = content[0];
+  if (openingQuote === '"' || openingQuote === "'" || openingQuote === "`") {
+    let escaped = false;
+    let decoded = "";
+    for (let i = 1; i < content.length; i++) {
+      const ch = content[i];
+      if (escaped) {
+        decoded += ch;
+        escaped = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (ch === openingQuote) {
+        content = decoded;
+        return content && content.length > 0 ? content : void 0;
+      }
+      decoded += ch;
+    }
+  }
+  content = content.replace(/\.\s+(?:(?:Do not|Verify|Validation)\b|Acceptance:).*$/i, "").trim();
+  content = content.replace(/\.$/, "").trim();
+  return content && content.length > 0 ? content : void 0;
+}
+function buildExactLineVerifyCommand(pathValue, content) {
+  const encodedContent = Buffer.from(content, "utf8").toString("base64");
+  return `poetic assert exact-line ${quoteVerifyArg(pathValue)} --content-base64 ${encodedContent}`;
+}
+function normalizeBodyVerifyLine(line) {
+  let value = line.trim().replace(/^\s*(?:[-*+]|\d+[.)])\s+/, "").trim();
+  if (!value) return void 0;
+  const codeSpan = value.match(/`([^`]+)`/);
+  if (codeSpan?.[1]) {
+    value = codeSpan[1].trim().replace(/^["']|["']$/g, "").trim();
+    return value.length > 0 ? value : void 0;
+  }
+  value = value.replace(/^run\s+/i, "").trim().replace(/^["']|["']$/g, "").replace(/(?<![./]);$/g, "").replace(/(?<![./])\.$/g, "").trim();
+  return value.length > 0 ? value : void 0;
+}
+function extractBodyVerifyCommands(text) {
+  const lines = text.split(/\r?\n/);
+  const commands = [];
+  let inVerifySection = false;
+  let inFence = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/^```/.test(trimmed)) {
+      if (inVerifySection) {
+        inFence = !inFence;
+      }
+      continue;
+    }
+    if (!inFence && /^#{1,6}\s+/.test(trimmed)) {
+      if (/^#{1,6}\s+how\s+to\s+verify\b/i.test(trimmed)) {
+        inVerifySection = true;
+        continue;
+      }
+      if (inVerifySection) {
+        break;
+      }
+    }
+    if (!inVerifySection) continue;
+    const command = normalizeBodyVerifyLine(line);
+    if (!command) continue;
+    const safety = checkVerifyCommandSafety(command);
+    if (safety.safe && !commands.includes(command)) {
+      commands.push(command);
+    }
+  }
+  return commands;
+}
+function isIgnoredTargetPath(targetPath) {
+  const normalized = targetPath.replace(/\\/g, "/").replace(/^\.\//, "");
+  return IGNORED_TARGET_PREFIXES.some(
+    (prefix) => normalized === prefix.slice(0, -1) || normalized.startsWith(prefix)
+  );
+}
+function normalizeTargetPath(value) {
+  return value.trim().replace(/^`|`$/g, "").replace(/^\.\//, "").replace(/#L\d+(?:-L?\d+)?$/i, "").replace(/\s+\(\s*(?:new|create|modify)\s*\)$/i, "").replace(/[),.;:]+$/g, "");
+}
+function extractCreateAnnotatedFileTargets(text) {
+  const targets = /* @__PURE__ */ new Set();
+  for (const line of text.split("\n")) {
+    const match = line.match(/^\s*FILE:\s*(.+)$/i);
+    if (!match) continue;
+    if (!/\(\s*(?:new|create)\s*\)\s*$/i.test(match[1] ?? "")) continue;
+    const target = normalizeTargetPath(match[1] ?? "");
+    if (target) targets.add(target);
+  }
+  return Array.from(targets);
+}
+function hasCreateFileIntent(text) {
+  return /\b(?:create|scaffold|generate|introduce)\b[\s\S]{0,120}\b(?:file|module|component|template|fixture|script|document|doc)\b/i.test(
+    text
+  ) || /\bnew\s+(?:file|module|component|template|fixture|script|document|doc)\b/i.test(text);
+}
+function inferCreateIntentTargets(options) {
+  const { task, body, stage } = options;
+  const text = `${task.title ?? ""}
+${body.rawBody || body.description || ""}`;
+  const annotatedTargets = extractCreateAnnotatedFileTargets(text);
+  if (annotatedTargets.length > 0) return annotatedTargets;
+  if (!hasCreateFileIntent(text)) return [];
+  return Array.from(
+    new Set(
+      [
+        ...body.fileMarkers,
+        ...stage.allowlist ?? [],
+        ...stage.validation?.requiredFiles ?? [],
+        ...extractLikelyPathReferences(text)
+      ].map(normalizeTargetPath).filter((target) => target.length > 0 && !target.endsWith("/"))
+    )
+  );
+}
+function annotatePromptWithCreateTargets(prompt, createTargets) {
+  if (createTargets.length === 0) return prompt;
+  const remaining = new Set(createTargets);
+  const lines = prompt.split("\n").map((line) => {
+    const match = line.match(/^(\s*)FILE:\s*(.+)$/i);
+    if (!match) return line;
+    const indent = match[1] ?? "";
+    const target = normalizeTargetPath(match[2] ?? "");
+    if (!remaining.has(target)) return line;
+    remaining.delete(target);
+    return `${indent}FILE: ${target} (create)`;
+  });
+  if (remaining.size === 0) return lines.join("\n");
+  const insertion = Array.from(remaining, (target) => `FILE: ${target} (create)`).join("\n");
+  const checklistIndex = lines.findIndex((line) => /^##\s+Checklist\b/i.test(line));
+  if (checklistIndex >= 0) {
+    lines.splice(checklistIndex, 0, "", insertion, "");
+    return lines.join("\n");
+  }
+  return `${lines.join("\n").trimEnd()}
+
+${insertion}
+`;
+}
+function addCreateIntentValidation(stage, createTargets) {
+  if (createTargets.length === 0) return;
+  stage.validation = stage.validation ?? { enabled: false };
+  const requiredFiles = new Set(stage.validation.requiredFiles ?? []);
+  const checks = [...stage.validation.checks ?? []];
+  const existingFileExistsChecks = new Set(
+    checks.filter((check) => check.type === "file-exists").map((check) => normalizeTargetPath(check.path))
+  );
+  for (const target of createTargets) {
+    requiredFiles.add(target);
+    if (!existingFileExistsChecks.has(target)) {
+      checks.push({ type: "file-exists", path: target });
+      existingFileExistsChecks.add(target);
+    }
+  }
+  stage.validation.requiredFiles = Array.from(requiredFiles);
+  stage.validation.checks = checks;
+}
+function taskTypeFrameworkToJudgeType(framework, defaultJudgeType) {
+  if (framework === "multi-lens") return "multi-lens";
+  if (framework === "ai-judge") return "ai";
+  if (framework === "auto") return defaultJudgeType;
+  return defaultJudgeType;
+}
+function getPolicyAwareDefaultCompetitionVariants(provider, policy) {
+  const base = getDefaultCompetitionVariantsForProvider(provider);
+  const preferred = policy?.routing?.defaultStrategy;
+  if (!preferred) return base;
+  const providerId = base[0]?.provider ?? provider ?? resolveDefaultProvider(void 0, process.cwd()).value;
+  if (preferred === "hybrid") {
+    return [
+      { provider: providerId, strategy: "hybrid" },
+      { provider: providerId, strategy: "conservative" }
+    ];
+  }
+  const first = base.find((v) => v.strategy === preferred);
+  const rest = base.filter((v) => v !== first);
+  return first ? [first, ...rest] : base;
+}
+function createDefaultCompetitionConfig(provider, overrides, policy, defaultJudgeType = "ai") {
+  const policyDefaultScore = policy?.judging?.defaultScore;
+  const policyMinimumScore = policy?.judging?.minimumScore;
+  const defaultThresholdRaw = policyDefaultScore ?? 70;
+  const minimumThresholdRaw = policyMinimumScore ?? -Infinity;
+  const defaultThreshold = Math.max(defaultThresholdRaw, minimumThresholdRaw);
+  const config = {
+    variants: getPolicyAwareDefaultCompetitionVariants(provider, policy),
+    judgeConfig: {
+      type: overrides?.judgeType ?? taskTypeFrameworkToJudgeType(policy?.judging?.framework, defaultJudgeType),
+      threshold: defaultThreshold
+    },
+    preserveCandidates: false,
+    applyWinner: true,
+    // Delivery-safe default: verification failures disqualify candidates.
+    verificationPolicy: "blocking",
+    // Enable automatic repair for winners with verification findings
+    repairOnFindings: {
+      enabled: true,
+      maxIterations: 3,
+      timeboxMs: resolveExecutionBoundary("bounded-loop").hardCeilingMs
+    },
+    // Default to 'inconclusive': refuse to break score ties without an LLM verdict.
+    // Users can opt back into deterministic tie-breaking by setting the stage's
+    // tieBreaker explicitly (e.g. 'prefer-first-ranked').
+    tieBreaker: {
+      mode: "inconclusive"
+    }
+  };
+  if (overrides) {
+    if (overrides.verificationPolicy) {
+      config.verificationPolicy = overrides.verificationPolicy;
+    }
+    if (overrides.repairOnFindings !== void 0) {
+      if (!overrides.repairOnFindings.enabled) {
+        config.repairOnFindings = { enabled: false };
+      } else {
+        config.repairOnFindings = {
+          enabled: true,
+          maxIterations: overrides.repairOnFindings.maxIterations ?? 3,
+          timeboxMs: overrides.repairOnFindings.timeboxMs ?? resolveExecutionBoundary("bounded-loop").hardCeilingMs
+        };
+      }
+    }
+    if (overrides.judgeType) {
+      config.judgeConfig = {
+        ...config.judgeConfig ?? { threshold: defaultThreshold },
+        type: overrides.judgeType
+      };
+    }
+    if (overrides.disableAiJudge) {
+      config.judgeConfig = {
+        ...config.judgeConfig ?? { type: defaultJudgeType, threshold: defaultThreshold },
+        disableAiJudge: true
+      };
+    }
+    if (overrides.aiJudgeRun !== void 0 && overrides.aiJudgeRun !== false) {
+      config.judgeConfig = {
+        ...config.judgeConfig ?? { type: defaultJudgeType, threshold: defaultThreshold },
+        runComparison: true
+      };
+    }
+  }
+  return config;
+}
+async function validateAndFilterDependencies(task, sprintTaskIds, completedTaskIds) {
+  const validDeps = [];
+  const satisfiedArchivedDeps = [];
+  const crossSprintDeps = [];
+  const missingDeps = [];
+  const dependencies = Array.isArray(task.dependencies) ? task.dependencies : [];
+  for (const dep of dependencies) {
+    if (sprintTaskIds.has(dep)) {
+      try {
+        const { yaml: depTask } = await getTask(dep, { includeArchive: false });
+        if (depTask.status === "blocked" || depTask.status === "cancelled") {
+          crossSprintDeps.push(`${dep} (status: ${depTask.status})`);
+          continue;
+        }
+      } catch {
+      }
+      validDeps.push(dep);
+    } else {
+      try {
+        const { yaml: depTask, isArchived } = await getTask(dep, { includeArchive: true });
+        const classification = classifyTaskDependency(dep, {
+          task: { status: depTask.status, isArchived }
+        });
+        if (classification.satisfied) {
+          satisfiedArchivedDeps.push(dep);
+        } else {
+          crossSprintDeps.push(isArchived ? `${dep} (archived status: ${depTask.status})` : dep);
+        }
+      } catch {
+        const classification = classifyTaskDependency(dep, {
+          task: null,
+          recordedComplete: completedTaskIds.has(dep)
+        });
+        if (classification.satisfied) {
+          satisfiedArchivedDeps.push(dep);
+        } else {
+          missingDeps.push(dep);
+        }
+      }
+    }
+  }
+  const canExecute = crossSprintDeps.length === 0 && missingDeps.length === 0;
+  return { validDeps, satisfiedArchivedDeps, crossSprintDeps, missingDeps, canExecute };
+}
+async function buildTaskTypeContext(registry) {
+  const candidates = registry.listIds().map((id) => registry.get(id)).filter((v) => v !== null);
+  let aliasMap = TaskTypeAliasMap.empty();
+  try {
+    aliasMap = await TaskTypeAliasMap.load({ cwd: process.cwd() });
+  } catch {
+  }
+  return { registry, candidates, aliasMap };
+}
+function resolveTaskTypePolicy(options) {
+  const { task, taskText, ctx } = options;
+  if (!ctx) return null;
+  const explicitId = task.taskType?.trim() || task.resolvedTaskTypeId?.trim() || void 0;
+  const resolution = resolveTaskTypeWithDeclaration({
+    taskText: stripPromptInjections(taskText),
+    candidates: ctx.candidates,
+    explicitId,
+    explicitResolvedBy: "frontmatter",
+    declaredType: task.declaredType,
+    resolveDeclared: (declared) => ctx.aliasMap.resolve(declared),
+    hasId: (id) => ctx.registry.get(id) !== null,
+    fallbackId: "general",
+    // Preserve the original matcher behavior here: the pure candidate matcher
+    // over already-stripped text (NOT the classification-aware variant), so the
+    // declared-term gate adds a step in front without changing matcher scoring.
+    inferFallback: ({ taskText: text, candidates, fallbackId }) => resolveTaskTypeFromCandidates({ taskText: text, candidates, fallbackId })
+  });
+  const def = ctx.registry.get(resolution.id);
+  return { resolution, policy: def?.policy ?? {} };
+}
+function inferStageContract(task, description, policyExecutionIntent) {
+  const contract = resolveStageContract({
+    title: task.title,
+    text: description,
+    metadataExecutionIntent: task.metadata?.executionIntent,
+    policyExecutionIntent
+  });
+  if (contract.source === "stage-semantics") {
+    const intent = classifyIntent(description);
+    const isHighConfidenceAnalysis = intent.category === "analyze" && intent.confidence > 0.8;
+    return {
+      capabilities: {
+        modifiesFiles: !isHighConfidenceAnalysis,
+        executionIntent: isHighConfidenceAnalysis ? "analysis" : "edit"
+      },
+      source: "intent-classifier",
+      authoritativeAnalysis: false
+    };
+  }
+  return contract;
+}
+async function readTaskBody(taskId) {
+  try {
+    const { filePath } = await getTask(taskId, { includeArchive: true });
+    const { body } = await readMarkdownFile(filePath);
+    return parseTaskBody(body);
+  } catch {
+    return {
+      description: "",
+      subtasks: [],
+      notes: "",
+      fileMarkers: [],
+      rawBody: ""
+    };
+  }
+}
+async function mapTaskToStage(task, body, sprintTaskIds, completedTaskIds, strict, defaultProvider, competitionOverrides, taskTypeContext, defaultJudgeType = "ai") {
+  const warnings = [];
+  const errors = [];
+  const depValidation = await validateAndFilterDependencies(task, sprintTaskIds, completedTaskIds);
+  if (task.status === "blocked") {
+    const msg = `Task ${task.id} is blocked and cannot be executed until unblocked.`;
+    if (strict) {
+      errors.push(msg);
+    } else {
+      warnings.push(`SKIPPING: ${msg}`);
+      return {
+        stage: null,
+        skipped: true,
+        warnings,
+        errors,
+        skipMeta: { taskId: task.id, reason: "blocked", message: msg }
+      };
+    }
+  }
+  if (depValidation.satisfiedArchivedDeps.length > 0) {
+    warnings.push(
+      `Task ${task.id} has archived/completed deps (satisfied): ${depValidation.satisfiedArchivedDeps.join(", ")}`
+    );
+  }
+  if (depValidation.crossSprintDeps.length > 0) {
+    const msg = `Task ${task.id} has cross-sprint deps that are not yet done: ${depValidation.crossSprintDeps.join(", ")}`;
+    if (strict) {
+      errors.push(msg);
+    } else {
+      warnings.push(`SKIPPING: ${msg}`);
+      return {
+        stage: null,
+        skipped: true,
+        warnings,
+        errors,
+        skipMeta: { taskId: task.id, reason: "crossSprintDep", message: msg }
+      };
+    }
+  }
+  if (depValidation.missingDeps.length > 0) {
+    const msg = `Task ${task.id} has missing deps: ${depValidation.missingDeps.join(", ")}`;
+    if (strict) {
+      errors.push(msg);
+    } else {
+      warnings.push(`SKIPPING: ${msg}`);
+      return {
+        stage: null,
+        skipped: true,
+        warnings,
+        errors,
+        skipMeta: { taskId: task.id, reason: "missing", message: msg }
+      };
+    }
+  }
+  const taskText = `${task.title}
+
+${body.rawBody || body.description || ""}`;
+  const taskTypePolicy = resolveTaskTypePolicy({ task, taskText, ctx: taskTypeContext });
+  if (task.taskType && taskTypeContext && taskTypePolicy?.resolution.resolvedBy !== "frontmatter") {
+    warnings.push(`Task ${task.id}: unknown taskType override '${task.taskType}' (falling back)`);
+  }
+  if (taskTypePolicy && (taskTypePolicy.resolution.id !== "general" || task.taskType)) {
+    warnings.push(
+      `Task ${task.id}: taskType=${taskTypePolicy.resolution.id} (${taskTypePolicy.resolution.resolvedBy})`
+    );
+  }
+  const stagePolicyExecutionIntent = taskTypePolicy?.resolution.resolvedBy === "fallback" ? void 0 : taskTypePolicy?.policy.executionIntent;
+  const stageContract = inferStageContract(task, taskText, stagePolicyExecutionIntent);
+  const capabilities = stageContract.capabilities;
+  const validation = capabilities.executionIntent === "analysis" ? { enabled: false } : { enabled: true, threshold: 60 };
+  void (capabilities.executionIntent === "analysis");
+  const stage = {
+    id: task.id,
+    name: task.title,
+    deps: depValidation.validDeps.length > 0 ? depValidation.validDeps : void 0,
+    prompt: buildPromptFromTask(task, body),
+    capabilities,
+    validation
+  };
+  const inferredAllowlistTargets = Array.from(
+    /* @__PURE__ */ new Set([
+      ...body.fileMarkers,
+      ...extractLikelyPathReferences(taskText),
+      ...task.flywheel?.validation?.requiredFiles ?? []
+    ])
+  );
+  const groundedInferredAllowlistTargets = inferredAllowlistTargets.filter(
+    (target) => !isIgnoredTargetPath(target)
+  );
+  if (taskTypePolicy) {
+    stage.templateVariables = {
+      ...stage.templateVariables,
+      taskTypeId: taskTypePolicy.resolution.id,
+      taskTypeResolvedBy: taskTypePolicy.resolution.resolvedBy
+    };
+    const taskTypeAllowlistMode = taskTypePolicy.policy.allowlist?.mode;
+    const hasAllowlistScope = (stage.allowlist?.length ?? 0) > 0 || (task.flywheel?.allowlist?.length ?? 0) > 0 || groundedInferredAllowlistTargets.length > 0;
+    const requiresNonEmptyAllowlist = taskTypePolicy.policy.allowlist?.requireNonEmpty === true;
+    if (!task.flywheel?.allowlistMode && taskTypeAllowlistMode && !stage.allowlistMode) {
+      if (taskTypeAllowlistMode === "strict" && requiresNonEmptyAllowlist && !hasAllowlistScope && capabilities.executionIntent !== "analysis") {
+        const msg = `Task ${task.id}: taskType policy requires a non-empty allowlist; refine the task scope before execution`;
+        if (strict) {
+          errors.push(msg);
+        } else {
+          warnings.push(`SKIPPING: ${msg}`);
+          return {
+            stage: null,
+            skipped: true,
+            warnings,
+            errors,
+            skipMeta: { taskId: task.id, reason: "refinement", message: msg }
+          };
+        }
+      } else {
+        stage.allowlistMode = taskTypeAllowlistMode;
+      }
+    }
+    if (requiresNonEmptyAllowlist && stage.allowlistMode === "strict" && !hasAllowlistScope) {
+      warnings.push(`Task ${task.id}: taskType policy requires a non-empty allowlist (strict)`);
+    }
+  }
+  if (task.routing) {
+    if (task.routing.provider) {
+      stage.provider = task.routing.provider;
+    }
+    if (task.routing.model) {
+      stage.model = task.routing.model;
+    }
+    if (task.routing.strategy || task.routing.reasoning || task.routing.profile) {
+      stage.templateVariables = {
+        ...stage.templateVariables,
+        routingStrategy: task.routing.strategy,
+        routingReasoning: task.routing.reasoning,
+        routingProfile: task.routing.profile
+      };
+    }
+    const pins = [
+      task.routing.provider && `provider=${task.routing.provider}`,
+      task.routing.model && `model=${task.routing.model}`,
+      task.routing.strategy && `strategy=${task.routing.strategy}`
+    ].filter(Boolean).join(", ");
+    if (pins) {
+      warnings.push(`Task ${task.id} has routing pins: ${pins}`);
+    }
+  }
+  if (task.flywheel) {
+    if (task.flywheel.type) {
+      stage.type = task.flywheel.type;
+    }
+    if (task.flywheel.inputs && task.flywheel.inputs.length > 0) {
+      stage.inputs = task.flywheel.inputs;
+    }
+    if (task.flywheel.outputs) {
+      stage.outputs = task.flywheel.outputs;
+    }
+    if (task.flywheel.validation) {
+      stage.validation = {
+        ...stage.validation ?? { enabled: false },
+        ...task.flywheel.validation
+      };
+    }
+    if (task.flywheel.competition) {
+      stage.type = "competition";
+      stage.competition = task.flywheel.competition;
+    }
+    if (task.flywheel.allowEmptyResults !== void 0) {
+      stage.allowEmptyResults = task.flywheel.allowEmptyResults;
+    }
+    if (task.flywheel.allowlist && task.flywheel.allowlist.length > 0) {
+      stage.allowlist = task.flywheel.allowlist;
+    }
+    if (task.flywheel.allowlistMode) {
+      stage.allowlistMode = task.flywheel.allowlistMode;
+    }
+    if (task.flywheel.allowDenylist && task.flywheel.allowDenylist.length > 0) {
+      stage.allowDenylist = task.flywheel.allowDenylist;
+    }
+    if (task.flywheel.verify && task.flywheel.verify.commands.length > 0) {
+      stage.verify = task.flywheel.verify;
+    }
+    if (task.flywheel.type === "autoloop" || task.flywheel.autoloop) {
+      stage.type = "autoloop";
+      stage.autoloop = task.flywheel.autoloop ?? {};
+      warnings.push(
+        `Task ${task.id}: Explicit autoloop configuration applied (maxIterations: ${stage.autoloop.maxIterations ?? 3})`
+      );
+    }
+    if (stage.type === "verify" && stage.verify?.commands && stage.verify.commands.length > 0) {
+      if (stage.validation?.semanticChecks) {
+        delete stage.validation.semanticChecks;
+      }
+    }
+  }
+  if (!hasExplicitFlywheelConfig(task)) {
+    const isExplicitAnalysisIntent = capabilities.executionIntent === "analysis" && stageContract.authoritativeAnalysis;
+    const isFusionDefaultActivity = task.taskClassification?.activity !== void 0 && FUSION_DEFAULT_ACTIVITIES.has(task.taskClassification.activity);
+    const useMatchedAnalysisIntent = !task.taskClassification && taskTypePolicy?.resolution.id === "analysis" && taskTypePolicy.policy.executionIntent === "analysis";
+    const policyExecutionIntent = taskTypePolicy?.policy.executionIntent;
+    const strategyExecutionIntent = task.metadata?.executionIntent ?? (policyExecutionIntent === "analysis" && (task.taskType || useMatchedAnalysisIntent) ? policyExecutionIntent : void 0);
+    const strategyTask = strategyExecutionIntent && strategyExecutionIntent !== task.metadata?.executionIntent ? {
+      ...task,
+      metadata: {
+        ...task.metadata,
+        executionIntent: strategyExecutionIntent
+      }
+    } : task;
+    const preferCompetition = isFusionDefaultActivity || taskTypePolicy?.policy.routing?.preferCompetition === true && !isExplicitAnalysisIntent;
+    const strategySelection = competitionOverrides?.forceSinglePass ? {
+      strategy: "single-pass",
+      reasons: ["--single-pass requested"],
+      confidence: 100,
+      hasExplicitConfig: false
+    } : isExplicitAnalysisIntent && !isFusionDefaultActivity ? {
+      strategy: "single-pass",
+      reasons: ["analysis intent avoids competition fan-in"],
+      confidence: 100,
+      hasExplicitConfig: false
+    } : preferCompetition ? {
+      strategy: "compete",
+      reasons: [
+        isFusionDefaultActivity ? "activity defaults to Fusion-style competition" : "taskType policy prefers competition"
+      ],
+      confidence: 100,
+      hasExplicitConfig: false
+    } : selectExecutionStrategy(strategyTask);
+    const preferredProvider = task.routing?.provider ?? defaultProvider;
+    if (strategySelection.strategy === "compete") {
+      stage.type = "competition";
+      stage.competition = createDefaultCompetitionConfig(
+        preferredProvider,
+        competitionOverrides,
+        taskTypePolicy?.policy,
+        defaultJudgeType
+      );
+      warnings.push(
+        `Task ${task.id}: Strategy selection \u2192 competition (${strategySelection.reasons.join("; ")})`
+      );
+    } else if (strategySelection.strategy === "single-pass") {
+      stage.type = "standard";
+      warnings.push(
+        `Task ${task.id}: Strategy selection \u2192 single-pass (${strategySelection.reasons.join("; ")})`
+      );
+    } else if (strategySelection.strategy === "autoloop" || strategySelection.strategy === "parallel") {
+      stage.type = "standard";
+      warnings.push(
+        `Task ${task.id}: Strategy selection \u2192 ${strategySelection.strategy} (mapped to standard; full support pending) (${strategySelection.reasons.join("; ")})`
+      );
+    }
+  }
+  if (stage.type === "competition" && task.flywheel?.validation?.enabled === void 0) {
+    stage.validation = { ...stage.validation ?? { enabled: false }, enabled: false };
+  }
+  if (stage.type === "competition" && stage.competition && competitionOverrides?.judgeType) {
+    stage.competition.judgeConfig = {
+      ...stage.competition.judgeConfig ?? { threshold: 70 },
+      type: competitionOverrides.judgeType
+    };
+  }
+  if (stage.type === "competition" && stage.competition && taskTypePolicy) {
+    if (!stage.competition.judgeConfig) {
+      stage.competition.judgeConfig = {
+        type: defaultJudgeType,
+        threshold: 70
+      };
+    }
+    const judgeConfig = stage.competition.judgeConfig;
+    const defaultScore = taskTypePolicy.policy.judging?.defaultScore;
+    if (judgeConfig.threshold === void 0 && typeof defaultScore === "number") {
+      judgeConfig.threshold = defaultScore;
+    }
+    const minimumScore = taskTypePolicy.policy.judging?.minimumScore;
+    if (typeof minimumScore === "number") {
+      const current = judgeConfig.threshold ?? 0;
+      if (current < minimumScore) {
+        judgeConfig.threshold = minimumScore;
+        warnings.push(
+          `Task ${task.id}: clamped judge threshold to ${minimumScore} (taskType minimumScore)`
+        );
+      }
+    }
+  }
+  if (stage.allowEmptyResults === void 0) {
+    const descriptionText = `${task.title ?? ""}
+${body.rawBody ?? body.description ?? ""}`.toLowerCase();
+    const idempotentPatterns = /\b(idempotent|make no (?:repository |file )?changes|no changes (?:needed|required|expected)|already (?:correct|satisfied|present)|succeed with (?:no|zero) (?:changes|edits|file changes))\b/;
+    if (idempotentPatterns.test(descriptionText)) {
+      stage.allowEmptyResults = true;
+      warnings.push(
+        `Task ${task.id}: auto-detected idempotent intent from description \u2192 allowEmptyResults=true`
+      );
+    }
+  }
+  if (stage.capabilities?.executionIntent === "analysis" && stage.allowEmptyResults === void 0) {
+    stage.allowEmptyResults = true;
+  }
+  if (stage.validation?.requireChanges === void 0) {
+    const isEditIntent = stage.capabilities?.executionIntent === "edit";
+    const isApplyWinnerCompetition = stage.type === "competition" && stage.competition?.applyWinner === true;
+    if (stage.allowEmptyResults === true) {
+      stage.validation = stage.validation ?? { enabled: false };
+      stage.validation.requireChanges = false;
+    } else if (isEditIntent || isApplyWinnerCompetition) {
+      stage.validation = stage.validation ?? { enabled: false };
+      stage.validation.requireChanges = true;
+    }
+  }
+  if (stage.capabilities?.executionIntent === "analysis" && !stage.outputs) {
+    stage.outputs = { report: "text" };
+  }
+  const taskTargetPaths = Array.from(
+    /* @__PURE__ */ new Set([
+      ...inferredAllowlistTargets,
+      ...stage.allowlist ?? [],
+      ...stage.validation?.requiredFiles ?? []
+    ])
+  );
+  if ((stage.allowlist?.length ?? 0) === 0 && groundedInferredAllowlistTargets.length > 0) {
+    stage.allowlist = groundedInferredAllowlistTargets;
+  }
+  const exactLineContent = extractExactOneLineContent(body.rawBody ?? body.description ?? "");
+  const exactLineTargets = (stage.allowlist ?? []).filter((target) => !isIgnoredTargetPath(target));
+  if (exactLineContent && exactLineTargets.length === 1) {
+    const command = buildExactLineVerifyCommand(exactLineTargets[0], exactLineContent);
+    const existingCommands = stage.verify?.commands ?? [];
+    if (!existingCommands.includes(command)) {
+      stage.verify = { commands: [...existingCommands, command] };
+      warnings.push(`Task ${task.id}: added exact-line verify command for ${exactLineTargets[0]}`);
+    }
+  }
+  if ((stage.verify?.commands?.length ?? 0) === 0) {
+    const bodyVerifyCommands = extractBodyVerifyCommands(body.rawBody ?? body.description ?? "");
+    if (bodyVerifyCommands.length > 0) {
+      stage.verify = { commands: bodyVerifyCommands };
+      warnings.push(
+        `Task ${task.id}: added ${bodyVerifyCommands.length} verify command(s) from How to Verify`
+      );
+    }
+  }
+  const ignoredTargets = taskTargetPaths.filter(isIgnoredTargetPath);
+  if (ignoredTargets.length > 0) {
+    const message = `Task ${task.id}: target path(s) are gitignored/runtime-scoped and may produce no fan-in material: ` + ignoredTargets.join(", ");
+    if (strict) {
+      errors.push(message);
+    } else {
+      warnings.push(`${message}. Use tracked paths for change-producing sprint validation tasks.`);
+    }
+  }
+  const createIntentTargets = inferCreateIntentTargets({ task, body, stage });
+  if (createIntentTargets.length > 0) {
+    stage.prompt = annotatePromptWithCreateTargets(stage.prompt ?? "", createIntentTargets);
+    const validationTargets = createIntentTargets.filter((target) => !isIgnoredTargetPath(target));
+    addCreateIntentValidation(stage, validationTargets);
+  }
+  if (stage.validation?.enabled && stage.outputs && Object.keys(stage.outputs).length > 1) {
+    if (!stage.validation.target) {
+      if (Object.hasOwn(stage.outputs, "bundle")) {
+        stage.validation.target = "bundle";
+      } else {
+        const entries = Object.entries(stage.outputs);
+        const diffEntry = entries.find(([, type]) => type === "diff");
+        const filesEntry = entries.find(([, type]) => type === "files");
+        stage.validation.target = diffEntry?.[0] ?? filesEntry?.[0] ?? Object.keys(stage.outputs)[0] ?? void 0;
+      }
+      if (stage.validation.target) {
+        warnings.push(
+          `Stage ${task.id}: defaulted validation.target to '${stage.validation.target}' for multi-output stage`
+        );
+      }
+    }
+  }
+  const hasAssignmentOutput = stage.type !== "competition" && Boolean(stage.outputs && Object.hasOwn(stage.outputs, "assignment"));
+  if (hasAssignmentOutput && stage.capabilities?.executionIntent === "analysis") {
+    stage.validation = stage.validation ?? { enabled: false };
+    stage.validation.semanticChecks = stage.validation.semanticChecks ?? getP1SemanticChecks();
+    stage.validation.onFailure = stage.validation.onFailure ?? "retry-with-feedback";
+    stage.validation.maxRetries = stage.validation.maxRetries ?? 2;
+    warnings.push(
+      `Stage ${task.id}: applied default semantic assignment gates + retry-with-feedback (${stage.validation.maxRetries} retries)`
+    );
+  }
+  return {
+    stage,
+    skipped: false,
+    warnings,
+    errors
+  };
+}
+async function buildWorkflowStages(tasks, sprintTaskIds, completedTaskIds, strict, initialSkippedTaskIds, defaultProvider, competitionOverrides, taskTypeContext, defaultJudgeType = "ai") {
+  const stages = [];
+  const skippedTaskIds = new Set(initialSkippedTaskIds);
+  const skippedTasks = [];
+  const allWarnings = [];
+  const allErrors = [];
+  const mappingResults = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    const body = await readTaskBody(task.id);
+    const result = await mapTaskToStage(
+      task,
+      body,
+      sprintTaskIds,
+      completedTaskIds,
+      strict,
+      defaultProvider,
+      competitionOverrides,
+      taskTypeContext,
+      defaultJudgeType
+    );
+    mappingResults.set(task.id, result);
+    if (result.skipped) {
+      skippedTaskIds.add(task.id);
+      if (result.skipMeta) {
+        skippedTasks.push(result.skipMeta);
+      }
+    }
+    allWarnings.push(...result.warnings);
+    allErrors.push(...result.errors);
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const [taskId, result] of mappingResults) {
+      if (result.skipped) continue;
+      if (!result.stage) continue;
+      const hasSkippedDep = result.stage.deps?.some((dep) => skippedTaskIds.has(dep)) ?? false;
+      if (hasSkippedDep) {
+        const skippedDeps = result.stage.deps?.filter((dep) => skippedTaskIds.has(dep)) ?? [];
+        const msg = `Task ${taskId} depends on skipped tasks: ${skippedDeps.join(", ")}`;
+        allWarnings.push(`SKIPPING: ${msg}`);
+        skippedTaskIds.add(taskId);
+        skippedTasks.push({ taskId, reason: "dependsOnSkipped", message: msg });
+        result.skipped = true;
+        result.stage = null;
+        changed = true;
+      }
+    }
+  }
+  for (const [_taskId, result] of mappingResults) {
+    if (result.stage && !result.skipped) {
+      if (result.stage.deps) {
+        result.stage.deps = result.stage.deps.filter((dep) => !skippedTaskIds.has(dep));
+      }
+      stages.push(result.stage);
+    }
+  }
+  return { stages, skippedTaskIds, skippedTasks, warnings: allWarnings, errors: allErrors };
+}
+async function collectTasksWithUnfilledSpecMarkers(tasks) {
+  const taskIds = [];
+  for (const task of tasks) {
+    const body = await readTaskBody(task.id);
+    if (hasUnfilledMarkers(body.rawBody || body.description || "")) {
+      taskIds.push(task.id);
+    }
+  }
+  return taskIds;
+}
+async function loadSprintData(sprintId) {
+  const planningRoot = getPlanningRoot();
+  const sprintPath = path.join(getBucketPathByKind("sprint", planningRoot), `${sprintId}.md`);
+  try {
+    const { frontMatter } = await readMarkdownFile(sprintPath);
+    return {
+      taskIds: frontMatter.taskIds || [],
+      completedTaskIds: frontMatter.completedTaskIds || []
+    };
+  } catch (_error) {
+    try {
+      const archivedRoot = getBucketArchivePathByKind("sprint", planningRoot);
+      const files = await listMarkdownFilesRecursive(archivedRoot);
+      const file = files.find((p) => path.basename(p) === `${sprintId}.md`);
+      if (!file) {
+        throw new Error("not found");
+      }
+      const { frontMatter } = await readMarkdownFile(file);
+      return {
+        taskIds: frontMatter.taskIds || [],
+        completedTaskIds: frontMatter.completedTaskIds || []
+      };
+    } catch {
+      throw new Error(`Sprint not found: ${sprintId}`);
+    }
+  }
+}
+async function validateAndLoadTasks(taskIds, strict) {
+  const tasks = [];
+  const warnings = [];
+  const errors = [];
+  const skippedIds = [];
+  const archivedIds = [];
+  const doneIds = [];
+  const skippedTasks = [];
+  for (const taskId of taskIds) {
+    try {
+      const { yaml: task, isArchived } = await getTask(taskId, { includeArchive: true });
+      if (isArchived) {
+        const msg = `Task ${taskId} is archived (already completed).`;
+        if (strict) {
+          errors.push(msg);
+        } else {
+          warnings.push(`SKIPPING: ${msg}`);
+          skippedIds.push(taskId);
+          archivedIds.push(taskId);
+          skippedTasks.push({ taskId, reason: "archived", message: msg });
+        }
+        continue;
+      }
+      if (task.status === "done") {
+        const msg = `Task ${taskId} is already done (status: done).`;
+        if (strict) {
+          errors.push(msg);
+        } else {
+          warnings.push(`SKIPPING: ${msg}`);
+          skippedIds.push(taskId);
+          doneIds.push(taskId);
+          skippedTasks.push({ taskId, reason: "done", message: msg });
+        }
+        continue;
+      }
+      tasks.push(task);
+    } catch {
+      const isBacklogId = taskId.startsWith("backlog-") || taskId.includes("backlog");
+      if (isBacklogId) {
+        const msg = `Task ${taskId} looks like a backlog ID without a task file. Use 'sprint add-task --split' to create task files.`;
+        if (strict) {
+          errors.push(msg);
+        } else {
+          warnings.push(`SKIPPING: ${msg}`);
+          skippedIds.push(taskId);
+          skippedTasks.push({ taskId, reason: "backlogId", message: msg });
+        }
+      } else {
+        const msg = `Task file not found: ${taskId}`;
+        if (strict) {
+          errors.push(msg);
+        } else {
+          warnings.push(`SKIPPING: ${msg}`);
+          skippedIds.push(taskId);
+          skippedTasks.push({ taskId, reason: "missing", message: msg });
+        }
+      }
+    }
+  }
+  return { tasks, warnings, errors, skippedIds, archivedIds, doneIds, skippedTasks };
+}
+async function writeWorkflowYaml(workflow, sprintId, workflowId) {
+  let filePath;
+  if (workflowId) {
+    filePath = getWorkflowYamlPath(workflowId);
+    const artifactDir = path.dirname(filePath);
+    await fs.mkdir(artifactDir, { recursive: true });
+  } else {
+    const planningRoot = getPlanningRoot();
+    const workflowsDir = path.join(planningRoot, ".poetic", "workflows");
+    await fs.mkdir(workflowsDir, { recursive: true });
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const filename = `sprint-${sprintId}-${timestamp}.yaml`;
+    filePath = path.join(workflowsDir, filename);
+  }
+  const yamlContent = yaml.dump(workflow, {
+    indent: 2,
+    lineWidth: 120,
+    noRefs: true
+  });
+  await fs.writeFile(filePath, yamlContent, "utf-8");
+  return filePath;
+}
+async function generateSprintWorkflow(options) {
+  const {
+    sprintId,
+    taskIds: specificTaskIds,
+    provider,
+    strict = false,
+    competitionOverrides,
+    acceptIncompleteSpec = false
+  } = options;
+  const warnings = [];
+  const errors = [];
+  const skippedTaskIds = [];
+  const skippedTasks = [];
+  let sprintTaskIds;
+  let sprintCompletedTaskIds;
+  try {
+    const sprint = await loadSprintData(sprintId);
+    sprintTaskIds = specificTaskIds ?? sprint.taskIds;
+    sprintCompletedTaskIds = sprint.completedTaskIds;
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return {
+      workflow: null,
+      yamlPath: "",
+      warnings: [],
+      errors: [msg],
+      skippedTaskIds: [],
+      skippedTasks: []
+    };
+  }
+  if (sprintTaskIds.length === 0) {
+    const msg = "Sprint has no tasks. Add tasks with `sprint add-task` first.";
+    return {
+      workflow: null,
+      yamlPath: "",
+      warnings: [],
+      errors: [msg],
+      skippedTaskIds: [],
+      skippedTasks: []
+    };
+  }
+  const loadResult = await validateAndLoadTasks(sprintTaskIds, strict);
+  warnings.push(...loadResult.warnings);
+  errors.push(...loadResult.errors);
+  skippedTaskIds.push(...loadResult.skippedIds);
+  skippedTasks.push(...loadResult.skippedTasks);
+  for (const id of loadResult.archivedIds) {
+    if (!skippedTaskIds.includes(id)) {
+      skippedTaskIds.push(id);
+    }
+  }
+  if (strict && errors.length > 0) {
+    return { workflow: null, yamlPath: "", warnings, errors, skippedTaskIds, skippedTasks };
+  }
+  const incompleteSpecTaskIds = await collectTasksWithUnfilledSpecMarkers(loadResult.tasks);
+  if (incompleteSpecTaskIds.length > 0) {
+    const message = `Task spec(s) contain unfilled <<<FILL>>> placeholders: ${incompleteSpecTaskIds.join(", ")}`;
+    if (!acceptIncompleteSpec) {
+      return {
+        workflow: null,
+        yamlPath: "",
+        warnings,
+        errors: [
+          `${message}. Complete the task specs or rerun with --accept-incomplete-spec to proceed anyway.`
+        ],
+        skippedTaskIds,
+        skippedTasks
+      };
+    }
+    warnings.push(`${message}; continuing because --accept-incomplete-spec was provided.`);
+  }
+  let taskTypeContext = null;
+  try {
+    taskTypeContext = await buildTaskTypeContext(
+      await TaskTypeRegistry.load({ cwd: process.cwd() })
+    );
+  } catch (error) {
+    warnings.push(
+      `Task types disabled (failed to load registry): ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const defaultJudgeType = resolveJudgeType(void 0, process.cwd()).value;
+  const completedTaskIds = /* @__PURE__ */ new Set([...loadResult.archivedIds, ...loadResult.doneIds]);
+  for (const id of sprintCompletedTaskIds) completedTaskIds.add(id);
+  const sprintTaskSet = new Set(sprintTaskIds.filter((id) => !completedTaskIds.has(id)));
+  const buildResult = await buildWorkflowStages(
+    loadResult.tasks,
+    sprintTaskSet,
+    completedTaskIds,
+    strict,
+    new Set(loadResult.skippedIds),
+    provider,
+    competitionOverrides,
+    taskTypeContext,
+    defaultJudgeType
+  );
+  warnings.push(...buildResult.warnings);
+  errors.push(...buildResult.errors);
+  for (const id of buildResult.skippedTaskIds) {
+    if (!skippedTaskIds.includes(id)) {
+      skippedTaskIds.push(id);
+    }
+  }
+  for (const s of buildResult.skippedTasks) {
+    if (!skippedTasks.some((existing) => existing.taskId === s.taskId)) {
+      skippedTasks.push(s);
+    }
+  }
+  if (strict && errors.length > 0) {
+    return { workflow: null, yamlPath: "", warnings, errors, skippedTaskIds, skippedTasks };
+  }
+  if (buildResult.stages.length === 0) {
+    const allSkippedMsg = `All ${skippedTaskIds.length} task(s) were skipped. Nothing to execute.`;
+    if (strict) {
+      return {
+        workflow: null,
+        yamlPath: "",
+        warnings,
+        errors: [...errors, allSkippedMsg],
+        skippedTaskIds,
+        skippedTasks
+      };
+    }
+    return {
+      workflow: null,
+      yamlPath: "",
+      warnings: [...warnings, allSkippedMsg],
+      errors: [],
+      skippedTaskIds,
+      skippedTasks
+    };
+  }
+  const workflow = {
+    name: `Sprint: ${sprintId}`,
+    stages: buildResult.stages,
+    strict: {
+      // Warn-first by default: allow stages to make ripple edits without hard-failing.
+      allowlistMode: "warn",
+      // Hard safety rail: prevent accidental high-impact edits unless explicitly allowlisted.
+      denylist: DEFAULT_SPRINT_WORKFLOW_DENYLIST
+    },
+    git: {
+      commitStrategy: "pass-only",
+      // Default to Run → Review → Integrate: preserve the integration branch/worktree.
+      historyCleanup: "keep-all",
+      skipHooksOnIntermediate: true
+    }
+  };
+  if (provider) {
+    for (const stage of workflow.stages) {
+      if (!stage.provider) {
+        stage.provider = provider;
+      }
+    }
+  }
+  const stampedWorkflow = applyExecutionPolicyToGeneratedWorkflow(workflow, {
+    cliProviderOverride: provider,
+    warnings
+  });
+  let yamlPath = "";
+  if (!options.dryRun) {
+    yamlPath = await writeWorkflowYaml(stampedWorkflow, sprintId, options.workflowId);
+  }
+  return {
+    workflow: stampedWorkflow,
+    yamlPath,
+    warnings,
+    errors,
+    skippedTaskIds,
+    skippedTasks
+  };
+}
+function applyExecutionPolicyToGeneratedWorkflow(workflow, options) {
+  const existingStamp = workflow.metadata?.executionPolicy;
+  if (existingStamp !== void 0) {
+    if (isCurrentExecutionPolicyWorkflow(workflow)) return workflow;
+    throw new Error(
+      `Generated workflow has a stale or malformed execution-policy stamp (${describeExecutionPolicyStampMismatch(existingStamp)}); regenerate the workflow.`
+    );
+  }
+  const cliOverrides = {
+    executorProvider: options.cliProviderOverride,
+    orchestratorProvider: options.orchestratorOverrideIsExplicit ? options.orchestratorProviderOverride : void 0,
+    orchestratorModel: options.orchestratorOverrideIsExplicit ? options.orchestratorModelOverride : void 0
+  };
+  const roles = resolveExecutionRoles({
+    cwd: process.cwd(),
+    cli: Object.values(cliOverrides).some(Boolean) ? cliOverrides : void 0,
+    additionalReviewerExcludes: collectCompetitionExecutorProviders(workflow),
+    effectiveOrchestrator: options.orchestratorProviderOverride && !options.orchestratorOverrideIsExplicit ? {
+      provider: options.orchestratorProviderOverride,
+      model: options.orchestratorModelOverride,
+      sourcePath: "artifact:executionDefaults"
+    } : void 0
+  });
+  const hasTaskExecutionStage = workflow.stages.some((stage) => {
+    const stageType = stage.type ?? "standard";
+    if (stageType === "standard" || stageType === "competition") return true;
+    return stage.seededPlan?.subStages.some((subStage) => {
+      const subStageType = subStage.type ?? "standard";
+      return subStageType === "standard" || subStageType === "competition";
+    });
+  });
+  const sameAsExecutor = roles.reviewAssurance?.executorSeparation === "same-as-executor" || roles.sameVendorReview;
+  if (isExecutionPolicyEngaged(roles) && sameAsExecutor && hasTaskExecutionStage) {
+    throw new Error(
+      `Execution policy requires executor separation (reviewer provider != executor provider(s)), but reviewer resolved to executor provider '${roles.executor.provider.value}'. Configure another reviewer provider (reviewer may match the orchestrator), or set the reviewer gate to off.`
+    );
+  }
+  return applyExecutionPolicy(workflow, roles, {
+    cliProviderOverride: options.cliProviderOverride,
+    onNotice: (message) => options.warnings.push(message)
+  });
+}
+function collectCompetitionExecutorProviders(workflow) {
+  const providers = /* @__PURE__ */ new Set();
+  const visit = (stage) => {
+    if (stage.type === "competition") {
+      for (const variant of stage.competition?.variants ?? []) {
+        const provider = variant.provider?.trim();
+        if (provider) providers.add(provider);
+      }
+    }
+    if (stage.type === "orchestrator" && stage.seededPlan) {
+      for (const subStage of stage.seededPlan.subStages) visit(subStage);
+    }
+  };
+  for (const stage of workflow.stages) visit(stage);
+  return [...providers];
+}
+
+export {
+  FUSION_DEFAULT_ACTIVITIES,
+  getDefaultCompetitionVariantsForProvider,
+  resolveTaskTypeFromCandidates,
+  resolveTaskTypeWithDeclaration,
+  resolveTaskTypeForText,
+  resolveStageContract,
+  createDefaultCompetitionConfig,
+  generateSprintWorkflow,
+  applyExecutionPolicyToGeneratedWorkflow
+};
+//# sourceMappingURL=chunk-GFGYB2ZU.js.map