@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-FYMRVUNZ.js

@@ -0,0 +1,1697 @@
+import {
+  applyTaskTransitions,
+  mergeWorkflowResult
+} from "./chunk-6KZKRTG3.js";
+import {
+  recordExecution
+} from "./chunk-3S2R4XJI.js";
+import {
+  WorkflowExecutor,
+  executeWorkflowFile,
+  filterResolvedManagedRepoCleanWarnings,
+  unverifiedCountField,
+  unverifiedStageField
+} from "./chunk-QDKYT4CI.js";
+import {
+  describeDormantPolicyMismatch,
+  resolveTaskExecutionRoles
+} from "./chunk-MO2BYAAF.js";
+import {
+  resolveTaskStatusForStageOutcome
+} from "./chunk-FSJ5TTZ3.js";
+import {
+  describeExecutionPolicyStampMismatch,
+  isCurrentExecutionPolicyWorkflow,
+  isExecutionPolicyEngaged,
+  mapGateStagesToExecutionStages
+} from "./chunk-YTVVTIWJ.js";
+import {
+  validateModel
+} from "./chunk-7HYBSRPZ.js";
+import {
+  parsePlanArtifactEnvelope
+} from "./chunk-CLA6QIJM.js";
+import {
+  isDeferSyncEnabled,
+  syncPlanningFiles
+} from "./chunk-TRURQUBP.js";
+import {
+  activateSprint,
+  closeSprintWithSyncPaths,
+  getCurrentSprint,
+  listTasksInSprint
+} from "./chunk-L2CBG5IX.js";
+import {
+  applyTaskTransitionOutcome,
+  getTask,
+  updateTaskStatus
+} from "./chunk-7LHJDJB3.js";
+import {
+  RUNTIME_ESTIMATOR_VERSION
+} from "./chunk-CE5OZBYY.js";
+import {
+  runWorkflowPreflight
+} from "./chunk-ES6NWJ36.js";
+import {
+  CompletionContractSchema,
+  validateCompletionContracts
+} from "./chunk-MCBNWZNO.js";
+import {
+  withPlanningLock
+} from "./chunk-CSXLLEGB.js";
+import {
+  getBucketByName,
+  getBucketPathByKind
+} from "./chunk-V3KLVK7B.js";
+import {
+  getResultPath,
+  loadManifest,
+  updateManifest
+} from "./chunk-6TRD7TEE.js";
+import {
+  signalCoordinator
+} from "./chunk-GC4CRMTS.js";
+import {
+  resolvePlanningContextForRoot
+} from "./chunk-BBPIILO2.js";
+import {
+  formatManagedSyncBranchError,
+  isManagedSyncBranchError
+} from "./chunk-I7SCBHJN.js";
+import {
+  buildRunBranchName
+} from "./chunk-F55YABKV.js";
+import {
+  hasRealOutput,
+  resolveBuildSelfExecutionScope
+} from "./chunk-AHU3FKPA.js";
+import {
+  CLAUDE_ALIAS_TO_MODEL_ID,
+  resolveModel
+} from "./chunk-H3HGMISG.js";
+import {
+  getWorktreeBaseDir
+} from "./chunk-Z5WGNULV.js";
+import {
+  findRepoRoot,
+  getExecutionContext
+} from "./chunk-7VRJHTGZ.js";
+
+// src/planning/sprint-execution-service.ts
+import fs from "fs/promises";
+import path2 from "path";
+import chalk2 from "chalk";
+import { execa } from "execa";
+
+// src/planning/decomposition-plan-artifact.ts
+import { z as z2 } from "zod";
+
+// src/core/build/schemas.ts
+import { createHash } from "crypto";
+import { z } from "zod";
+var verifyCommandProvenanceSchema = z.enum([
+  "workflow-config",
+  "baseline-workflow-config",
+  "candidate-gate-config",
+  "repair-config",
+  "persisted-finding"
+]);
+var VerifyCommandResultSchema = z.object({
+  command: z.string(),
+  exitCode: z.number().int(),
+  durationMs: z.number().int().nonnegative(),
+  provenance: verifyCommandProvenanceSchema.optional(),
+  outputTail: z.string().optional(),
+  stdoutTail: z.string().optional(),
+  stderrTail: z.string().optional(),
+  baselineErrorCount: z.number().int().nonnegative().optional(),
+  currentErrorCount: z.number().int().nonnegative().optional(),
+  newErrorCount: z.number().int().nonnegative().optional(),
+  /** Failed identically on the base checkout, so reported as passing. */
+  preExistingOnBase: z.boolean().optional(),
+  /** Resolver-proven unavailable (e.g. missing toolchain); kept so readback stays unverified. */
+  unavailable: z.boolean().optional()
+});
+var VerificationDispositionSchema = z.object({
+  outcome: z.enum(["passed", "failed", "unverified", "not-required"]),
+  scope: z.enum(["task", "project", "unknown"]),
+  reason: z.string().optional(),
+  uncovered: z.array(z.string()).optional()
+});
+var GoalGapEvidenceSchema = z.union([
+  z.object({ kind: z.literal("prose"), text: z.string() }),
+  // RESERVED / NOT YET EMITTED: no producer builds this variant today (see
+  // verifyResultId). Kept in the contract for the planned per-command evidence
+  // slice; consumers must not assume it appears.
+  z.object({ kind: z.literal("verifyResult"), verifyResultId: z.string(), command: z.string() })
+]);
+var GoalGapSchema = z.object({
+  id: z.string().min(1),
+  criterion: z.string().min(1),
+  status: z.enum(["satisfied", "unsatisfied", "unknown"]),
+  severity: z.enum(["blocking", "advisory"]),
+  evidence: GoalGapEvidenceSchema
+});
+function goalGapId(criterion) {
+  return createHash("sha1").update(criterion.trim(), "utf8").digest("hex").slice(0, 12);
+}
+var PriorAttemptSummarySchema = z.object({
+  attempt: z.number().int().positive(),
+  summary: z.string(),
+  verifyOutcome: z.enum(["passed", "failed", "skipped"]),
+  whyFailed: z.string().optional()
+});
+var ChangedFileSchema = z.object({
+  path: z.string(),
+  status: z.enum(["added", "modified", "deleted"]),
+  summary: z.string().optional()
+});
+var BudgetStateSchema = z.object({
+  turnsRemaining: z.number().int().nonnegative(),
+  msRemaining: z.number().int().nonnegative().optional()
+});
+var BuildRouteSchema = z.enum(["quick", "planned"]);
+var BuildNextActionSchema = z.enum(["retry", "repair", "replan", "stop"]);
+var BuildProviderProvenanceSchema = z.object({
+  /** The provider (and model) that actually ran. */
+  id: z.string().min(1),
+  model: z.string().min(1).optional(),
+  /** After a provider switch: what the build started with, what failed and why. */
+  requestedProvider: z.string().min(1).optional(),
+  requestedModel: z.string().min(1).optional(),
+  failoverFromProvider: z.string().min(1).optional(),
+  failoverReason: z.string().min(1).optional()
+});
+var BuildContextPreparationSchema = z.object({
+  policy: z.enum(["full", "quick", "review-repair", "repair", "merge"]),
+  status: z.string(),
+  reason: z.string().optional(),
+  executionRoot: z.string(),
+  revision: z.string().nullable(),
+  sources: z.array(z.string()),
+  selectedFiles: z.array(z.string()),
+  selectedFileReasons: z.array(z.string()),
+  omitted: z.array(z.object({ item: z.string(), reason: z.string() })),
+  estimatedTokens: z.number().nullable(),
+  contextBudgetTokens: z.number().nullable(),
+  cache: z.enum(["hit", "miss", "none"]),
+  purpose: z.enum(["confirmed", "absent"]),
+  stack: z.string().nullable(),
+  promptChars: z.object({ original: z.number(), prepared: z.number() })
+});
+var BuildQualityGateReportSchema = z.object({
+  preset: z.string(),
+  passed: z.boolean(),
+  /** Commands the gate actually ran, in order. */
+  ranCommands: z.array(z.string()).optional(),
+  /** Checks that passed, by name (for example Tests). */
+  passedChecks: z.array(z.string()).optional(),
+  /** The `--verify` commands that stood in for a verifier the resolver could not derive. */
+  deferredToVerifyCommands: z.array(z.string()).optional(),
+  /** Why nothing could verify the change, when the gate ran no failing check. */
+  unverifiedReason: z.string().optional(),
+  /** The check that failed: name, command and the first lines of its output. */
+  failure: z.object({ check: z.string(), command: z.string().optional(), detail: z.string() }).optional(),
+  /** Where this attempt's unapplied changes were saved, relative to the repository. */
+  attemptPatch: z.string().optional()
+});
+var BuildGoalEvidenceSchema = z.object({
+  semanticProgress: z.object({
+    movedCloser: z.boolean(),
+    confidence: z.number(),
+    reasoning: z.string()
+  }),
+  evaluator: z.object({ provider: z.string(), model: z.string().optional() }).optional()
+});
+var BuildAttemptOutcomeSchema = z.object({
+  intent: z.string(),
+  acceptanceCriteria: z.array(z.string()),
+  route: BuildRouteSchema,
+  provider: BuildProviderProvenanceSchema.optional(),
+  /** Quick route only: the context the attempt's provider turn was given. */
+  contextPreparation: BuildContextPreparationSchema.optional(),
+  /** Planned execution identity used by automation to locate workflow artifacts. */
+  workflowId: z.string().min(1).optional(),
+  /** Present only when the result was kept on a review branch and not applied to the checkout. */
+  review: z.object({ branch: z.string().optional(), baseSha: z.string().optional() }).optional(),
+  /** Planned route: advisory reviews that gave no trusted result, so the build passed unreviewed. */
+  reviewUnavailable: z.array(z.object({ stageId: z.string(), reason: z.string() })).optional(),
+  // Zero is reserved for the no-attempt terminal sentinel emitted by
+  // emptyOutcome() when the loop short-circuits before any attempt runs.
+  attempt: z.number().int().nonnegative(),
+  changedFiles: z.array(ChangedFileSchema),
+  verifyResults: z.array(VerifyCommandResultSchema),
+  goalGap: z.object({
+    satisfied: z.boolean(),
+    gaps: z.array(GoalGapSchema),
+    /** Raw evaluator status from goal-satisfaction-gate; used for truthful CLI rendering. */
+    evaluatorStatus: z.enum(["satisfied", "unsatisfied", "blocked"]).optional(),
+    /** Existing goal evaluator diagnostics, when the check ran. */
+    evidence: BuildGoalEvidenceSchema.optional()
+  }),
+  /** Present only when user verification could not run: delivered unverified, never passed. */
+  verification: VerificationDispositionSchema.optional(),
+  /** Quick route only: what the quality gate ran or why it could not verify. Omitted when it only passed. */
+  qualityGate: BuildQualityGateReportSchema.optional(),
+  priorAttempts: z.array(PriorAttemptSummarySchema),
+  priorAttemptsTruncated: z.boolean(),
+  recommendedNextAction: BuildNextActionSchema,
+  budgetState: BudgetStateSchema,
+  costUsd: z.number().nonnegative().optional(),
+  durationMs: z.number().int().nonnegative()
+});
+var PRIOR_ATTEMPTS_RETAINED = 5;
+var BuildTerminalReasonSchema = z.enum([
+  "satisfied",
+  "max-turns",
+  "timebox",
+  "aborted",
+  "error"
+]);
+var BuildResultSchema = z.object({
+  finalOutcome: BuildAttemptOutcomeSchema,
+  terminalReason: BuildTerminalReasonSchema,
+  totalDurationMs: z.number().int().nonnegative(),
+  totalCostUsd: z.number().nonnegative().optional(),
+  turnsRun: z.number().int().nonnegative()
+});
+function truncatePriorAttempts(attempts) {
+  if (attempts.length <= PRIOR_ATTEMPTS_RETAINED) {
+    return { attempts: [...attempts], truncated: false };
+  }
+  return {
+    attempts: attempts.slice(attempts.length - PRIOR_ATTEMPTS_RETAINED),
+    truncated: true
+  };
+}
+function structureLegacyGaps(rawGaps) {
+  return rawGaps.map((raw) => raw.trim()).filter((raw) => raw.length > 0).map((criterion) => ({
+    id: goalGapId(criterion),
+    criterion,
+    status: "unsatisfied",
+    severity: "blocking",
+    evidence: { kind: "prose", text: criterion }
+  }));
+}
+function removeDuplicateVerifyGaps(gaps, verifyResults) {
+  const failedVerifyResults = verifyResults.filter((result) => result.exitCode !== 0);
+  if (failedVerifyResults.length === 0) return [...gaps];
+  return gaps.filter((gap) => !isDuplicateVerifyGap(gap, failedVerifyResults));
+}
+function removeDuplicateVerifyReasons(reasons, verifyResults) {
+  const failedVerifyResults = verifyResults.filter((result) => result.exitCode !== 0);
+  if (failedVerifyResults.length === 0) return [...reasons];
+  return reasons.filter((reason) => {
+    const gap = {
+      id: goalGapId(reason),
+      criterion: reason,
+      status: "unsatisfied",
+      severity: "blocking",
+      evidence: { kind: "prose", text: reason }
+    };
+    return !isDuplicateVerifyGap(gap, failedVerifyResults);
+  });
+}
+function blockingGapsUnsatisfied(gaps) {
+  return gaps.filter((gap) => gap.severity === "blocking" && gap.status === "unsatisfied");
+}
+function downgradeGapsToAdvisory(gaps) {
+  return gaps.map((gap) => ({ ...gap, severity: "advisory" }));
+}
+var CARRYOVER_DIFF_BYTE_CAP = 2e5;
+function capDiff(diff) {
+  if (diff.length <= CARRYOVER_DIFF_BYTE_CAP) return diff;
+  return `${diff.slice(0, CARRYOVER_DIFF_BYTE_CAP)}
+[... diff truncated at ${CARRYOVER_DIFF_BYTE_CAP} bytes]`;
+}
+var GATE_EVIDENCE_BYTE_CAP = 800;
+function verifyResultToGateCheck(result, prefix = "verify") {
+  const failed = result.exitCode !== 0;
+  const evidence = (failed ? result.outputTail || result.stderrTail || result.stdoutTail || "" : [result.stderrTail, result.stdoutTail, result.outputTail].find(hasRealOutput) ?? (result.stderrTail || result.stdoutTail || result.outputTail || "")).slice(0, GATE_EVIDENCE_BYTE_CAP);
+  return {
+    name: `${prefix}: ${result.command}`,
+    status: failed ? "failed" : "passed",
+    summary: failed ? `exit ${result.exitCode} in ${result.durationMs}ms` : `exit 0 in ${result.durationMs}ms`,
+    evidence: evidence.length > 0 ? evidence : void 0
+  };
+}
+var VERIFY_GAP_CONTEXT = /\b(?:verify|verification|verify command|quality gate|gate failed|command failed|failed verification|exit\s+\d+|non[- ]?zero)\b/i;
+function isDuplicateVerifyGap(gap, failedVerifyResults) {
+  const gapText = gap.evidence.kind === "prose" ? `${gap.criterion}
+${gap.evidence.text}` : gap.criterion;
+  const normalizedGap = normalizeForVerifyGapMatch(gapText);
+  if (!VERIFY_GAP_CONTEXT.test(gapText)) return false;
+  return failedVerifyResults.some((result) => {
+    const normalizedCommand = normalizeForVerifyGapMatch(result.command);
+    if (normalizedCommand.length >= 8 && normalizedGap.includes(normalizedCommand)) {
+      return true;
+    }
+    return verifyFailureFragments(result).some((fragment) => {
+      const normalizedFragment = normalizeForVerifyGapMatch(fragment);
+      return normalizedFragment.length >= 20 && normalizedGap.includes(normalizedFragment);
+    });
+  });
+}
+function verifyFailureFragments(result) {
+  return [result.outputTail, result.stderrTail, result.stdoutTail].flatMap((text) => (text ?? "").split(/\r?\n/)).map((line) => line.trim()).filter((line) => line.length > 0);
+}
+function normalizeForVerifyGapMatch(value) {
+  return value.toLowerCase().replace(/[`'"]/g, "").replace(/\s+/g, " ").trim();
+}
+
+// src/planning/decomposition-plan-artifact.ts
+var CompetitionConfigSchema = z2.object({
+  variants: z2.array(
+    z2.object({
+      provider: z2.string().min(1)
+    }).passthrough()
+  )
+}).passthrough().transform((value) => value);
+var AutoloopConfigSchema = z2.object({}).passthrough().transform((value) => value);
+var StageCapabilitiesSchema = z2.object({
+  modifiesFiles: z2.boolean(),
+  readsFiles: z2.boolean().optional(),
+  producesText: z2.boolean().optional(),
+  executionIntent: z2.enum(["edit", "analysis"]).optional()
+}).passthrough().transform((value) => value);
+var StageValidationSchema = z2.object({
+  enabled: z2.boolean(),
+  requireChanges: z2.boolean().optional(),
+  target: z2.string().optional(),
+  threshold: z2.number().optional(),
+  maxRetries: z2.number().int().nonnegative().optional(),
+  requiredFiles: z2.array(z2.string()).optional(),
+  checks: z2.array(z2.unknown()).optional(),
+  semanticChecks: z2.array(z2.unknown()).optional(),
+  // Shape-check each contract, then apply the full set-level authoring policy
+  // (C08-R06) so individually valid llm_judge entries cannot bypass rejection
+  // of an llm_judge-only set on create/parse of decomposition artifacts.
+  completionContract: z2.union([CompletionContractSchema, z2.array(CompletionContractSchema)]).optional(),
+  extract: z2.unknown().optional()
+}).passthrough().superRefine((value, ctx) => {
+  if (value.completionContract === void 0) {
+    return;
+  }
+  const contractValidation = validateCompletionContracts(value.completionContract);
+  for (const error of contractValidation.errors) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      // Surface the shared completionContract field so create/parse errors
+      // match the actionable policy used by schema-validator / flywheel.
+      message: error.message,
+      path: ["completionContract"]
+    });
+  }
+}).transform((value) => value);
+var SubStageExecutionTelemetrySchema = z2.object({
+  validationPassed: z2.boolean(),
+  cost: z2.number(),
+  provider: z2.string().optional(),
+  model: z2.string().optional(),
+  resolvedModel: z2.string().optional(),
+  summary: z2.string().optional(),
+  durationMs: z2.number().int().optional(),
+  changedFilesCount: z2.number().int().optional(),
+  changedFiles: z2.array(z2.string()).optional(),
+  completeness: z2.number().optional(),
+  completenessSource: z2.enum(["provider", "post-commit", "derived"]).optional(),
+  verifyCommands: z2.array(z2.unknown()).optional(),
+  requiredFiles: z2.array(z2.string()).optional(),
+  missingRequiredFiles: z2.array(z2.string()).optional(),
+  untouchedRequiredFiles: z2.array(z2.string()).optional(),
+  intentionalNoOp: z2.boolean().optional(),
+  warnings: z2.array(z2.string()).optional(),
+  verification: VerificationDispositionSchema.optional(),
+  recovery: z2.object({
+    classification: z2.enum([
+      "deliverable-miss",
+      "structural",
+      "transient",
+      "transport",
+      "provider-timeout",
+      "other"
+    ]),
+    retryBudgetUsed: z2.number().int().nonnegative(),
+    retryBudgetTotal: z2.number().int().nonnegative(),
+    infrastructureRetryBudgetUsed: z2.number().int().nonnegative().optional(),
+    infrastructureRetryBudgetTotal: z2.number().int().nonnegative().optional(),
+    replanningBudgetUsed: z2.number().int().nonnegative().optional(),
+    replanningBudgetTotal: z2.number().int().nonnegative().optional(),
+    recoverable: z2.boolean(),
+    retryAttempted: z2.boolean(),
+    replanningAttempted: z2.boolean(),
+    note: z2.string().optional()
+  }).optional(),
+  modelSelectionSource: z2.enum([
+    "explicit-substage",
+    "inherited-parent",
+    "flywheel-tier-default",
+    "provider-registry-default"
+  ]).optional()
+}).passthrough();
+var DecompositionPlanExecutionSummarySchema = z2.object({
+  workflowId: z2.string().min(1),
+  sprintId: z2.string().min(1),
+  updatedAt: z2.string().min(1),
+  validationPassed: z2.boolean(),
+  verificationPolicy: z2.enum(["findings", "blocking"]).optional(),
+  successfulSubStages: z2.number().int().nonnegative(),
+  unverifiedSubStages: z2.number().int().positive().optional(),
+  totalSubStages: z2.number().int().nonnegative(),
+  orchestrationCost: z2.number(),
+  totalCostWithOrchestration: z2.number(),
+  replanningTriggered: z2.boolean().optional(),
+  replanningAttempts: z2.number().int().nonnegative().optional(),
+  zeroOutput: z2.boolean().optional(),
+  recovery: z2.object({
+    classification: z2.enum([
+      "deliverable-miss",
+      "structural",
+      "transient",
+      "transport",
+      "provider-timeout",
+      "other"
+    ]),
+    retryBudgetUsed: z2.number().int().nonnegative(),
+    retryBudgetTotal: z2.number().int().nonnegative(),
+    infrastructureRetryBudgetUsed: z2.number().int().nonnegative().optional(),
+    infrastructureRetryBudgetTotal: z2.number().int().nonnegative().optional(),
+    replanningBudgetUsed: z2.number().int().nonnegative().optional(),
+    replanningBudgetTotal: z2.number().int().nonnegative().optional(),
+    recoverable: z2.boolean(),
+    retryAttempted: z2.boolean(),
+    replanningAttempted: z2.boolean(),
+    note: z2.string().optional()
+  }).optional()
+}).passthrough();
+var ExecutionMetadataSchema = z2.object({
+  provider: z2.string().min(1),
+  resolvedModel: z2.string().optional(),
+  usedProviders: z2.array(z2.string().min(1)).optional(),
+  usedModels: z2.array(z2.string().min(1)).optional(),
+  durationMs: z2.number().int().nonnegative(),
+  totalCost: z2.number(),
+  success: z2.boolean(),
+  exitReason: z2.string().min(1),
+  warnings: z2.array(z2.string()).optional(),
+  errors: z2.array(z2.string()).optional(),
+  updatedAt: z2.string().min(1)
+}).passthrough();
+var BudgetAssessmentSchema = z2.object({
+  mode: z2.enum(["advisory"]),
+  budgetPerSubStage: z2.number(),
+  totalBudget: z2.number(),
+  estimatedTotalCost: z2.number(),
+  overBudget: z2.boolean(),
+  overBudgetStages: z2.array(
+    z2.object({
+      stageId: z2.string(),
+      estimatedCost: z2.number(),
+      advisoryCost: z2.number()
+    })
+  ),
+  updatedAt: z2.string().min(1)
+}).passthrough();
+var SubStageSpecSchema = z2.object({
+  id: z2.string().min(1),
+  type: z2.enum(["standard", "competition", "verify", "autoloop", "refinement"]),
+  name: z2.string().max(500).optional(),
+  prompt: z2.string().max(5e4),
+  description: z2.string().max(1e4).optional(),
+  deps: z2.array(z2.string()).optional(),
+  provider: z2.string().max(50).regex(/^[a-z][a-z0-9_-]*$/i, "Provider name must be a valid identifier").optional(),
+  model: z2.string().optional(),
+  estimatedCost: z2.number().optional(),
+  actualCost: z2.number().optional(),
+  actualDurationMs: z2.number().int().optional(),
+  result: SubStageExecutionTelemetrySchema.optional(),
+  competition: CompetitionConfigSchema.optional(),
+  autoloop: AutoloopConfigSchema.optional(),
+  verify: z2.object({
+    commands: z2.array(z2.string())
+  }).optional(),
+  capabilities: StageCapabilitiesSchema.optional(),
+  validation: StageValidationSchema.optional(),
+  allowEmptyResults: z2.boolean().optional(),
+  allowlist: z2.array(z2.string()).optional(),
+  retryBudget: z2.number().int().nonnegative().optional()
+}).passthrough();
+var DecompositionPlanSchema = z2.object({
+  goal: z2.string().min(1),
+  subStages: z2.array(SubStageSpecSchema).min(1),
+  rationale: z2.string(),
+  estimatedTotalCost: z2.number(),
+  estimatedDurationMs: z2.number().int(),
+  hasParallelGroups: z2.boolean(),
+  parallelGroups: z2.array(z2.array(z2.string())).optional(),
+  executionSummary: DecompositionPlanExecutionSummarySchema.optional(),
+  enforcementVersion: z2.number().optional().default(0),
+  budgetAssessment: BudgetAssessmentSchema.optional()
+}).passthrough();
+var OrchestratorConfigSnapshotSchema = z2.object({
+  maxSubStages: z2.number().int().positive(),
+  budgetPerSubStage: z2.number(),
+  totalBudget: z2.number(),
+  budgetMode: z2.enum(["advisory"]).optional(),
+  allowedSubStageTypes: z2.array(
+    z2.enum(["standard", "competition", "verify", "autoloop", "refinement"])
+  ),
+  orchestrationProvider: z2.string(),
+  orchestrationModel: z2.string(),
+  hints: z2.array(z2.string()),
+  allowReplanning: z2.boolean(),
+  maxReplanningAttempts: z2.number().int().nonnegative(),
+  retryBudgetPerSubStage: z2.number().int().nonnegative().default(1),
+  enableParallelization: z2.boolean(),
+  dryRun: z2.boolean(),
+  maxRecursionDepth: z2.number().int().nonnegative(),
+  repairOnVerifyFailure: z2.object({
+    enabled: z2.boolean(),
+    maxIterations: z2.number().int().positive().optional(),
+    timeboxMs: z2.number().int().positive().optional()
+  }).optional()
+}).passthrough();
+var DecompositionIntentSchema = z2.object({
+  rawIntent: z2.string().min(1),
+  source: z2.enum(["manual", "intake", "splitter"]).optional(),
+  interview: z2.object({
+    success: z2.string().optional(),
+    constraints: z2.string().optional(),
+    nonGoals: z2.string().optional(),
+    risk: z2.string().optional()
+  }).optional(),
+  configNonGoals: z2.array(z2.string()).optional(),
+  assumptions: z2.object({
+    inferred: z2.array(
+      z2.object({
+        key: z2.enum(["success", "constraints", "nonGoals", "risk"]),
+        value: z2.string(),
+        confidence: z2.enum(["high", "medium", "low"])
+      })
+    ).optional(),
+    alternatives: z2.array(
+      z2.object({
+        key: z2.enum(["success", "constraints", "nonGoals", "risk"]),
+        label: z2.string(),
+        description: z2.string()
+      })
+    ).optional(),
+    questionsAsked: z2.number().int().nonnegative().optional(),
+    analysisProvider: z2.string().optional(),
+    contextSignals: z2.object({
+      hadActiveSprint: z2.boolean().optional(),
+      hadBacklogItems: z2.boolean().optional(),
+      hadGitContext: z2.boolean().optional(),
+      hadModifiedFiles: z2.boolean().optional(),
+      taskTypeId: z2.string().optional()
+    }).optional()
+  }).optional()
+}).passthrough();
+var DecompositionPlanArtifactPayloadSchema = z2.object({
+  goal: z2.string().min(1),
+  intent: DecompositionIntentSchema.optional(),
+  orchestratorConfig: OrchestratorConfigSnapshotSchema,
+  plan: DecompositionPlanSchema,
+  executionDefaults: z2.object({
+    provider: z2.string().min(1),
+    model: z2.string().optional(),
+    providerExplicit: z2.boolean().optional()
+  }).passthrough(),
+  executionMetadata: ExecutionMetadataSchema.optional(),
+  budgetAssessment: BudgetAssessmentSchema.optional()
+}).passthrough();
+var SUPPORTED_VALIDATION_PROVIDERS = /* @__PURE__ */ new Set([
+  "claude",
+  "codex",
+  "copilot",
+  "cursor",
+  "gemini",
+  "openai"
+]);
+function normalizePersistedModel(provider, model, options = {}) {
+  if (typeof model !== "string") {
+    return model;
+  }
+  const trimmedModel = model.trim();
+  if (trimmedModel.length === 0) {
+    return options.preserveEmpty ? "" : void 0;
+  }
+  const normalizedProvider = provider?.trim().toLowerCase();
+  if (!normalizedProvider || !SUPPORTED_VALIDATION_PROVIDERS.has(normalizedProvider)) {
+    return trimmedModel;
+  }
+  if (normalizedProvider === "claude") {
+    const resolvedClaudeModel = resolveModel(trimmedModel) ?? trimmedModel;
+    return CLAUDE_ALIAS_TO_MODEL_ID[resolvedClaudeModel] ?? resolvedClaudeModel;
+  }
+  const validation = validateModel({
+    provider: normalizedProvider,
+    model: trimmedModel
+  });
+  return validation.valid ? validation.normalizedModel ?? trimmedModel : trimmedModel;
+}
+function normalizeDecompositionPlanArtifactPayload(payload) {
+  const executionProvider = payload.executionDefaults.provider;
+  const normalizedExecutionModel = normalizePersistedModel(
+    executionProvider,
+    payload.executionDefaults.model
+  );
+  const normalizedOrchestrationProvider = payload.orchestratorConfig.orchestrationProvider || executionProvider;
+  return {
+    ...payload,
+    orchestratorConfig: {
+      ...payload.orchestratorConfig,
+      orchestrationModel: normalizePersistedModel(
+        normalizedOrchestrationProvider,
+        payload.orchestratorConfig.orchestrationModel,
+        { preserveEmpty: true }
+      ) ?? ""
+    },
+    plan: {
+      ...payload.plan,
+      subStages: payload.plan.subStages.map((subStage) => ({
+        ...subStage,
+        model: normalizePersistedModel(subStage.provider ?? executionProvider, subStage.model)
+      }))
+    },
+    executionDefaults: {
+      ...payload.executionDefaults,
+      model: normalizedExecutionModel
+    }
+  };
+}
+function toDecompositionPlanArtifactPayload(input) {
+  return normalizeDecompositionPlanArtifactPayload(
+    DecompositionPlanArtifactPayloadSchema.parse(input)
+  );
+}
+function parseDecompositionPlanArtifactPayload(value) {
+  return normalizeDecompositionPlanArtifactPayload(
+    DecompositionPlanArtifactPayloadSchema.parse(value)
+  );
+}
+
+// src/planning/sprint-closeout.ts
+import path from "path";
+import chalk from "chalk";
+async function closeSprintAfterApply(config, logger) {
+  try {
+    const tasks = await listTasksInSprint(config.sprintId);
+    if (!tasks.every((task) => task.status === "done")) {
+      logger.log(chalk.yellow("Sprint not ready to close (not all tasks are done)"));
+      logger.log(chalk.dim("Incomplete tasks:"));
+      for (const task of tasks.filter((task2) => task2.status !== "done")) {
+        logger.log(chalk.dim(`  - ${task.id}: ${task.title} (${task.status})`));
+      }
+      return { closed: false };
+    }
+    logger.log(chalk.cyan("Closing sprint..."));
+    const closeout = await closeSprintWithSyncPaths(config.sprintId, {
+      force: false,
+      noArchive: false,
+      dryRun: false
+    });
+    const projectRoot = findRepoRoot();
+    const paths = [...closeout.touchedPaths];
+    if (config.archiveBacklog && config.archiveLinkedBacklogItems) {
+      const linked = await config.archiveLinkedBacklogItems(config.sprintId, {
+        dryRun: false
+      }).catch((error) => {
+        logger.log(chalk.yellow(`Failed to archive linked backlog items: ${String(error)}`));
+        return void 0;
+      });
+      if (linked?.archived.length) {
+        const backlogDir = getBucketPathByKind("backlog", projectRoot);
+        const publishArchive = resolvePlanningContextForRoot(projectRoot).backend === "git-branch" && getBucketByName("backlog", projectRoot)?.archivePublished === true;
+        for (const item of linked.archived) {
+          paths.push(path.join(backlogDir, `${item.id}.md`));
+          if (publishArchive) paths.push(item.archivedPath);
+        }
+        logger.log(chalk.green(`Archived ${linked.archived.length} linked backlog item(s)`));
+      } else if (linked) {
+        const warning = linked.warning ?? (linked.skipped.length > 0 ? `Linked backlog items were not archived: ${linked.skipped.join(", ")}` : `No linked backlog items found for sprint ${config.sprintId} (including archived tasks)`);
+        logger.log(chalk.yellow(`Warning: ${warning}`));
+      }
+    }
+    if (paths.length > 0) {
+      const publication = await syncPlanningFiles(
+        projectRoot,
+        [...new Set(paths)],
+        `sprint: close ${config.sprintId}`,
+        { strict: true, allowPushFailure: true, deferPublication: isDeferSyncEnabled() }
+      ).catch((error) => {
+        if (!isManagedSyncBranchError(error) || resolvePlanningContextForRoot(projectRoot).backend !== "checkout") {
+          throw error;
+        }
+        logger.log(chalk.yellow(`  Warning: ${formatManagedSyncBranchError(error)}`));
+        return { synced: false, status: "skipped" };
+      });
+      if (!publication.synced && !publication.noRemote && publication.status !== "skipped") {
+        throw new Error(`Sprint closeout publication is incomplete (${publication.status})`);
+      }
+    }
+    logger.log(chalk.green(`Sprint ${config.sprintId} closed (${tasks.length} done)`));
+    return { closed: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.log(chalk.yellow("Failed to close sprint:"));
+    logger.log(chalk.yellow(`  ${message}`));
+    return { closed: false, error: message };
+  }
+}
+
+// src/planning/sprint-execution-service.ts
+async function captureCallerCheckoutSnapshot() {
+  const repoRoot = findRepoRoot();
+  try {
+    const branchResult = await execa("git", ["branch", "--show-current"], {
+      cwd: repoRoot,
+      stdio: "pipe",
+      timeout: 3e4
+    });
+    const branch = branchResult.stdout.trim();
+    return { repoRoot, branch: branch || null };
+  } catch {
+    return { repoRoot, branch: null };
+  }
+}
+async function restoreCallerCheckoutIfNeeded(snapshot) {
+  if (!snapshot.branch) {
+    return null;
+  }
+  let currentBranch = "";
+  try {
+    const currentResult = await execa("git", ["branch", "--show-current"], {
+      cwd: snapshot.repoRoot,
+      stdio: "pipe",
+      timeout: 3e4
+    });
+    currentBranch = currentResult.stdout.trim();
+  } catch (error) {
+    return `Failed to inspect caller checkout before sprint status sync: ${error instanceof Error ? error.message : String(error)}`;
+  }
+  if (currentBranch === snapshot.branch) {
+    return null;
+  }
+  let status = "";
+  try {
+    const statusResult = await execa("git", ["status", "--porcelain"], {
+      cwd: snapshot.repoRoot,
+      stdio: "pipe",
+      timeout: 3e4
+    });
+    status = statusResult.stdout.trim();
+  } catch (error) {
+    return `Failed to inspect caller checkout cleanliness before sprint status sync: ${error instanceof Error ? error.message : String(error)}`;
+  }
+  if (status.length > 0) {
+    const currentLabel = currentBranch || "detached HEAD";
+    return `Caller checkout changed from ${snapshot.branch} to ${currentLabel} and has local changes; refusing to sync managed task status into the wrong checkout.`;
+  }
+  try {
+    await execa("git", ["checkout", snapshot.branch], {
+      cwd: snapshot.repoRoot,
+      stdio: "pipe",
+      timeout: 3e4
+    });
+    return null;
+  } catch (error) {
+    return `Failed to restore caller checkout to ${snapshot.branch} before sprint status sync: ${error instanceof Error ? error.message : String(error)}`;
+  }
+}
+function buildFailedExecutionResult(summary) {
+  return {
+    workflowId: "preflight-failed",
+    workflowName: summary.workflowName,
+    stageCount: summary.stageCount,
+    plannedStageCount: summary.plannedStageCount,
+    success: false,
+    degraded: false,
+    stageResults: [],
+    totalCost: 0,
+    totalDuration: 0,
+    budgetSummary: "Preflight failed before execution",
+    errors: summary.errors,
+    warnings: summary.warnings
+  };
+}
+async function enforceExecutionPolicyStamp(config, logger) {
+  let workflow;
+  try {
+    const executor = new WorkflowExecutor();
+    workflow = await executor.loadWorkflow(config.yamlPath);
+  } catch (error) {
+    return {
+      passed: false,
+      error: `Unable to validate the execution-policy workflow: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  const stamp = workflow.metadata?.executionPolicy;
+  if (stamp !== void 0) {
+    if (isCurrentExecutionPolicyWorkflow(workflow)) return { passed: true };
+    return {
+      passed: false,
+      error: `Refusing to execute a generated workflow with a stale or malformed execution-policy stamp (${describeExecutionPolicyStampMismatch(stamp, workflow)}). Regenerate the workflow through the current Build version.`
+    };
+  }
+  if (config.allowUnstampedWorkflow === true) {
+    logger.log(chalk2.yellow("running hand-authored workflow without execution policy"));
+    return { passed: true };
+  }
+  if (!workflowHasTaskExecutionStages(workflow)) {
+    return { passed: true };
+  }
+  if (config.reviewPolicy === "off") {
+    return { passed: true };
+  }
+  let dormantMismatch;
+  if (workflow.metadata?.executionPolicyDormant !== void 0) {
+    try {
+      dormantMismatch = describeDormantPolicyMismatch(workflow, {
+        cwd: process.cwd(),
+        reviewPolicy: config.reviewPolicy
+      });
+    } catch (error) {
+      dormantMismatch = `it could not be evaluated: ${error instanceof Error ? error.message : String(error)}`;
+    }
+    if (dormantMismatch === void 0) return { passed: true };
+  }
+  let gate = "off";
+  try {
+    const roles = resolveTaskExecutionRoles(workflow, {
+      cwd: process.cwd(),
+      reviewPolicy: config.reviewPolicy
+    });
+    if (roles.reviewer.gate.value === "off" || !isExecutionPolicyEngaged(roles) && dormantMismatch === void 0) {
+      return { passed: true };
+    }
+    gate = roles.reviewer.gate.value;
+  } catch (error) {
+    return {
+      passed: false,
+      error: `Refusing to execute with invalid role configuration: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  return {
+    passed: false,
+    error: `Refusing to execute an unstamped generated workflow: it contains task-execution stages but is missing the execution-policy stamp while the reviewer gate is '${gate}'. Regenerate the workflow through \`build plan sprint run\` / \`build plan approve --to-sprint\` (which apply the execution policy), set \`roles.reviewer.gate = off\` to disable review, or pass the explicit escape hatch for hand-authored/resumed workflows.` + (dormantMismatch ? ` The workflow's recorded dormant policy no longer applies: ${dormantMismatch}.` : "")
+  };
+}
+function workflowHasTaskExecutionStages(workflow) {
+  const isExec = (type) => (type ?? "standard") === "standard" || type === "competition";
+  for (const stage of workflow.stages) {
+    if (stage.type === "orchestrator" && stage.seededPlan) {
+      if (stage.seededPlan.subStages.some((sub) => isExec(sub.type))) return true;
+      continue;
+    }
+    if (isExec(stage.type)) return true;
+  }
+  return false;
+}
+async function runSprintWorkflowPreflight(config) {
+  const { runExecutionPreflight, formatExecutionPreflightWarning } = await import("./execution-preflight-DASJWWQF.js");
+  const preflightWarning = formatExecutionPreflightWarning(
+    await runExecutionPreflight({ verbose: config.verbose })
+  );
+  if (preflightWarning) console.warn(preflightWarning);
+  const executor = new WorkflowExecutor();
+  try {
+    const workflow = await executor.loadWorkflow(config.yamlPath);
+    const workflowName = workflow.name ?? "Unnamed Workflow";
+    const stageCount = workflow.stages.length;
+    const projectRoot = findRepoRoot();
+    const worktreeRoot = config.preflight?.worktreeHygiene?.baseDir ?? getWorktreeBaseDir();
+    const preflight = await runWorkflowPreflight(workflow, {
+      authProbeEnv: { ...process.env, ...getExecutionContext().envOverrides },
+      ...config.preflight ?? {},
+      verbose: config.verbose,
+      cwd: projectRoot,
+      worktreeHygiene: {
+        ...config.preflight?.worktreeHygiene ?? {},
+        baseDir: worktreeRoot
+      }
+    });
+    return {
+      passed: preflight.passed,
+      workflowName,
+      stageCount,
+      plannedStageCount: stageCount,
+      warnings: [...filterResolvedManagedRepoCleanWarnings(preflight.warnings, void 0)],
+      errors: [...preflight.errors],
+      executionContext: {
+        projectRoot,
+        worktreeRoot,
+        preflight: { result: preflight, source: "caller" }
+      }
+    };
+  } catch (error) {
+    return {
+      passed: false,
+      workflowName: "Unnamed Workflow",
+      stageCount: 0,
+      plannedStageCount: 0,
+      warnings: [],
+      errors: [
+        `Preflight execution failed: ${error instanceof Error ? error.message : String(error)}`
+      ]
+    };
+  }
+}
+async function loadGateMapFromWorkflowYaml(yamlPath) {
+  if (!yamlPath) return /* @__PURE__ */ new Map();
+  try {
+    const { default: yaml } = await import("js-yaml");
+    const parsed = yaml.load(await fs.readFile(yamlPath, "utf-8"));
+    if (!parsed || !Array.isArray(parsed.stages)) return /* @__PURE__ */ new Map();
+    return mapGateStagesToExecutionStages(parsed);
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+async function buildFallbackTaskTransitions(sprintId, stageResults, apply, stageToTaskMap, yamlPath) {
+  if (signalCoordinator.isShuttingDown) {
+    return [];
+  }
+  const gateToExecution = await loadGateMapFromWorkflowYaml(yamlPath);
+  const gateByExecution = new Map(
+    [...gateToExecution.entries()].map(([gateId, executionId]) => [executionId, gateId])
+  );
+  const targetStatus = resolveTaskStatusForStageOutcome({
+    kind: "stage-result",
+    validationPassed: true,
+    apply
+  });
+  if (!targetStatus) {
+    return [];
+  }
+  let sprintTasks;
+  try {
+    sprintTasks = await listTasksInSprint(sprintId);
+  } catch (error) {
+    if (signalCoordinator.isShuttingDown && isMissingSprintMetadataError(error)) {
+      return [];
+    }
+    throw error;
+  }
+  const sprintTaskIds = new Set(sprintTasks.map((task) => task.id));
+  const transitions = [];
+  const maybeTaskIdForStage = (stageId) => {
+    const mappedTaskId = stageToTaskMap?.get(stageId);
+    if (mappedTaskId && sprintTaskIds.has(mappedTaskId)) return mappedTaskId;
+    if (sprintTaskIds.has(stageId)) return stageId;
+    return void 0;
+  };
+  const flattened = flattenStageResultEntries(stageResults);
+  const passedStageIds = new Set(
+    flattened.filter((result) => result.validationPassed === true).map((result) => result.stageId)
+  );
+  for (const stageResult of flattened) {
+    const taskId = maybeTaskIdForStage(stageResult.stageId);
+    if (!taskId || stageResult.validationPassed !== true) continue;
+    const gateId = gateByExecution.get(stageResult.stageId);
+    if (gateId && !passedStageIds.has(gateId)) continue;
+    transitions.push({ taskId, targetStatus });
+  }
+  return Array.from(new Map(transitions.map((entry) => [entry.taskId, entry])).values());
+}
+function flattenStageResultEntries(stageResults) {
+  const entries = [];
+  const visit = (stageResult) => {
+    entries.push({
+      stageId: stageResult.stageId,
+      validationPassed: stageResult.validationPassed === true
+    });
+    if (!isOrchestratorStageResult(stageResult)) return;
+    for (const subStage of stageResult.subStageResults) {
+      entries.push({
+        stageId: subStage.spec.id,
+        validationPassed: subStage.result.validationPassed === true
+      });
+      if (isOrchestratorStageResult(subStage.result)) {
+        visit(subStage.result);
+      }
+    }
+  };
+  for (const stageResult of stageResults) visit(stageResult);
+  return entries;
+}
+function attachResultArtifactPath(transitions, resultArtifactPath) {
+  if (transitions.length === 0) return transitions;
+  return transitions.map((transition) => ({
+    ...transition,
+    resultArtifactPath: transition.resultArtifactPath ?? resultArtifactPath
+  }));
+}
+function isMissingSprintMetadataError(error) {
+  const maybeCode = error?.code;
+  if (maybeCode === "ENOENT") return true;
+  const message = error instanceof Error ? error.message : String(error);
+  const normalized = message.toLowerCase();
+  return normalized.includes("no such file") || normalized.includes("not found");
+}
+var FAILED_APPLY_REVIEW_REASON = "Apply failed; task returned to review";
+async function reconcileTasksAfterFailedApply(stageResults, logger, stageToTaskMap) {
+  let reconciledCount = 0;
+  const seenTaskIds = /* @__PURE__ */ new Set();
+  for (const stageResult of flattenStageResultEntries(stageResults)) {
+    const taskId = stageToTaskMap?.get(stageResult.stageId) ?? stageResult.stageId;
+    if (seenTaskIds.has(taskId)) continue;
+    seenTaskIds.add(taskId);
+    try {
+      const { yaml: task } = await getTask(taskId);
+      if (task.status === "done" || task.status === "in_progress") {
+        await updateTaskStatus(taskId, "review");
+        await applyTaskTransitionOutcome(taskId, {
+          targetStatus: "review",
+          reason: FAILED_APPLY_REVIEW_REASON
+        });
+        reconciledCount++;
+      }
+    } catch (error) {
+      logger.log(
+        chalk2.yellow(
+          `Failed to reconcile task ${taskId} after merge failure: ${error instanceof Error ? error.message : String(error)}`
+        )
+      );
+    }
+  }
+  return reconciledCount;
+}
+async function executeSprintWorkflow(config, logger = console) {
+  const integrationBranch = buildRunBranchName("sprint", config.workflowId);
+  if (config.mergeOptions?.repairBiome !== void 0 || config.mergeOptions?.repairBiomeMaxIterations !== void 0 || config.mergeOptions?.repairBiomeTimeboxMs !== void 0) {
+    logger.log(
+      chalk2.yellow(
+        "Warning: merge-time Biome repair options are deprecated and have no effect; repair runs before application."
+      )
+    );
+  }
+  const preflightSummary = await runSprintWorkflowPreflight(config);
+  if (!preflightSummary.passed) {
+    return {
+      status: "error",
+      executionResult: buildFailedExecutionResult(preflightSummary)
+    };
+  }
+  const invariant = await enforceExecutionPolicyStamp(config, logger);
+  if (!invariant.passed) {
+    return {
+      status: "error",
+      executionResult: buildFailedExecutionResult({
+        passed: false,
+        workflowName: preflightSummary.workflowName,
+        stageCount: preflightSummary.stageCount,
+        plannedStageCount: preflightSummary.plannedStageCount,
+        warnings: preflightSummary.warnings,
+        errors: [invariant.error ?? "Execution policy stamp invariant failed"]
+      })
+    };
+  }
+  if (config.apply) {
+    try {
+      await activateSprint(config.sprintId);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      let sprintIsActive = false;
+      try {
+        const currentSprint = await getCurrentSprint();
+        sprintIsActive = currentSprint?.yaml?.id === config.sprintId && currentSprint.yaml.status === "active";
+      } catch {
+      }
+      if (!sprintIsActive) {
+        logger.error(
+          chalk2.red(
+            `[sprint-execution] WARN: activateSprint(${config.sprintId}) failed and sprint is not active \u2014 sprint status may be stale: ${message}`
+          )
+        );
+      } else {
+        logger.log(chalk2.yellow(`Failed to activate sprint ${config.sprintId}: ${message}`));
+      }
+    }
+  }
+  const lifecycleAwaitDrain = config.lifecycleAwaitDrain ?? config.lifecycleCallbacks?.awaitDrain;
+  const awaitDrain = typeof lifecycleAwaitDrain === "function" ? lifecycleAwaitDrain : void 0;
+  const callerCheckout = await captureCallerCheckoutSnapshot();
+  let executionResult;
+  try {
+    executionResult = await executeWorkflowFile(config.yamlPath, {
+      verbose: config.verbose,
+      dryRun: false,
+      allowMain: config.mergeOptions?.allowMain,
+      allowProtected: config.mergeOptions?.allowProtected,
+      currentBranch: config.applyTargetBranch,
+      workflowId: config.workflowId,
+      resumeWorkflowId: config.resumeWorkflowId,
+      admittedResume: config.admittedResume,
+      executionContext: preflightSummary.executionContext,
+      preflight: {
+        authProbeEnv: { ...process.env, ...getExecutionContext().envOverrides },
+        ...config.preflight ?? {},
+        skip: {
+          ...config.preflight?.skip ?? {},
+          repoClean: true
+        }
+      },
+      skipPreflight: false,
+      manifest: {
+        sourceType: "sprint",
+        sprintId: config.sprintId,
+        taskIds: config.taskIds,
+        generatedYamlPath: config.yamlPath,
+        originalCommand: process.argv.slice(2),
+        planArtifactPath: config.planArtifactPath
+      },
+      lifecycleCallbacks: config.lifecycleCallbacks,
+      blockerAnswers: config.blockerAnswers,
+      repairOnVerifyFailure: config.repairOnVerifyFailure,
+      competitionPerVariantTimeoutMinutes: config.competitionPerVariantTimeoutMinutes,
+      preserveFailedStageWork: config.mergeOptions?.keepArtifacts === true,
+      keepWorkOnProviderFailure: config.keepWorkOnProviderFailure,
+      onProviderOutput: config.onProviderOutput,
+      signal: config.signal
+    });
+  } finally {
+    if (typeof awaitDrain === "function") {
+      await awaitDrain();
+    }
+  }
+  const callerCheckoutRestoreError = await restoreCallerCheckoutIfNeeded(callerCheckout);
+  if (callerCheckoutRestoreError) {
+    logger.error(chalk2.red(callerCheckoutRestoreError));
+    return {
+      status: "error",
+      executionResult: {
+        ...executionResult,
+        success: false,
+        errors: [...executionResult.errors, callerCheckoutRestoreError]
+      }
+    };
+  }
+  if (preflightSummary.warnings.length > 0) {
+    executionResult.warnings = [...preflightSummary.warnings, ...executionResult.warnings];
+  }
+  const effectiveVerificationPolicy = config.verificationPolicy ?? "blocking";
+  executionResult.verificationPolicy = effectiveVerificationPolicy;
+  const rawInjectedTransitions = config.recordedTransitions && config.recordedTransitions.size > 0 ? Array.from(config.recordedTransitions.values()) : await buildFallbackTaskTransitions(
+    config.sprintId,
+    executionResult.stageResults,
+    config.apply,
+    config.stageToTaskMap,
+    config.yamlPath
+  );
+  const resultPath = getResultPath(config.workflowId);
+  const resultArtifactPath = path2.relative(findRepoRoot(), resultPath) || resultPath;
+  const injectedTransitions = config.mergeOptions?.keepArtifacts === true ? attachResultArtifactPath(rawInjectedTransitions, resultArtifactPath) : rawInjectedTransitions;
+  if (injectedTransitions.length > 0) {
+    executionResult.taskTransitions = injectedTransitions;
+    if (executionResult.stageResults.length > 0) {
+      const firstResult = executionResult.stageResults[0];
+      if (firstResult) {
+        firstResult.taskTransitions = injectedTransitions;
+      }
+    }
+  }
+  try {
+    const tmpPath = `${resultPath}.tmp.${process.pid}.${Date.now()}`;
+    await fs.writeFile(tmpPath, JSON.stringify(executionResult, null, 2), "utf-8");
+    await fs.rename(tmpPath, resultPath);
+  } catch (error) {
+    logger.log(
+      chalk2.yellow(
+        `Failed to persist workflow result: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+  let manifest;
+  try {
+    manifest = await updateManifest(config.workflowId, (currentManifest) => {
+      currentManifest.verificationPolicy = effectiveVerificationPolicy;
+    });
+  } catch (error) {
+    logger.log(
+      chalk2.yellow(
+        `Failed to persist workflow manifest policy for ${config.workflowId}: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+    manifest = await loadManifest(config.workflowId).catch((loadError) => {
+      logger.log(
+        chalk2.yellow(
+          `Failed to load workflow manifest metadata for ${config.workflowId}: ${loadError instanceof Error ? loadError.message : String(loadError)}`
+        )
+      );
+      return null;
+    });
+  }
+  const reviewBaseSha = manifest?.baseSha ?? "HEAD";
+  const reviewBranch = manifest?.integrationBranch ?? integrationBranch;
+  if (!config.apply && executionResult.success && config.mergeOptions?.keepArtifacts === true && injectedTransitions.length > 0) {
+    const syncResult = await applyTaskTransitions(config.sprintId, injectedTransitions, {
+      promoteToDone: true
+    });
+    if (syncResult.tasksFailed > 0 || syncResult.tasksEphemeral > 0) {
+      const message = `Task status sync failed after preserved no-apply run: ${syncResult.tasksFailed} failed, ${syncResult.tasksEphemeral} ephemeral`;
+      logger.error(chalk2.red(message));
+      return {
+        status: "error",
+        executionResult: {
+          ...executionResult,
+          success: false,
+          errors: [...executionResult.errors, message]
+        },
+        reviewBaseSha,
+        reviewBranch
+      };
+    }
+  } else if (!config.apply && executionResult.success) {
+    logger.log(
+      chalk2.yellow(
+        "Warning: --no-apply completed without --keep-artifacts; task status and result artifact provenance were not synced."
+      )
+    );
+  }
+  if (config.apply && executionResult.success) {
+    if (config.mergeOptions?.noRepairOnFindings) {
+      const failingStages = executionResult.stageResults.filter(
+        (r) => r.validationPassed === false
+      );
+      if (failingStages.length > 0) {
+        logger.error(chalk2.red("\nVerification failures detected"));
+        logger.log(chalk2.red("--no-repair-on-findings is set. Blocking --apply."));
+        await persistExecutionTelemetryIfConfigured({
+          config,
+          executionResult: {
+            ...executionResult,
+            success: false,
+            errors: [
+              ...executionResult.errors,
+              "--no-repair-on-findings blocked apply because verification failures were present."
+            ]
+          },
+          verificationPolicy: effectiveVerificationPolicy,
+          logger
+        });
+        return {
+          status: "error",
+          executionResult,
+          reviewBaseSha,
+          reviewBranch
+        };
+      }
+    }
+    await persistExecutionTelemetryIfConfigured({
+      config,
+      executionResult,
+      verificationPolicy: effectiveVerificationPolicy,
+      logger
+    });
+    const shouldCleanupAfterApply = config.mergeOptions?.cleanup === true || config.closeSprint && config.mergeOptions?.keepArtifacts !== true;
+    const mergeResult = await mergeWorkflowResult({
+      workflowId: config.workflowId,
+      force: false,
+      applyOnly: config.mergeOptions?.applyOnly,
+      keepArtifacts: config.mergeOptions?.keepArtifacts,
+      allowMain: config.mergeOptions?.allowMain,
+      allowProtected: config.mergeOptions?.allowProtected,
+      taskStatus: "apply",
+      cleanup: shouldCleanupAfterApply
+    });
+    if (!mergeResult.success) {
+      if (executionResult.success) {
+        const reconciledCount = await reconcileTasksAfterFailedApply(
+          executionResult.stageResults,
+          logger,
+          config.stageToTaskMap
+        );
+        if (reconciledCount > 0) {
+          logger.log(
+            chalk2.yellow(
+              `Reconciled ${reconciledCount} task status(es) back to review after merge failure`
+            )
+          );
+        }
+      }
+      logger.error(chalk2.red("\nMerge failed"));
+      if (mergeResult.error) {
+        logger.log(chalk2.red(`  ${mergeResult.error}`));
+      }
+      await persistExecutionTelemetryIfConfigured({
+        config,
+        executionResult: {
+          ...executionResult,
+          success: false,
+          errors: [
+            ...executionResult.errors,
+            `Merge failed${mergeResult.error ? `: ${mergeResult.error}` : ""}`
+          ]
+        },
+        verificationPolicy: effectiveVerificationPolicy,
+        logger
+      });
+      return {
+        status: "error",
+        executionResult,
+        mergeResult,
+        reviewBaseSha,
+        reviewBranch
+      };
+    }
+    logger.log(chalk2.green("Results merged into current branch"));
+    if (mergeResult.postApplyError) {
+      logger.log(chalk2.yellow(`Post-apply cleanup warning: ${mergeResult.postApplyError}`));
+    }
+    let distStale = false;
+    const selfScope = resolveBuildSelfExecutionScope({ root: process.cwd() });
+    if (selfScope.status === "pass") {
+      try {
+        const distIndex = path2.join(process.cwd(), "dist", "index.js");
+        await import("fs/promises").then((fs2) => fs2.access(distIndex));
+        const srcCheck = await execa(
+          "find",
+          ["src", "-name", "*.ts", "-newer", distIndex, "-print", "-quit"],
+          { stdio: "pipe", timeout: 5e3, reject: false }
+        );
+        if (srcCheck.stdout?.trim()) {
+          distStale = true;
+          logger.log("");
+          logger.log(chalk2.yellow("Source files are newer than dist/ \u2014 CLI may be stale"));
+          logger.log(
+            chalk2.dim("  Run `npm run build` to update the CLI after this command exits.")
+          );
+        }
+      } catch {
+      }
+    }
+    let closeout = { closed: false };
+    if (config.closeSprint) {
+      closeout = await closeSprintAfterApply(config, logger);
+    }
+    return {
+      status: closeout.error ? "error" : "success",
+      executionResult,
+      mergeResult,
+      sprintClosed: closeout.closed,
+      reviewBaseSha,
+      reviewBranch,
+      distStale
+    };
+  }
+  if (config.apply && !executionResult.success) {
+    const reconciledCount = await reconcileTasksAfterFailedApply(
+      executionResult.stageResults,
+      logger,
+      config.stageToTaskMap
+    );
+    if (reconciledCount > 0) {
+      logger.log(
+        chalk2.yellow(
+          `Reconciled ${reconciledCount} task status(es) back to review after failed apply`
+        )
+      );
+    }
+  }
+  await persistExecutionTelemetryIfConfigured({
+    config,
+    executionResult,
+    verificationPolicy: effectiveVerificationPolicy,
+    logger
+  });
+  return {
+    status: executionResult.success ? "success" : "error",
+    executionResult,
+    reviewBaseSha,
+    reviewBranch
+  };
+}
+function isOrchestratorStageResult(result) {
+  return typeof result === "object" && result !== null && result.stageType === "orchestrator" && Array.isArray(result.subStageResults);
+}
+function buildSubStageTelemetry(result) {
+  return {
+    validationPassed: result.result.validationPassed,
+    cost: result.result.cost,
+    provider: result.result.provider,
+    model: result.result.model,
+    resolvedModel: result.result.resolvedModel,
+    summary: result.result.summary,
+    durationMs: result.result.durationMs,
+    changedFilesCount: result.result.changedFilesCount ?? result.result.changedFiles?.length,
+    changedFiles: result.result.changedFiles,
+    completeness: result.result.completeness,
+    completenessSource: result.result.completenessSource,
+    verifyCommands: result.result.verifyCommands,
+    requiredFiles: result.result.requiredFiles,
+    missingRequiredFiles: result.result.missingRequiredFiles,
+    untouchedRequiredFiles: result.result.untouchedRequiredFiles,
+    intentionalNoOp: result.result.intentionalNoOp,
+    warnings: result.result.warnings,
+    recovery: result.result.recovery,
+    provenance: result.result.provenance,
+    modelSelectionSource: result.result.modelSelectionSource,
+    ...unverifiedStageField(result.result)
+  };
+}
+function deriveExecutionExitReason(result) {
+  if (result.success && result.degraded) {
+    return "success-degraded";
+  }
+  if (result.success) {
+    return "success";
+  }
+  if (result.errors.length > 0) {
+    return result.errors[0] ?? "workflow-error";
+  }
+  if (result.stageResults.some((stage) => !stage.validationPassed)) {
+    return "stage-validation-failed";
+  }
+  return "workflow-failed";
+}
+function deriveExecutionMetadata(payload, executionResult, updatedAt) {
+  const stageExecutionDetails = executionResult.stageResults.flatMap((stage) => {
+    if (isOrchestratorStageResult(stage)) {
+      return stage.subStageResults.map((subStage) => ({
+        provider: subStage.result.provider,
+        model: subStage.result.model,
+        resolvedModel: subStage.result.resolvedModel
+      }));
+    }
+    return [
+      {
+        provider: stage.provider,
+        model: stage.model,
+        resolvedModel: stage.resolvedModel
+      }
+    ];
+  });
+  const usedProviders = Array.from(
+    new Set(
+      stageExecutionDetails.map((stage) => stage.provider).filter(
+        (provider) => typeof provider === "string" && provider.length > 0
+      )
+    )
+  );
+  const resolvedModels = Array.from(
+    new Set(
+      stageExecutionDetails.map((stage) => stage.resolvedModel).filter((model) => typeof model === "string" && model.length > 0)
+    )
+  );
+  const usedModels = Array.from(
+    new Set(
+      stageExecutionDetails.map((stage) => stage.resolvedModel ?? stage.model).filter((model) => typeof model === "string" && model.length > 0)
+    )
+  );
+  return {
+    provider: payload.executionDefaults.provider,
+    resolvedModel: (resolvedModels.length === 1 ? resolvedModels[0] : void 0) || payload.executionDefaults.model || (usedModels.length === 1 ? usedModels[0] : void 0) || payload.orchestratorConfig.orchestrationModel || void 0,
+    usedProviders: usedProviders.length > 0 ? usedProviders : void 0,
+    usedModels: usedModels.length > 0 ? usedModels : void 0,
+    durationMs: executionResult.totalDuration,
+    totalCost: executionResult.totalCost,
+    success: executionResult.success,
+    exitReason: deriveExecutionExitReason(executionResult),
+    warnings: executionResult.warnings.length > 0 ? executionResult.warnings : void 0,
+    errors: executionResult.errors.length > 0 ? executionResult.errors : void 0,
+    updatedAt
+  };
+}
+function recordPlanExecutionHistory(params) {
+  const provider = params.payload.orchestratorConfig.orchestrationProvider?.trim() || params.payload.executionDefaults.provider?.trim();
+  const estimatedDurationMs = params.payload.plan.estimatedDurationMs;
+  const actualDurationMs = params.executionResult.totalDuration;
+  if (!provider || estimatedDurationMs <= 0 || actualDurationMs <= 0) {
+    return;
+  }
+  const stageRetryCount = params.orchestratorResult?.subStageResults.reduce(
+    (sum, subStageResult) => sum + (subStageResult.result.recovery?.retryBudgetUsed ?? 0) + (subStageResult.result.recovery?.infrastructureRetryBudgetUsed ?? 0),
+    0
+  ) ?? 0;
+  const retryCount = stageRetryCount + (params.orchestratorResult?.replanningAttempts ?? 0);
+  const isCompetitive = params.payload.plan.subStages.some(
+    (subStage) => subStage.type === "competition"
+  );
+  const model = params.payload.executionDefaults.model?.trim() || params.payload.orchestratorConfig.orchestrationModel?.trim() || void 0;
+  recordExecution({
+    provider,
+    model,
+    executionMode: "orchestrator",
+    parallelism: params.payload.plan.subStages.length,
+    outcome: deriveSprintOutcome(params.executionResult),
+    estimatorVersion: RUNTIME_ESTIMATOR_VERSION,
+    expectedRuntimeMs: estimatedDurationMs,
+    stageCount: params.payload.plan.subStages.length,
+    retryCount,
+    isCompetitive,
+    actualDurationMs,
+    estimatedDurationMs,
+    completedAt: Date.now()
+  });
+}
+function deriveSprintOutcome(executionResult) {
+  if (!executionResult.success) return "failed";
+  return executionResult.degraded ? "degraded" : "success";
+}
+async function persistExecutionTelemetryIfConfigured(params) {
+  if (!params.config.planArtifactPath) {
+    return;
+  }
+  await persistPlanExecutionTelemetry({
+    planArtifactPath: params.config.planArtifactPath,
+    workflowId: params.config.workflowId,
+    sprintId: params.config.sprintId,
+    executionResult: params.executionResult,
+    verificationPolicy: params.verificationPolicy,
+    logger: params.logger
+  });
+}
+async function persistPlanExecutionTelemetry(params) {
+  try {
+    const rootDir = findRepoRoot();
+    await withPlanningLock(rootDir, async () => {
+      const absolutePath = path2.resolve(rootDir, params.planArtifactPath);
+      const raw = await fs.readFile(absolutePath, "utf-8");
+      const envelope = parsePlanArtifactEnvelope(JSON.parse(raw));
+      const payload = parseDecompositionPlanArtifactPayload(envelope.payload);
+      const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const orchestratorResult = params.executionResult.stageResults.find(isOrchestratorStageResult);
+      if (orchestratorResult) {
+        const subStageTelemetryById = new Map(
+          orchestratorResult.subStageResults.map((subStageResult) => [
+            subStageResult.spec.id,
+            buildSubStageTelemetry(subStageResult)
+          ])
+        );
+        payload.plan.subStages = payload.plan.subStages.map((subStage) => {
+          const telemetry = subStageTelemetryById.get(subStage.id);
+          if (!telemetry) {
+            return subStage;
+          }
+          return {
+            ...subStage,
+            actualCost: telemetry.cost,
+            actualDurationMs: telemetry.durationMs,
+            result: telemetry
+          };
+        });
+        payload.plan.executionSummary = {
+          workflowId: params.workflowId,
+          sprintId: params.sprintId,
+          updatedAt,
+          validationPassed: orchestratorResult.validationPassed,
+          verificationPolicy: params.verificationPolicy,
+          successfulSubStages: orchestratorResult.successfulSubStages,
+          ...unverifiedCountField(orchestratorResult.subStageResults.map((sub) => sub.result)),
+          totalSubStages: orchestratorResult.totalSubStages,
+          orchestrationCost: orchestratorResult.orchestrationCost,
+          totalCostWithOrchestration: orchestratorResult.totalCostWithOrchestration,
+          replanningTriggered: orchestratorResult.replanningTriggered,
+          replanningAttempts: orchestratorResult.replanningAttempts,
+          zeroOutput: orchestratorResult.zeroOutput,
+          recovery: orchestratorResult.recovery
+        };
+      } else {
+        const stageResultById = new Map(
+          params.executionResult.stageResults.map((sr) => [sr.stageId, sr])
+        );
+        payload.plan.subStages = payload.plan.subStages.map((subStage) => {
+          const sr = stageResultById.get(subStage.id);
+          if (!sr) {
+            return subStage;
+          }
+          const telemetry = buildSubStageTelemetry({ result: sr });
+          return {
+            ...subStage,
+            actualCost: sr.cost,
+            actualDurationMs: sr.durationMs,
+            result: telemetry
+          };
+        });
+        const stageResults = params.executionResult.stageResults;
+        const successCount = stageResults.filter((r) => r.validationPassed).length;
+        const totalCost = stageResults.reduce((sum, r) => sum + r.cost, 0);
+        payload.plan.executionSummary = {
+          workflowId: params.workflowId,
+          sprintId: params.sprintId,
+          updatedAt,
+          validationPassed: params.executionResult.success,
+          verificationPolicy: params.verificationPolicy,
+          successfulSubStages: successCount,
+          ...unverifiedCountField(stageResults),
+          totalSubStages: stageResults.length,
+          orchestrationCost: 0,
+          totalCostWithOrchestration: totalCost
+        };
+      }
+      payload.executionMetadata = deriveExecutionMetadata(
+        payload,
+        params.executionResult,
+        updatedAt
+      );
+      const tmpPath = `${absolutePath}.tmp-${process.pid}-${Date.now()}`;
+      await fs.writeFile(
+        tmpPath,
+        JSON.stringify(
+          {
+            ...envelope,
+            payload
+          },
+          null,
+          2
+        ),
+        "utf-8"
+      );
+      await fs.rename(tmpPath, absolutePath);
+      try {
+        recordPlanExecutionHistory({
+          payload,
+          executionResult: params.executionResult,
+          orchestratorResult
+        });
+      } catch {
+      }
+    });
+  } catch (error) {
+    params.logger.log(
+      chalk2.yellow(
+        `Failed to persist plan execution telemetry: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+
+export {
+  goalGapId,
+  PRIOR_ATTEMPTS_RETAINED,
+  truncatePriorAttempts,
+  structureLegacyGaps,
+  removeDuplicateVerifyGaps,
+  removeDuplicateVerifyReasons,
+  blockingGapsUnsatisfied,
+  downgradeGapsToAdvisory,
+  capDiff,
+  verifyResultToGateCheck,
+  toDecompositionPlanArtifactPayload,
+  parseDecompositionPlanArtifactPayload,
+  enforceExecutionPolicyStamp,
+  workflowHasTaskExecutionStages,
+  executeSprintWorkflow
+};
+//# sourceMappingURL=chunk-FYMRVUNZ.js.map