@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-MO2BYAAF.js

@@ -0,0 +1,2896 @@
+import {
+  classifyTask,
+  classifyTaskForRouting,
+  stripPromptInjections,
+  toCanonicalRoutingClassificationInput
+} from "./chunk-JHP7OT6K.js";
+import {
+  getP1SemanticChecks
+} from "./chunk-G6OIMVXH.js";
+import {
+  assertReviewerOrderUsable,
+  resolveReviewerEligibility
+} from "./chunk-JDCZQZU7.js";
+import {
+  applyExecutionPolicy,
+  describeExecutionPolicyStampMismatch,
+  isCurrentExecutionPolicyWorkflow,
+  isExecutionPolicyEngaged
+} from "./chunk-YTVVTIWJ.js";
+import {
+  expectsCodeEdits,
+  extractTaskContract
+} from "./chunk-SU6UFUQY.js";
+import {
+  parsePromptSpec
+} from "./chunk-INJ3SS6A.js";
+import {
+  getTask
+} from "./chunk-7LHJDJB3.js";
+import {
+  TaskTypeAliasMap
+} from "./chunk-2KO7HVZM.js";
+import {
+  hasUnfilledMarkers
+} from "./chunk-UAPHFJPN.js";
+import {
+  TaskTypeRegistry
+} from "./chunk-6T6NHXK4.js";
+import {
+  buildPromptFromTask,
+  parseTaskBody,
+  stripTaskHeaderMetadata
+} from "./chunk-US3RT6CY.js";
+import {
+  classifyIntent
+} from "./chunk-GI5M67YA.js";
+import {
+  extractAcceptanceCriteria
+} from "./chunk-XON4ZCYX.js";
+import {
+  classifyExplicitNoEdit
+} from "./chunk-PPHXX4W7.js";
+import {
+  classifyTaskDependency
+} from "./chunk-NXH3RX7O.js";
+import {
+  extractCreateAnnotatedFilePaths
+} from "./chunk-ETA2K4KI.js";
+import {
+  getPlanningRoot
+} from "./chunk-CSXLLEGB.js";
+import {
+  getBucketArchivePathByKind,
+  getBucketPathByKind
+} from "./chunk-V3KLVK7B.js";
+import {
+  resolveExecutionRoles
+} from "./chunk-32IYXIE5.js";
+import {
+  getWorkflowYamlPath
+} from "./chunk-6TRD7TEE.js";
+import {
+  resolveCandidates,
+  resolveDefaultProvider,
+  resolveJudgeType,
+  resolveProviderModel,
+  resolveProviderReasoningEffort
+} from "./chunk-C3DH3NCY.js";
+import {
+  PROVIDER_REGISTRY_CONFIG_PATHS,
+  classifyRepoPath,
+  shouldIgnoreRepoPath
+} from "./chunk-RBBTBCHX.js";
+import {
+  hasKnownVerifyExecutable,
+  partitionVerifyCommands
+} from "./chunk-AHU3FKPA.js";
+import {
+  getProjectReferencePathExtensions
+} from "./chunk-RPIMAMV7.js";
+import {
+  resolveExecutionBoundary
+} from "./chunk-2VUEDIUM.js";
+import {
+  matchesFamilyAlias
+} from "./chunk-FAZBRHGG.js";
+import {
+  execGit
+} from "./chunk-MHLEZQQI.js";
+import {
+  ProviderRegistry
+} from "./chunk-QJ6OEH4K.js";
+import {
+  normalizeReasoningEffortInput
+} from "./chunk-4BTDUT2S.js";
+import {
+  listMarkdownFilesRecursive,
+  readMarkdownFile
+} from "./chunk-352PCJLK.js";
+import {
+  BUILD_TASK_TYPE_MIN_CONFIDENCE,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/providers/routing/registry-capability-reader.ts
+var NOMINAL_INPUT_TOKENS = 5e3;
+var NOMINAL_OUTPUT_TOKENS = 2e3;
+function perMillion(per1m, per1k) {
+  if (typeof per1m === "number") return per1m;
+  if (typeof per1k === "number") return per1k * 1e3;
+  return void 0;
+}
+function toModelPricing(pricing) {
+  return {
+    inputPer1m: perMillion(pricing.input_per_1m_tokens, pricing.input_per_1k_tokens),
+    outputPer1m: perMillion(pricing.output_per_1m_tokens, pricing.output_per_1k_tokens)
+  };
+}
+function resolveConfiguredModel(providerId, model, registry) {
+  return ProviderRegistry.resolveModel(providerId, model, registry);
+}
+function toRegistryRoutingSnapshot(config, registry) {
+  const pricingByModel = {};
+  for (const [modelId, pricing] of Object.entries(config.pricing?.models ?? {})) {
+    pricingByModel[modelId] = toModelPricing(pricing);
+  }
+  const roles = config.models.roles ?? {};
+  const resolvedRoles = {};
+  for (const [role, roleModel] of Object.entries(roles)) {
+    resolvedRoles[role] = resolveConfiguredModel(config.id, roleModel, registry);
+  }
+  return {
+    id: config.id,
+    enabled: config.enabled,
+    order: config.order,
+    defaultModel: resolveConfiguredModel(config.id, config.models.default, registry),
+    modelRoles: resolvedRoles,
+    mappings: { ...config.models.mappings ?? {} },
+    allowedPatterns: [...config.models.allowed_patterns ?? []],
+    // Overlay and consumer registries predate this field, so read it defensively
+    // rather than trusting the schema default to have been applied.
+    familyAliases: Array.isArray(config.models.family_aliases) ? [...config.models.family_aliases] : [],
+    models: config.models.available.map((model) => ({
+      id: model.id,
+      capabilities: [...model.capabilities]
+    })),
+    operational: {
+      streaming: config.capabilities.streaming,
+      toolUse: config.capabilities.tool_use,
+      vision: config.capabilities.vision,
+      functionCalling: config.capabilities.function_calling
+    },
+    currency: config.pricing?.currency ?? "USD",
+    pricingByModel
+  };
+}
+function readEnabledRegistryRoutingSnapshots(registry) {
+  return ProviderRegistry.getEnabledProviders(registry).map(
+    (config) => toRegistryRoutingSnapshot(config, registry)
+  );
+}
+function readRegistryRoutingSnapshot(providerId, registry) {
+  try {
+    return toRegistryRoutingSnapshot(
+      ProviderRegistry.getProviderConfig(providerId, registry),
+      registry
+    );
+  } catch {
+    return void 0;
+  }
+}
+function estimateAdvisoryUsd(snapshot, modelId) {
+  const pricing = snapshot.pricingByModel[modelId] ?? snapshot.pricingByModel[modelId.toLowerCase()] ?? Object.entries(snapshot.pricingByModel).find(
+    ([key]) => key.toLowerCase() === modelId.toLowerCase()
+  )?.[1];
+  if (!pricing) return null;
+  if (pricing.inputPer1m == null && pricing.outputPer1m == null) return null;
+  return ((pricing.inputPer1m ?? 0) * NOMINAL_INPUT_TOKENS + (pricing.outputPer1m ?? 0) * NOMINAL_OUTPUT_TOKENS) / 1e6;
+}
+
+// src/core/routing/canonical-candidates.ts
+var REASONING_CATEGORIES = /* @__PURE__ */ new Set(["analyze", "review"]);
+var REASONING_ACTIVITIES = /* @__PURE__ */ new Set(["planning", "research", "architecture", "design"]);
+function preferredModelRole(_classification) {
+  return void 0;
+}
+function canonicalInventoryModelId(snapshot, model) {
+  const needle = model.trim();
+  if (!needle) return void 0;
+  const exact = snapshot.models.find((entry) => entry.id === needle);
+  if (exact) return exact.id;
+  const insensitive = snapshot.models.find(
+    (entry) => entry.id.toLowerCase() === needle.toLowerCase()
+  );
+  return insensitive?.id;
+}
+function mappingTarget(snapshot, model) {
+  if (model in snapshot.mappings) {
+    return snapshot.mappings[model];
+  }
+  const match = Object.entries(snapshot.mappings).find(
+    ([key]) => key.toLowerCase() === model.toLowerCase()
+  );
+  return match?.[1];
+}
+function resolveModelAgainstSnapshot(snapshot, model) {
+  const trimmed = model.trim();
+  if (!trimmed) return void 0;
+  const mapped = mappingTarget(snapshot, trimmed);
+  if (mapped) {
+    return canonicalInventoryModelId(snapshot, mapped) ?? mapped;
+  }
+  if (matchesFamilyAlias(snapshot.familyAliases, trimmed)) {
+    return trimmed;
+  }
+  for (const pattern of snapshot.allowedPatterns) {
+    let regex;
+    try {
+      regex = new RegExp(pattern);
+    } catch {
+      continue;
+    }
+    if (regex.test(trimmed)) {
+      return canonicalInventoryModelId(snapshot, trimmed) ?? trimmed;
+    }
+  }
+  return canonicalInventoryModelId(snapshot, trimmed);
+}
+function selectModelForSnapshot(snapshot, role) {
+  if (role) {
+    const roleModel = snapshot.modelRoles[role];
+    if (roleModel) {
+      const resolved2 = resolveModelAgainstSnapshot(snapshot, roleModel);
+      if (!resolved2) return void 0;
+      return {
+        model: resolved2,
+        source: "classification-role"
+      };
+    }
+  }
+  const resolved = resolveModelAgainstSnapshot(snapshot, snapshot.defaultModel);
+  if (!resolved) return void 0;
+  return {
+    model: resolved,
+    source: "registry"
+  };
+}
+function advisoryCostFor(snapshot, model) {
+  const estimatedUsd = estimateAdvisoryUsd(snapshot, model);
+  return {
+    estimatedUsd,
+    currency: snapshot.currency,
+    usedInRanking: false,
+    source: estimatedUsd == null ? "unknown" : "registry-pricing"
+  };
+}
+function modelCapabilitiesFor(snapshot, model) {
+  const exact = snapshot.models.find((entry) => entry.id === model);
+  if (exact) return [...exact.capabilities];
+  const insensitive = snapshot.models.find(
+    (entry) => entry.id.toLowerCase() === model.toLowerCase()
+  );
+  return insensitive ? [...insensitive.capabilities] : [];
+}
+function buildCanonicalRoutingCandidates(options = {}) {
+  const snapshots = options.snapshots ?? readEnabledRegistryRoutingSnapshots(options.registry);
+  const role = preferredModelRole(options.classification);
+  return snapshots.flatMap((snapshot) => {
+    const selected = selectModelForSnapshot(snapshot, role);
+    if (!selected) return [];
+    return [
+      {
+        provider: snapshot.id,
+        model: selected.model,
+        registryOrder: snapshot.order,
+        defaultModel: selected.model === snapshot.defaultModel,
+        modelCapabilities: modelCapabilitiesFor(snapshot, selected.model),
+        operational: { ...snapshot.operational },
+        advisoryCost: advisoryCostFor(snapshot, selected.model)
+      }
+    ];
+  });
+}
+function classificationFitScore(candidate, classification) {
+  if (!classification) return 0;
+  const caps = new Set(candidate.modelCapabilities.map((capability) => capability.toLowerCase()));
+  let score = 0;
+  const wantsReasoning = REASONING_CATEGORIES.has(classification.category) || REASONING_ACTIVITIES.has(classification.activity);
+  if (wantsReasoning && (caps.has("reasoning") || caps.has("thinking"))) {
+    score += 2;
+  }
+  if ((classification.category === "execute" || classification.category === "test") && caps.has("code")) {
+    score += 2;
+  }
+  if (classification.category === "document" && (caps.has("fast") || caps.has("docs") || caps.has("documentation"))) {
+    score += 1;
+  }
+  return score;
+}
+
+// src/core/routing/canonical-decision.ts
+var CanonicalRoutingError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CanonicalRoutingError";
+  }
+};
+function isFullClassification(value) {
+  return "judgeTaskType" in value && "provenance" in value;
+}
+function resolveClassification(input) {
+  if (input.classification) {
+    return {
+      classification: isFullClassification(input.classification) ? toCanonicalRoutingClassificationInput(input.classification) : input.classification,
+      source: "input"
+    };
+  }
+  if (input.prompt != null && input.prompt.trim() !== "") {
+    return {
+      classification: toCanonicalRoutingClassificationInput(classifyTaskForRouting(input.prompt)),
+      source: "prompt"
+    };
+  }
+  return { classification: void 0, source: "none" };
+}
+function normalizePin(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function withUsedInRanking(cost, usedInRanking) {
+  return { ...cost, usedInRanking };
+}
+function applyModelOverride(candidate, snapshot, model) {
+  const estimatedUsd = snapshot ? estimateAdvisoryUsd(snapshot, model) : null;
+  return {
+    ...candidate,
+    model,
+    defaultModel: snapshot ? model === snapshot.defaultModel : false,
+    modelCapabilities: snapshot ? modelCapabilitiesFor(snapshot, model) : [],
+    advisoryCost: {
+      estimatedUsd,
+      currency: snapshot?.currency ?? candidate.advisoryCost.currency,
+      usedInRanking: false,
+      source: estimatedUsd == null ? "unknown" : "registry-pricing"
+    }
+  };
+}
+function compareCandidates(left, right, classification) {
+  const leftFit = classificationFitScore(left, classification);
+  const rightFit = classificationFitScore(right, classification);
+  if (leftFit !== rightFit) return rightFit - leftFit;
+  return left.registryOrder - right.registryOrder;
+}
+function clampConfidence(value) {
+  if (value < 0.3) return 0.3;
+  if (value > 0.95) return 0.95;
+  return value;
+}
+function unpinnedConfidence(classification) {
+  if (!classification) return 0.6;
+  return clampConfidence((classification.analyticsConfidence + classification.judgeConfidence) / 2);
+}
+function alternativeConfidence(primary, index) {
+  const scaled = primary * (0.8 - index * 0.08);
+  return Math.max(0.1, Math.min(primary, scaled));
+}
+function selectionRationale(args) {
+  const rationale = [];
+  if (args.providerSource === "explicit") {
+    rationale.push("explicit provider pin");
+  } else {
+    rationale.push("registry candidate order");
+  }
+  if (args.modelSource === "explicit") {
+    rationale.push("explicit model pin");
+  } else if (args.modelSource === "classification-role") {
+    rationale.push("classification-selected model role");
+  } else {
+    rationale.push("registry default model");
+  }
+  if (args.classification) {
+    rationale.push(
+      `canonical classification ${args.classification.category}/${args.classification.activity}`
+    );
+  }
+  rationale.push("advisory cost not used for ranking");
+  return rationale;
+}
+function toAlternative(candidate, confidence) {
+  return {
+    provider: candidate.provider,
+    model: candidate.model,
+    confidence,
+    rationale: [`unselected alternative ${candidate.provider}:${candidate.model}`],
+    advisoryCost: candidate.advisoryCost
+  };
+}
+function collectSnapshots(input) {
+  if (input.snapshots) return [...input.snapshots];
+  return readEnabledRegistryRoutingSnapshots(input.registry);
+}
+function registryKnowsProvider(providerId, registry) {
+  try {
+    ProviderRegistry.getProviderConfig(providerId, registry);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveCanonicalRoutingModel(providerId, model, snapshot, registry) {
+  const trimmed = model.trim();
+  if (!trimmed) return void 0;
+  if (registryKnowsProvider(providerId, registry)) {
+    const attempts = [trimmed];
+    const mappingKey = Object.keys(snapshot.mappings).find(
+      (key) => key.toLowerCase() === trimmed.toLowerCase()
+    );
+    if (mappingKey && !attempts.includes(mappingKey)) {
+      attempts.push(mappingKey);
+    }
+    const inventoryId = canonicalInventoryModelId(snapshot, trimmed);
+    if (inventoryId && !attempts.includes(inventoryId)) {
+      attempts.push(inventoryId);
+    }
+    for (const attempt of attempts) {
+      try {
+        const resolved = ProviderRegistry.resolveModel(providerId, attempt, registry);
+        return canonicalInventoryModelId(snapshot, resolved) ?? resolved;
+      } catch {
+      }
+    }
+    return void 0;
+  }
+  return resolveModelAgainstSnapshot(snapshot, trimmed);
+}
+function requireCandidate(candidate, message) {
+  if (!candidate) {
+    throw new CanonicalRoutingError(message);
+  }
+  return candidate;
+}
+function idsEqual(left, right) {
+  return left.trim().toLowerCase() === right.trim().toLowerCase();
+}
+function resolvePinnedProviderSnapshot(providerPin, snapshots, registry) {
+  const fromSnapshots = snapshots.find((snapshot) => idsEqual(snapshot.id, providerPin));
+  if (fromSnapshots) {
+    if (!fromSnapshots.enabled) {
+      throw new CanonicalRoutingError(
+        `Explicit provider pin '${providerPin}' targets a disabled provider`
+      );
+    }
+    return fromSnapshots;
+  }
+  const fromRegistry = readRegistryRoutingSnapshot(providerPin, registry);
+  if (fromRegistry) {
+    if (!fromRegistry.enabled) {
+      throw new CanonicalRoutingError(
+        `Explicit provider pin '${providerPin}' targets a disabled provider`
+      );
+    }
+    return snapshots.find((snapshot) => snapshot.id === fromRegistry.id) ?? fromRegistry;
+  }
+  throw new CanonicalRoutingError(
+    `Explicit provider pin '${providerPin}' is not a configured registry provider`
+  );
+}
+function decideCanonicalRouting(input = {}) {
+  const costMode = input.costMode ?? "advisory";
+  const { classification, source: classificationSource } = resolveClassification(input);
+  const providerPin = normalizePin(input.pins?.provider);
+  const modelPin = normalizePin(input.pins?.model);
+  const snapshots = collectSnapshots(input);
+  const snapshotsById = new Map(snapshots.map((snapshot) => [snapshot.id, snapshot]));
+  let resolvedProviderPinId;
+  if (providerPin) {
+    const resolved = resolvePinnedProviderSnapshot(providerPin, snapshots, input.registry);
+    resolvedProviderPinId = resolved.id;
+    if (!snapshotsById.has(resolved.id)) {
+      snapshots.push(resolved);
+      snapshotsById.set(resolved.id, resolved);
+    }
+  }
+  const candidates = buildCanonicalRoutingCandidates({
+    snapshots: snapshots.filter((entry) => entry.enabled),
+    classification,
+    registry: input.registry
+  });
+  if (candidates.length === 0) {
+    throw new CanonicalRoutingError(
+      "No enabled registry providers are available to build a routing decision"
+    );
+  }
+  const ranked = [...candidates].sort(
+    (left, right) => compareCandidates(left, right, classification)
+  );
+  let selected;
+  let providerSource = "registry";
+  let modelSource = "registry";
+  if (resolvedProviderPinId) {
+    selected = requireCandidate(
+      ranked.find((candidate) => candidate.provider === resolvedProviderPinId),
+      `Explicit provider pin '${providerPin}' could not be applied`
+    );
+    providerSource = "explicit";
+  } else if (modelPin) {
+    const matching = ranked.filter((candidate) => {
+      const snapshot = snapshotsById.get(candidate.provider);
+      if (!snapshot) return false;
+      return resolveCanonicalRoutingModel(candidate.provider, modelPin, snapshot, input.registry) != null;
+    });
+    const owner = ProviderRegistry.resolveProviderByModel(modelPin, input.registry);
+    selected = requireCandidate(
+      matching.find((candidate) => candidate.provider === owner) ?? matching[0],
+      `Explicit model pin '${modelPin}' is not in the registry inventory`
+    );
+  } else {
+    selected = requireCandidate(ranked[0], "No routing candidate available");
+  }
+  const selectedSnapshot = snapshotsById.get(selected.provider);
+  if (!selectedSnapshot) {
+    throw new CanonicalRoutingError(
+      `Routing candidate '${selected.provider}' is missing registry capabilities`
+    );
+  }
+  if (modelPin) {
+    const resolvedModel = resolveCanonicalRoutingModel(
+      selected.provider,
+      modelPin,
+      selectedSnapshot,
+      input.registry
+    );
+    if (!resolvedModel) {
+      throw new CanonicalRoutingError(
+        `Explicit model pin '${modelPin}' is not in the registry inventory for '${selected.provider}'`
+      );
+    }
+    selected = applyModelOverride(selected, selectedSnapshot, resolvedModel);
+    modelSource = "explicit";
+  } else {
+    const selectedModel = selectModelForSnapshot(
+      selectedSnapshot,
+      preferredModelRole(classification)
+    );
+    if (!selectedModel) {
+      throw new CanonicalRoutingError(
+        `Configured model for '${selected.provider}' is not in the registry inventory`
+      );
+    }
+    modelSource = selectedModel.source;
+    const resolvedModel = resolveCanonicalRoutingModel(
+      selected.provider,
+      selectedModel.model,
+      selectedSnapshot,
+      input.registry
+    );
+    if (!resolvedModel) {
+      throw new CanonicalRoutingError(
+        `Configured model for '${selected.provider}' is not in the registry inventory`
+      );
+    }
+    if (resolvedModel !== selected.model) {
+      selected = applyModelOverride(selected, selectedSnapshot, resolvedModel);
+    }
+  }
+  selected = {
+    ...selected,
+    advisoryCost: withUsedInRanking(selected.advisoryCost, false)
+  };
+  const confidence = providerSource === "explicit" || modelSource === "explicit" ? 1 : unpinnedConfidence(classification);
+  const alternatives = ranked.filter(
+    (candidate) => candidate.provider !== selected.provider || candidate.model !== selected.model
+  ).map(
+    (candidate, index) => toAlternative(
+      {
+        ...candidate,
+        advisoryCost: withUsedInRanking(candidate.advisoryCost, false)
+      },
+      alternativeConfidence(confidence, index)
+    )
+  );
+  const provenance = {
+    ...providerPin ? { providerPin: { value: providerPin, source: "explicit" } } : {},
+    ...modelPin ? { modelPin: { value: modelPin, source: "explicit" } } : {},
+    providerSource,
+    modelSource,
+    ...classification ? { classification } : {},
+    classificationSource,
+    ...input.executionStrategy ? { executionStrategyInput: input.executionStrategy } : {},
+    costMode
+  };
+  return {
+    provider: selected.provider,
+    model: selected.model,
+    confidence,
+    alternatives,
+    rationale: selectionRationale({
+      providerSource,
+      modelSource,
+      classification
+    }),
+    provenance,
+    advisoryCost: selected.advisoryCost
+  };
+}
+
+// src/automation/flywheel-routing.ts
+function normalizePin2(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function requireEnabledProvider(stageId, provider, registry) {
+  const providerConfig = ProviderRegistry.getProviderConfig(provider, registry);
+  if (providerConfig.enabled !== true) {
+    throw new Error(`Stage '${stageId}' references disabled provider '${provider}'`);
+  }
+  return providerConfig.id;
+}
+function planFlywheelStageRouting(input) {
+  const prompt = input.stage.prompt ?? "";
+  const classification = input.classification ?? classifyTaskForRouting(prompt);
+  const stageProviderPin = normalizePin2(input.stage.provider);
+  const forceProviderPin = normalizePin2(input.hints?.forceProvider);
+  const explicitProvider = stageProviderPin ?? forceProviderPin;
+  const explicitModel = normalizePin2(input.stage.model);
+  const applyAutomaticRanking = input.hints?.providerRouting === "auto" && !explicitProvider;
+  if (explicitProvider) {
+    const snapshot = input.snapshots?.find(
+      (entry) => entry.id.trim().toLowerCase() === explicitProvider.toLowerCase()
+    );
+    if (snapshot) {
+      if (!snapshot.enabled) {
+        throw new Error(
+          `Stage '${input.stage.id}' references disabled provider '${explicitProvider}'`
+        );
+      }
+    } else if (input.snapshots) {
+      throw new CanonicalRoutingError(
+        `Explicit provider pin '${explicitProvider}' is not a configured registry provider`
+      );
+    } else {
+      requireEnabledProvider(input.stage.id, explicitProvider, input.registry);
+    }
+  }
+  const pins = (() => {
+    if (!explicitProvider && !explicitModel) return void 0;
+    return {
+      ...explicitProvider ? { provider: explicitProvider } : {},
+      ...explicitModel ? { model: explicitModel } : {}
+    };
+  })();
+  const decision = decideCanonicalRouting({
+    classification: applyAutomaticRanking || pins ? classification : void 0,
+    pins,
+    costMode: "advisory",
+    snapshots: input.snapshots,
+    registry: input.registry
+  });
+  const appliedProvider = decision.provider;
+  const hintsApplied = ["canonical-routing"];
+  if (stageProviderPin) {
+    hintsApplied.push("stage.provider");
+  } else if (forceProviderPin) {
+    hintsApplied.push("routingHints.forceProvider");
+  } else if (applyAutomaticRanking) {
+    hintsApplied.push("provider-routing-auto");
+  } else {
+    hintsApplied.push("configured-default");
+  }
+  if (input.hints?.modelPreference === "cost") {
+    hintsApplied.push("advisory-cost-ignored");
+  }
+  return {
+    provider: appliedProvider,
+    model: explicitModel ? decision.model : void 0,
+    confidence: decision.confidence,
+    reasoning: decision.rationale.join("; "),
+    alternatives: decision.alternatives.map((alternative) => alternative.provider),
+    hintsApplied,
+    canonicalDecision: decision,
+    classification
+  };
+}
+
+// src/planning/workflow-executor-providers.ts
+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];
+}
+function collectTaskExecutorProviders(workflow) {
+  const providers = new Set(collectCompetitionExecutorProviders(workflow));
+  let routedDefault;
+  const visit = (stage) => {
+    const type = stage.type ?? "standard";
+    const explicit = stage.provider?.trim();
+    if (explicit && (type === "standard" || type === "competition")) {
+      providers.add(explicit);
+    } else if (type === "standard") {
+      routedDefault ??= planFlywheelStageRouting({ stage: { id: stage.id, prompt: "" } }).provider;
+      providers.add(routedDefault);
+    }
+    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].sort();
+}
+function resolveTaskExecutionRoles(workflow, options) {
+  const executors = collectTaskExecutorProviders(workflow);
+  return resolveExecutionRoles({
+    cwd: options.cwd,
+    cli: { executorProvider: executors[0], reviewPolicy: options.reviewPolicy },
+    additionalReviewerExcludes: executors.slice(1),
+    ...resolveReviewerEligibility(options.cwd)
+  });
+}
+function describeDormantPolicyMismatch(workflow, options) {
+  const record = workflow.metadata?.executionPolicyDormant;
+  if (!record || typeof record.executor !== "string" || typeof record.reviewer !== "string" || typeof record.gate !== "string" || !Array.isArray(record.executors)) {
+    return "the dormant-policy record is missing or malformed";
+  }
+  const recorded = [...record.executors].sort().join(",");
+  const current = collectTaskExecutorProviders(workflow).join(",");
+  if (recorded !== current) {
+    return `executors changed since generation (recorded '${recorded}', now '${current}')`;
+  }
+  if (current !== record.executor) {
+    return `tasks run on '${current}', not the recorded executor '${record.executor}'`;
+  }
+  const roles = resolveExecutionRoles({
+    cwd: options.cwd,
+    cli: {
+      executorProvider: record.executor,
+      ...options.reviewPolicy ? { reviewPolicy: options.reviewPolicy } : {}
+    },
+    additionalReviewerExcludes: collectCompetitionExecutorProviders(workflow),
+    ...resolveReviewerEligibility(options.cwd)
+  });
+  if (isExecutionPolicyEngaged(roles)) {
+    return "review would now be engaged for the recorded executor";
+  }
+  if (roles.reviewer.provider.value !== record.reviewer) {
+    return `reviewer changed since generation (recorded '${record.reviewer}', now '${roles.reviewer.provider.value}')`;
+  }
+  const gate = roles.reviewer.gate?.value ?? "off";
+  if (gate !== record.gate) {
+    return `review gate changed since generation (recorded '${record.gate}', now '${gate}')`;
+  }
+  return void 0;
+}
+
+// src/automation/unreviewed-executor-effort.ts
+function isNonCompetitionExecution(stage) {
+  return (stage.type ?? "standard") === "standard";
+}
+function bindExecutorEffortWithoutPolicy(workflow, roles, cwd) {
+  const executorProvider = roles.executor.provider.value;
+  const effortFor = (provider) => {
+    const target = provider?.trim() || executorProvider;
+    const resolved = target.toLowerCase() === executorProvider.trim().toLowerCase() ? roles.executor.reasoningEffort : resolveProviderReasoningEffort(target, void 0, cwd);
+    return normalizeReasoningEffortInput(resolved?.value);
+  };
+  const withEffort = (stage, inheritedProvider) => {
+    if (!isNonCompetitionExecution(stage) || stage.modelReasoningEffort != null) return stage;
+    const effort = effortFor(stage.provider ?? inheritedProvider);
+    return effort ? { ...stage, modelReasoningEffort: effort } : stage;
+  };
+  const stages = workflow.stages.map((stage) => {
+    if (stage.type !== "orchestrator") return withEffort(stage);
+    if (!stage.seededPlan) return stage;
+    return {
+      ...stage,
+      seededPlan: {
+        ...stage.seededPlan,
+        subStages: stage.seededPlan.subStages.map((sub) => withEffort(sub, stage.provider))
+      }
+    };
+  });
+  return { ...workflow, stages };
+}
+
+// src/planning/provider-plan-notice.ts
+function defaultModelFor(provider, cwd) {
+  try {
+    return resolveProviderModel(provider, void 0, cwd).value;
+  } catch {
+    return "default";
+  }
+}
+function indexStages(workflow) {
+  const byId = /* @__PURE__ */ new Map();
+  const visit = (stage) => {
+    byId.set(stage.id, stage);
+    if (stage.type === "orchestrator" && stage.seededPlan) {
+      for (const subStage of stage.seededPlan.subStages) visit(subStage);
+    }
+  };
+  for (const stage of workflow.stages) visit(stage);
+  return byId;
+}
+function collectCandidates(workflow, bound, roles, cliProviderOverride, cwd) {
+  const labels = /* @__PURE__ */ new Set();
+  const boundById = indexStages(bound);
+  const add = (provider, model) => {
+    labels.add(`${provider}:${model?.trim() || defaultModelFor(provider, cwd)}`);
+  };
+  const visit = (original) => {
+    if (original.type === "orchestrator" && original.seededPlan) {
+      for (const subStage of original.seededPlan.subStages) visit(subStage);
+      return;
+    }
+    const stage = boundById.get(original.id) ?? original;
+    if (stage.type === "competition") {
+      for (const variant of stage.competition?.variants ?? []) add(variant.provider, variant.model);
+      return;
+    }
+    if ((stage.type ?? "standard") !== "standard") return;
+    const provider = stage.provider ?? cliProviderOverride ?? roles.executor.provider.value;
+    const executorModel = provider === roles.executor.provider.value && !cliProviderOverride ? roles.executor.model.value : void 0;
+    add(provider, stage.model ?? executorModel);
+  };
+  for (const stage of workflow.stages) visit(stage);
+  return [...labels];
+}
+function describeProviderPlan(workflow, bound, roles, options) {
+  try {
+    const candidates = collectCandidates(
+      workflow,
+      bound,
+      roles,
+      options.cliProviderOverride,
+      options.cwd
+    );
+    if (candidates.length === 0) return void 0;
+    const review = options.reviewOff ? "review off" : options.reviewEngaged ? `review ${roles.reviewer.provider.value}:${roles.reviewer.model.value}` : "review not run";
+    return `Provider plan: candidates ${candidates.join(", ")}; ${review}.`;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/planning/generated-workflow-policy.ts
+function describeDormantReview(roles, eligibility) {
+  if (roles.reviewer.bindingSource === "explicit") {
+    return `Task review unavailable: roles.reviewer.provider '${roles.reviewer.provider.value}' does the work.`;
+  }
+  const installed = eligibility.installedReviewerProviders ?? eligibility.eligibleReviewerProviders;
+  const providers = installed && installed.length > 0 ? installed : [roles.executor.provider.value];
+  if (providers.length === 1) {
+    return `Task review skipped: ${providers[0]} is the only installed provider.`;
+  }
+  const contributors = new Set(roles.reviewerExcludes.map((id) => id.trim().toLowerCase()));
+  const independent = providers.filter((provider) => !contributors.has(provider.toLowerCase()));
+  return independent.length === 0 ? `Task review unavailable: every installed provider (${providers.join(", ")}) does the work.` : `Task review unavailable: the installed providers that do not do the work (${independent.join(", ")}) are outside the provider order.`;
+}
+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,
+    reviewPolicy: options.reviewPolicy,
+    orchestratorProvider: options.orchestratorOverrideIsExplicit ? options.orchestratorProviderOverride : void 0,
+    orchestratorModel: options.orchestratorOverrideIsExplicit ? options.orchestratorModelOverride : void 0
+  };
+  const eligibility = resolveReviewerEligibility(process.cwd());
+  const { eligibleReviewerProviders } = eligibility;
+  const roles = resolveExecutionRoles({
+    cwd: process.cwd(),
+    cli: Object.values(cliOverrides).some(Boolean) ? cliOverrides : void 0,
+    additionalReviewerExcludes: collectCompetitionExecutorProviders(workflow),
+    ...eligibility,
+    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 (hasTaskExecutionStage && roles.reviewer.gate?.value !== "off") {
+    assertReviewerOrderUsable(roles, eligibleReviewerProviders, process.cwd());
+  }
+  const engaged = isExecutionPolicyEngaged(roles);
+  if (engaged && 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.`
+    );
+  }
+  if (!engaged && sameAsExecutor && hasTaskExecutionStage && roles.reviewer.gate?.value !== "off") {
+    options.warnings.push(describeDormantReview(roles, eligibility));
+  }
+  const stamped = applyExecutionPolicy(workflow, roles, {
+    cliProviderOverride: options.cliProviderOverride,
+    onNotice: (message) => options.warnings.push(message)
+  });
+  const unstampedBound = engaged ? stamped : bindExecutorEffortWithoutPolicy(stamped, roles, process.cwd());
+  if (!engaged && hasTaskExecutionStage && roles.reviewer.gate?.value !== "off") {
+    const routedRoles = resolveTaskExecutionRoles(unstampedBound, {
+      cwd: process.cwd(),
+      reviewPolicy: options.reviewPolicy
+    });
+    if (isExecutionPolicyEngaged(routedRoles)) {
+      throw new Error(
+        "The routed task providers require review, although the configured executor left review dormant. Regenerate with an explicit --provider matching the intended executor so review can be bound."
+      );
+    }
+  }
+  let executors;
+  const dormantExecutor = options.cliProviderOverride ?? roles.executor.provider.value;
+  if (!engaged && hasTaskExecutionStage) {
+    try {
+      executors = collectTaskExecutorProviders(unstampedBound);
+    } catch {
+      executors = void 0;
+    }
+    if (executors && !(executors.length === 1 && executors[0] === dormantExecutor)) {
+      executors = void 0;
+    }
+  }
+  const bound = executors ? {
+    ...unstampedBound,
+    metadata: {
+      ...unstampedBound.metadata,
+      executionPolicyDormant: {
+        reason: sameAsExecutor ? "reviewer-same-as-executor" : "policy-not-engaged",
+        executor: dormantExecutor,
+        executors,
+        reviewer: roles.reviewer.provider.value,
+        gate: roles.reviewer.gate?.value ?? "off"
+      }
+    }
+  } : unstampedBound;
+  if (hasTaskExecutionStage && options.onProviderPlan) {
+    const plan = describeProviderPlan(workflow, bound, roles, {
+      cliProviderOverride: options.cliProviderOverride,
+      reviewOff: options.reviewPolicy === "off" || roles.reviewer.gate?.value === "off",
+      reviewEngaged: engaged,
+      cwd: process.cwd()
+    });
+    if (plan) options.onProviderPlan(plan);
+  }
+  return bound;
+}
+
+// src/planning/stage-contract-adapter.ts
+var CODE_ONLY_NO_CHANGE_PHRASE = /\b(?:no|without)\s+code\s+changes?\b/gi;
+function stageIsExplicitNoEdit(text, policyExecutionIntent) {
+  return classifyExplicitNoEdit(
+    policyExecutionIntent === "edit" ? text.replace(CODE_ONLY_NO_CHANGE_PHRASE, " ") : text
+  );
+}
+function resolveStageContract({
+  text,
+  title,
+  metadataExecutionIntent,
+  policyExecutionIntent,
+  policyIntentAuthority
+}) {
+  if (metadataExecutionIntent) {
+    return fromIntent(metadataExecutionIntent, "metadata", metadataExecutionIntent === "analysis");
+  }
+  if (policyIntentAuthority === "explicit" && policyExecutionIntent) {
+    return fromIntent(
+      policyExecutionIntent,
+      "task-type-policy",
+      policyExecutionIntent === "analysis"
+    );
+  }
+  if (policyExecutionIntent === "analysis") {
+    return fromIntent("analysis", "task-type-policy", true);
+  }
+  const stageText = [title, text].filter(Boolean).join("\n\n");
+  if (stageIsExplicitNoEdit(stageText, policyExecutionIntent)) {
+    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 resolveOrderedProviders() {
+  try {
+    const ordered = resolveCandidates("global", { preserveFallbackChain: true }).map(
+      (candidate) => candidate.provider
+    );
+    const distinct = [...new Set(ordered.filter((provider) => provider.length > 0))];
+    if (distinct.length > 0) return distinct;
+  } catch {
+  }
+  return [resolveDefaultProvider().value];
+}
+function getDefaultCompetitionVariantsForProvider(provider) {
+  const requested = typeof provider === "string" && provider.trim().length > 0 && provider !== "multi" ? provider.trim() : void 0;
+  const ordered = resolveOrderedProviders();
+  const preferred = requested ?? ordered[0] ?? resolveDefaultProvider().value;
+  const second = ordered.find((candidate) => candidate !== preferred);
+  return second ? [{ provider: preferred }, { provider: second }] : [{ provider: preferred }];
+}
+
+// src/core/task-types/effective-policy.ts
+var DEFAULT_TASK_TYPE_MIN_CONFIDENCE = 0.3;
+function getTaskTypeMinConfidence() {
+  return readEnv(BUILD_TASK_TYPE_MIN_CONFIDENCE).value ?? DEFAULT_TASK_TYPE_MIN_CONFIDENCE;
+}
+function getEffectiveTaskTypePolicy(options) {
+  const { policy, resolvedBy } = options;
+  const confidence = options.confidence;
+  const threshold = getTaskTypeMinConfidence();
+  const isMatcher = resolvedBy === "matcher";
+  const suppressed = isMatcher && typeof confidence === "number" && confidence < threshold;
+  return {
+    policy: suppressed ? stripRestrictivePolicy(policy) : policy,
+    suppressed,
+    threshold
+  };
+}
+function stripRestrictivePolicy(policy) {
+  return {
+    ...policy,
+    decomposition: policy.decomposition ? {
+      ...policy.decomposition,
+      maxParallelGroups: void 0,
+      requiredStageTypes: void 0
+    } : void 0,
+    allowlist: void 0,
+    // A read-only analysis intent is restrictive; the edit default is not.
+    executionIntent: policy.executionIntent === "analysis" ? void 0 : policy.executionIntent,
+    routing: policy.routing ? {
+      ...policy.routing,
+      preferCompetition: void 0
+    } : void 0
+  };
+}
+
+// src/core/task-types/resolver.ts
+var DEFAULT_TASK_TYPE_ID = "general";
+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 = DEFAULT_TASK_TYPE_ID } = 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) {
+    const mappedId = options.resolveDeclared?.(declaredType);
+    if (typeof mappedId === "string" && mappedId.length > 0 && hasId(mappedId)) {
+      return {
+        id: mappedId,
+        resolvedBy: "declared",
+        reasons: [`declared:${declaredType}`]
+      };
+    }
+    return {
+      id: options.fallbackId ?? DEFAULT_TASK_TYPE_ID,
+      resolvedBy: "fallback",
+      reasons: [`declared:${declaredType} unmapped; inference skipped`]
+    };
+  }
+  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/create-intent-targets.ts
+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 isRepoRelativeTargetPath(value) {
+  const normalized = value.replace(/\\/g, "/").trim();
+  if (normalized.length === 0) return false;
+  if (normalized.startsWith("/") || /^[A-Za-z]:/.test(normalized)) return false;
+  return normalized !== ".." && !normalized.startsWith("../") && !normalized.includes("/../");
+}
+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;
+    const candidate = raw.replace(/^\.\//, "");
+    if (!isRepoRelativeTargetPath(candidate)) continue;
+    candidates.add(candidate);
+  }
+  return Array.from(candidates);
+}
+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 path2 of extractCreateAnnotatedFilePaths(text)) {
+    const target = normalizeTargetPath(path2);
+    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 collectProseUnits(text) {
+  const units = [];
+  let block = "";
+  let inFence = false;
+  let verifyDepth;
+  const flush = () => {
+    const pending = block.trim();
+    block = "";
+    if (pending.length === 0) return;
+    for (const sentence of pending.split(/(?<=[.!?])\s+/)) {
+      const unit = sentence.trim();
+      if (unit.length > 0) units.push(unit);
+    }
+  };
+  for (const rawLine of text.split(/\r?\n/)) {
+    const trimmed = rawLine.trim();
+    if (/^```/.test(trimmed)) {
+      flush();
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) continue;
+    const heading = /^(#{1,6})\s+/.exec(trimmed);
+    if (heading) {
+      flush();
+      const depth = (heading[1] ?? "").length;
+      if (verifyDepth === void 0 || depth <= verifyDepth) {
+        verifyDepth = /^#{1,6}\s+how\s+to\s+verify\b/i.test(trimmed) ? depth : void 0;
+      }
+      continue;
+    }
+    if (verifyDepth !== void 0) continue;
+    if (trimmed.length === 0) {
+      flush();
+      continue;
+    }
+    const listMarker = /^(?:[-*+]|\d+[.)])\s+/.exec(trimmed);
+    if (listMarker) {
+      flush();
+      block = trimmed.slice(listMarker[0].length);
+      continue;
+    }
+    block = block.length > 0 ? `${block} ${trimmed}` : trimmed;
+  }
+  flush();
+  return units;
+}
+function inferCreateIntentTargets(options) {
+  const text = `${options.title ?? ""}
+
+${options.body ?? ""}`;
+  const annotatedTargets = extractCreateAnnotatedFileTargets(text);
+  if (annotatedTargets.length > 0) return annotatedTargets;
+  const targets = /* @__PURE__ */ new Set();
+  for (const unit of collectProseUnits(text)) {
+    if (!hasCreateFileIntent(unit)) continue;
+    for (const reference of extractLikelyPathReferences(unit)) {
+      const target = normalizeTargetPath(reference);
+      if (target.length > 0 && !target.endsWith("/")) targets.add(target);
+    }
+  }
+  return Array.from(targets);
+}
+
+// src/planning/dry-run-target-warnings.ts
+var IGNORED_TARGET_PREFIXES = [
+  ".build-project/planning/",
+  ".build-project/tmp/",
+  ".build-project/cache/",
+  ".build-project/state/",
+  ".build-project/telemetry/",
+  ".build-project/runs/",
+  ".build-project/artifacts/",
+  ".build-project/workflows/",
+  "node_modules/",
+  "dist/",
+  "build/",
+  "coverage/"
+];
+function normalizeTarget(targetPath) {
+  return targetPath.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function isIgnoredTargetPath(targetPath) {
+  const normalized = normalizeTarget(targetPath);
+  return IGNORED_TARGET_PREFIXES.some(
+    (prefix) => normalized === prefix.slice(0, -1) || normalized.startsWith(prefix)
+  );
+}
+async function collectGitignoredTargets(options) {
+  const { repoRoot, targets } = options;
+  const queried = /* @__PURE__ */ new Map();
+  for (const target of targets) {
+    const normalized = normalizeTarget(target);
+    if (!isRepoRelativeTargetPath(normalized)) continue;
+    const existing = queried.get(normalized);
+    if (existing) {
+      existing.push(target);
+    } else {
+      queried.set(normalized, [target]);
+    }
+  }
+  if (queried.size === 0) {
+    return { targets: [], source: "git" };
+  }
+  let ignoredPaths;
+  try {
+    const result = await execGit(["check-ignore", "-z", "--stdin"], {
+      cwd: repoRoot,
+      input: `${[...queried.keys()].join("\0")}\0`
+    });
+    if (result.exitCode === 0 || result.exitCode === 1) {
+      ignoredPaths = new Set(result.stdout.split("\0").filter((entry) => entry.length > 0));
+    }
+  } catch {
+  }
+  if (!ignoredPaths) {
+    return { targets: targets.filter(isIgnoredTargetPath), source: "static-fallback" };
+  }
+  const ignoredTargets = [];
+  for (const [normalized, originals] of queried) {
+    if (ignoredPaths.has(normalized)) ignoredTargets.push(...originals);
+  }
+  return { targets: ignoredTargets, source: "git" };
+}
+function describeUndeliverableReason(normalized) {
+  if (PROVIDER_REGISTRY_CONFIG_PATHS.includes(normalized)) {
+    return "provider-registry config that provider-authored edits may never write";
+  }
+  switch (classifyRepoPath(normalized)) {
+    case "runtime-artifact":
+      return "runtime artifact path the pipeline does not apply";
+    case "generated-artifact":
+      return "generated output the pipeline does not apply";
+    case "planning-artifact":
+      return "excluded planning path the pipeline does not apply";
+    default:
+      return "excluded from applied changes by the delivery classifier";
+  }
+}
+function collectUndeliverableTargets(targets) {
+  const seen = /* @__PURE__ */ new Set();
+  const entries = [];
+  for (const target of targets) {
+    const normalized = normalizeTarget(target);
+    if (normalized.length === 0 || seen.has(normalized)) continue;
+    seen.add(normalized);
+    if (!shouldIgnoreRepoPath(normalized)) continue;
+    entries.push({ path: target, reason: describeUndeliverableReason(normalized) });
+  }
+  return entries;
+}
+function formatUndeliverableTargetsWarning(taskId, entries) {
+  if (entries.length === 0) return void 0;
+  const detail = entries.map((entry) => `${entry.path} (${entry.reason})`).join(", ");
+  return `Task ${taskId}: target path(s) cannot be delivered by the pipeline: ${detail}`;
+}
+
+// src/planning/stage-dependency-order.ts
+function orderStagesByDeclaredDeps(stages) {
+  const ids = new Set(stages.map((stage) => stage.id));
+  const placed = /* @__PURE__ */ new Set();
+  const remaining = [...stages];
+  const ordered = [];
+  while (remaining.length > 0) {
+    const nextIndex = remaining.findIndex(
+      (stage) => (stage.deps ?? []).every((dep) => dep === stage.id || !ids.has(dep) || placed.has(dep))
+    );
+    if (nextIndex === -1) {
+      ordered.push(...remaining);
+      break;
+    }
+    const next = remaining[nextIndex];
+    remaining.splice(nextIndex, 1);
+    placed.add(next.id);
+    ordered.push(next);
+  }
+  return ordered;
+}
+
+// src/planning/sprint-to-workflow.ts
+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 `build assert exact-line ${quoteVerifyArg(pathValue)} --content-base64 ${encodedContent}`;
+}
+function stripWrappingQuotes(value) {
+  const quote = value[0];
+  if (value.length >= 2 && (quote === '"' || quote === "'") && value.endsWith(quote) && !value.slice(1, -1).includes(quote)) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function normalizeBodyVerifyLine(line, inFence) {
+  let value = line.trim().replace(/^\s*(?:[-*+]|\d+[.)])\s+/, "").trim();
+  if (!value) return void 0;
+  const codeSpan = value.match(/`([^`]+)`/);
+  if (codeSpan?.[1]) {
+    value = stripWrappingQuotes(codeSpan[1].trim()).trim();
+    return value.length > 0 ? { command: value, reportRejection: true } : void 0;
+  }
+  const hasRunPrefix = /^run\s+/i.test(value);
+  value = stripWrappingQuotes(value.replace(/^run\s+/i, "").trim()).replace(/(?<![./]);$/g, "").replace(/(?<![./])\.$/g, "").trim();
+  const hasCommandSyntax = /^[a-z][a-z0-9._+-]*\s+-/.test(value) || /(?:&&|;|\||[<>]|\$\()/.test(value);
+  if (value.length === 0) return void 0;
+  if (inFence) return { command: value, reportRejection: true };
+  return {
+    command: value,
+    reportRejection: hasRunPrefix || hasCommandSyntax || hasKnownVerifyExecutable(value),
+    prose: true
+  };
+}
+function extractBodyVerifyCommands(text) {
+  const lines = text.split(/\r?\n/);
+  const ignoredProse = [];
+  const candidates = /* @__PURE__ */ new Map();
+  let inVerifySection = false;
+  let sectionFound = false;
+  let inFence = false;
+  let verifyDepth = 0;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/^```/.test(trimmed)) {
+      if (inVerifySection) {
+        inFence = !inFence;
+      }
+      continue;
+    }
+    const heading = !inFence ? /^(#{1,6})\s+/.exec(trimmed) : null;
+    if (heading) {
+      const depth = (heading[1] ?? "").length;
+      if (/^#{1,6}\s+how\s+to\s+verify\b/i.test(trimmed)) {
+        if (!inVerifySection || depth <= verifyDepth) verifyDepth = depth;
+        inVerifySection = true;
+        sectionFound = true;
+        continue;
+      }
+      if (inVerifySection) {
+        if (depth <= verifyDepth) break;
+        continue;
+      }
+    }
+    if (!inVerifySection) continue;
+    const normalized = normalizeBodyVerifyLine(line, inFence);
+    if (!normalized) continue;
+    if (normalized.prose) {
+      if (normalized.reportRejection) ignoredProse.push(normalized.command);
+      continue;
+    }
+    candidates.set(
+      normalized.command,
+      (candidates.get(normalized.command) ?? false) || normalized.reportRejection
+    );
+  }
+  const partitioned = partitionVerifyCommands([...candidates.keys()]);
+  return {
+    commands: partitioned.accepted,
+    rejected: partitioned.rejected.filter(({ command }) => candidates.get(command) === true),
+    ignoredProse,
+    sectionFound
+  };
+}
+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";
+  return defaultJudgeType;
+}
+function getPolicyAwareDefaultCompetitionVariants(provider, _policy) {
+  return getDefaultCompetitionVariantsForProvider(provider);
+}
+function taskTypeDefaultStrategyWarning(taskId, policy) {
+  if (!policy?.routing?.defaultStrategy) return void 0;
+  return `Task ${taskId}: taskType policy 'routing.defaultStrategy' is accepted and ignored (variant strategies were removed; see ADR-025)`;
+}
+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.judgeAllowUnsafeModel) {
+      config.judgeConfig = {
+        ...config.judgeConfig ?? { type: defaultJudgeType, threshold: defaultThreshold },
+        allowUnsafeModel: 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);
+  const effective = getEffectiveTaskTypePolicy({
+    policy: def?.policy ?? {},
+    confidence: resolution.confidence,
+    resolvedBy: resolution.resolvedBy
+  });
+  return { resolution, policy: effective.policy, policySuppressed: effective.suppressed };
+}
+function inferStageContract(task, description, policyExecutionIntent, policyIntentAuthority) {
+  let contract = resolveStageContract({
+    title: task.title,
+    text: description,
+    metadataExecutionIntent: task.metadata?.executionIntent,
+    policyExecutionIntent,
+    policyIntentAuthority
+  });
+  if (contract.source === "stage-semantics") {
+    const intent = classifyIntent(description);
+    const isHighConfidenceAnalysis = intent.category === "analyze" && intent.confidence > 0.8;
+    contract = {
+      capabilities: {
+        modifiesFiles: !isHighConfidenceAnalysis,
+        executionIntent: isHighConfidenceAnalysis ? "analysis" : "edit"
+      },
+      source: "intent-classifier",
+      authoritativeAnalysis: false
+    };
+  }
+  for (const key of ["modifiesFiles", "readsFiles", "producesText"]) {
+    const value = task.metadata?.[key];
+    if (typeof value === "boolean") contract.capabilities[key] = value;
+  }
+  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. Run: build plan task unblock ${task.id} --to todo`;
+    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 classificationText = stripTaskHeaderMetadata(taskText);
+  const taskTypePolicy = resolveTaskTypePolicy({
+    task,
+    taskText: classificationText,
+    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)) {
+    const suppressedNote = taskTypePolicy.policySuppressed ? "; low-confidence match, restrictive policy suppressed" : "";
+    warnings.push(
+      `Task ${task.id}: taskType=${taskTypePolicy.resolution.id} (${taskTypePolicy.resolution.resolvedBy}${suppressedNote})`
+    );
+  }
+  const resolvedBy = taskTypePolicy?.resolution.resolvedBy;
+  const stagePolicyExecutionIntent = resolvedBy === "fallback" ? void 0 : taskTypePolicy?.policy.executionIntent;
+  const policyIntentAuthority = stagePolicyExecutionIntent === void 0 ? void 0 : resolvedBy === "frontmatter" ? "explicit" : "inferred";
+  const stageContract = inferStageContract(
+    task,
+    classificationText,
+    stagePolicyExecutionIntent,
+    policyIntentAuthority
+  );
+  const capabilities = stageContract.capabilities;
+  if (capabilities.executionIntent === "analysis" && policyIntentAuthority === "inferred" && stagePolicyExecutionIntent === "edit") {
+    warnings.push(
+      `Task ${task.id}: runs read-only (${stageContract.source}) although taskType=${taskTypePolicy?.resolution.id} expects edits; no files will change. To edit, run: build plan task update ${task.id} --execution-intent edit`
+    );
+  }
+  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),
+    templateVariables: {
+      reviewAcceptanceCriteria: extractAcceptanceCriteria(body.rawBody || body.description || "", {
+        checkboxFallback: false
+      })
+    },
+    capabilities,
+    validation
+  };
+  const declaredTargets = [
+    ...body.fileMarkers,
+    ...task.flywheel?.validation?.requiredFiles ?? []
+  ];
+  const inferredTargetCandidates = Array.from(
+    new Set(
+      declaredTargets.length > 0 ? declaredTargets : extractLikelyPathReferences(classificationText)
+    )
+  );
+  const inferredAllowlistTargets = inferredTargetCandidates.filter(isRepoRelativeTargetPath);
+  const unusableTargets = inferredTargetCandidates.filter(
+    (target) => !isRepoRelativeTargetPath(target)
+  );
+  if (unusableTargets.length > 0) {
+    warnings.push(
+      `Task ${task.id}: ignored target path(s) that cannot be repo-relative: ${unusableTargets.join(", ")}`
+    );
+  }
+  const groundedInferredAllowlistTargets = inferredAllowlistTargets.filter(
+    (target) => !isIgnoredTargetPath(target)
+  );
+  const removedStrategyPolicyWarning = taskTypeDefaultStrategyWarning(
+    task.id,
+    taskTypePolicy?.policy
+  );
+  if (removedStrategyPolicyWarning) {
+    warnings.push(removedStrategyPolicyWarning);
+  }
+  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.reasoning || task.routing.profile) {
+      stage.templateVariables = {
+        ...stage.templateVariables,
+        routingReasoning: task.routing.reasoning,
+        routingProfile: task.routing.profile
+      };
+    }
+    if (task.routing.strategy) {
+      warnings.push(
+        `Task ${task.id}: routing pin 'strategy' is accepted and ignored (variant strategies were removed; see ADR-025)`
+      );
+    }
+    const pins = [
+      task.routing.provider && `provider=${task.routing.provider}`,
+      task.routing.model && `model=${task.routing.model}`
+    ].filter(Boolean).join(", ");
+    if (pins) {
+      warnings.push(`Task ${task.id} has routing pins: ${pins}`);
+    }
+  }
+  if (task.flywheel) {
+    if (task.flywheel.modelReasoningEffort) {
+      stage.modelReasoningEffort = task.flywheel.modelReasoningEffort;
+    }
+    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 policyPreferCompetition = taskTypePolicy?.policy.routing?.preferCompetition;
+    const preferCompetition = isFusionDefaultActivity || policyPreferCompetition === true && !isExplicitAnalysisIntent;
+    const policyPrefersSinglePass = !isFusionDefaultActivity && policyPreferCompetition === false;
+    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
+    } : policyPrefersSinglePass ? {
+      strategy: "single-pass",
+      reasons: ["taskType policy routing.preferCompetition=false prefers single-pass"],
+      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
+      );
+      const competitionVariants = stage.competition.variants;
+      const secondCandidateNote = competitionVariants.length > 1 ? `; ${competitionVariants[0]?.provider} is the preferred candidate and ${competitionVariants[1]?.provider} is added from the provider order (--single-pass runs the preferred provider alone)` : "";
+      warnings.push(
+        `Task ${task.id}: Strategy selection \u2192 competition (${strategySelection.reasons.join("; ")})${secondCandidateNote}`
+      );
+    } 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 && competitionOverrides?.judgeAllowUnsafeModel) {
+    stage.competition.judgeConfig = {
+      ...stage.competition.judgeConfig ?? { type: defaultJudgeType, threshold: 70 },
+      allowUnsafeModel: true
+    };
+  }
+  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.type === "verify") {
+      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 ?? "");
+    for (const rejected of bodyVerifyCommands.rejected) {
+      warnings.push(
+        `Task ${task.id}: dropped How to Verify command ${JSON.stringify(rejected.command)} because ${rejected.reason.replace(/^Verify command rejected:\s*/i, "")}`
+      );
+    }
+    for (const line of bodyVerifyCommands.ignoredProse) {
+      warnings.push(
+        `Task ${task.id}: ignored How to Verify line ${JSON.stringify(line.length > 120 ? `${line.slice(0, 117)}...` : line)} because it is not in backticks or a fenced block; only backticked or fenced commands run`
+      );
+    }
+    if (bodyVerifyCommands.commands.length > 0) {
+      stage.verify = { commands: bodyVerifyCommands.commands };
+      warnings.push(
+        `Task ${task.id}: added ${bodyVerifyCommands.commands.length} verify command(s) from How to Verify`
+      );
+    } else if (bodyVerifyCommands.sectionFound) {
+      warnings.push(
+        `Task ${task.id}: How to Verify has no runnable commands; the quality gate will use project-resolved verification commands`
+      );
+    }
+  }
+  const { targets: ignoredTargets } = await collectGitignoredTargets({
+    repoRoot: getPlanningRoot(),
+    targets: taskTargetPaths
+  });
+  if (ignoredTargets.length > 0) {
+    const describeIgnored = (targets) => `Task ${task.id}: target path(s) are gitignored/runtime-scoped and may produce no fan-in material: ` + targets.join(", ");
+    const refusableTargets = strict ? ignoredTargets.filter(isIgnoredTargetPath) : [];
+    const advisoryTargets = ignoredTargets.filter((target) => !refusableTargets.includes(target));
+    if (refusableTargets.length > 0) {
+      errors.push(describeIgnored(refusableTargets));
+    }
+    if (advisoryTargets.length > 0) {
+      warnings.push(
+        `${describeIgnored(advisoryTargets)}. Use tracked paths for change-producing sprint validation tasks.`
+      );
+    }
+  }
+  const undeliverableWarning = formatUndeliverableTargetsWarning(
+    task.id,
+    collectUndeliverableTargets(taskTargetPaths)
+  );
+  if (undeliverableWarning) {
+    warnings.push(undeliverableWarning);
+  }
+  const explicitDeliverables = (task.flywheel?.validation?.requiredFiles?.length ?? 0) > 0;
+  const createIntentTargets = explicitDeliverables ? [] : inferCreateIntentTargets({
+    title: task.title,
+    body: body.rawBody || body.description || ""
+  });
+  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,
+    contract: {
+      executionIntent: capabilities.executionIntent === "analysis" ? "analysis" : "edit",
+      source: stageContract.source
+    },
+    skipped: false,
+    warnings,
+    errors
+  };
+}
+async function buildWorkflowStages(tasks, sprintTaskIds, completedTaskIds, strict, initialSkippedTaskIds, defaultProvider, competitionOverrides, taskTypeContext, defaultJudgeType = "ai") {
+  const stages = [];
+  const stageContracts = {};
+  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);
+      if (result.contract) stageContracts[result.stage.id] = result.contract;
+    }
+  }
+  return {
+    // Declared dependencies decide stage order, so the default previous-stage dependency
+    // later given to a stage without deps never contradicts one.
+    stages: orderStagesByDeclaredDeps(stages),
+    stageContracts,
+    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 'build plan 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, ".build-project", "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);
+    if (specificTaskIds) {
+      const sprintMembers = new Set(sprint.taskIds);
+      const outsideSprint = [...new Set(specificTaskIds)].filter((id) => !sprintMembers.has(id));
+      if (outsideSprint.length > 0) {
+        return {
+          workflow: null,
+          yamlPath: "",
+          warnings: [],
+          errors: [
+            `Selected task(s) are not members of sprint ${sprintId}: ${outsideSprint.join(", ")}`
+          ],
+          skippedTaskIds: [],
+          skippedTasks: []
+        };
+      }
+    }
+    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 `build plan 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"
+      // No denylist here: the flywheel's DEFAULT_WORKFLOW_DENYLIST (root manifests and
+      // lockfiles of every ecosystem, CI workflows) applies when none is declared.
+    },
+    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,
+    reviewPolicy: options.reviewPolicy,
+    warnings,
+    // Sprint output already carries its informational lines (strategy selection) here.
+    onProviderPlan: (plan) => warnings.push(plan)
+  });
+  let yamlPath = "";
+  if (!options.dryRun) {
+    yamlPath = await writeWorkflowYaml(stampedWorkflow, sprintId, options.workflowId);
+  }
+  return {
+    workflow: stampedWorkflow,
+    yamlPath,
+    warnings,
+    errors,
+    skippedTaskIds,
+    skippedTasks,
+    runnableTasks: buildResult.stages.map((stage) => ({
+      taskId: stage.id,
+      title: stage.name ?? stage.id
+    })),
+    stageContracts: buildResult.stageContracts
+  };
+}
+
+export {
+  getEffectiveTaskTypePolicy,
+  getDefaultCompetitionVariantsForProvider,
+  resolveTaskTypeFromCandidates,
+  resolveTaskTypeWithDeclaration,
+  resolveTaskTypeForText,
+  readEnabledRegistryRoutingSnapshots,
+  CanonicalRoutingError,
+  decideCanonicalRouting,
+  planFlywheelStageRouting,
+  resolveTaskExecutionRoles,
+  describeDormantPolicyMismatch,
+  applyExecutionPolicyToGeneratedWorkflow,
+  resolveStageContract,
+  createDefaultCompetitionConfig,
+  generateSprintWorkflow
+};
+//# sourceMappingURL=chunk-MO2BYAAF.js.map