@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-RSXSD4MH.js

@@ -0,0 +1,1016 @@
+import {
+  recordExecution
+} from "./chunk-RHVG6UNL.js";
+import {
+  RUNTIME_ESTIMATOR_VERSION
+} from "./chunk-CE5OZBYY.js";
+import {
+  resolveTaskStatusForStageOutcome
+} from "./chunk-D5EP5D2W.js";
+import {
+  parseDecompositionPlanArtifactPayload
+} from "./chunk-DCAVAABI.js";
+import {
+  applyTaskTransitions,
+  mergeWorkflowResult
+} from "./chunk-CVMVZWG4.js";
+import {
+  parsePlanArtifactEnvelope
+} from "./chunk-A2WKSVX7.js";
+import {
+  WorkflowExecutor,
+  executeWorkflowFile,
+  filterResolvedManagedRepoCleanWarnings
+} from "./chunk-EX3OM35G.js";
+import {
+  getTask,
+  updateTaskStatus
+} from "./chunk-SUZ7UYZH.js";
+import {
+  runWorkflowPreflight
+} from "./chunk-V6YLL5WA.js";
+import {
+  resolvePoeticSelfExecutionScope
+} from "./chunk-MFADRRTR.js";
+import {
+  describeExecutionPolicyStampMismatch,
+  isCurrentExecutionPolicyWorkflow,
+  isExecutionPolicyEngaged
+} from "./chunk-PIKLF7BM.js";
+import {
+  resolveExecutionRoles
+} from "./chunk-7NPSXSHO.js";
+import {
+  activateSprint,
+  closeSprint,
+  getCurrentSprint,
+  listTasksInSprint
+} from "./chunk-XUSRFFA7.js";
+import {
+  withPlanningLock
+} from "./chunk-OPYFYTWQ.js";
+import {
+  getResultPath,
+  loadManifest,
+  updateManifest
+} from "./chunk-CQM3A35X.js";
+import {
+  signalCoordinator
+} from "./chunk-72YTZMAM.js";
+import {
+  getWorktreeBaseDir
+} from "./chunk-5EERLVZB.js";
+import {
+  getExecutionContext
+} from "./chunk-UI2F6DJ5.js";
+import {
+  findRepoRoot
+} from "./chunk-L7JZLXQL.js";
+
+// src/planning/sprint-execution-service.ts
+import fs from "fs/promises";
+import path from "path";
+import chalk from "chalk";
+import { execa } from "execa";
+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)}). Regenerate the workflow through the current Poetic version.`
+    };
+  }
+  if (config.allowUnstampedWorkflow === true) {
+    logger.log(chalk.yellow("running hand-authored workflow without execution policy"));
+    return { passed: true };
+  }
+  if (!workflowHasTaskExecutionStages(workflow)) {
+    return { passed: true };
+  }
+  let gate = "off";
+  try {
+    const roles = resolveExecutionRoles({ cwd: process.cwd() });
+    if (!isExecutionPolicyEngaged(roles)) {
+      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 \`poetic sprint run\` / \`poetic 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.`
+  };
+}
+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-Z4Y64V3I.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 buildFallbackTaskTransitions(sprintId, stageResults, apply, stageToTaskMap) {
+  if (signalCoordinator.isShuttingDown) {
+    return [];
+  }
+  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;
+  };
+  for (const stageResult of flattenStageResultEntries(stageResults)) {
+    const taskId = maybeTaskIdForStage(stageResult.stageId);
+    if (taskId && stageResult.validationPassed === true) {
+      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");
+}
+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") {
+        await updateTaskStatus(taskId, "review");
+        reconciledCount++;
+        continue;
+      }
+      if (task.status === "in_progress") {
+        await updateTaskStatus(taskId, "review");
+        reconciledCount++;
+      }
+    } catch (error) {
+      logger.log(
+        chalk.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 = `poetic/flywheel/${config.workflowId}`;
+  if (config.mergeOptions?.repairBiome !== void 0 || config.mergeOptions?.repairBiomeMaxIterations !== void 0 || config.mergeOptions?.repairBiomeTimeboxMs !== void 0) {
+    logger.log(
+      chalk.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(
+          chalk.red(
+            `[sprint-execution] WARN: activateSprint(${config.sprintId}) failed and sprint is not active \u2014 sprint status may be stale: ${message}`
+          )
+        );
+      } else {
+        logger.log(chalk.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,
+        generatedYamlPath: config.yamlPath,
+        originalCommand: process.argv.slice(2),
+        planArtifactPath: config.planArtifactPath
+      },
+      lifecycleCallbacks: config.lifecycleCallbacks,
+      blockerAnswers: config.blockerAnswers,
+      repairOnVerifyFailure: config.repairOnVerifyFailure,
+      onProviderOutput: config.onProviderOutput,
+      signal: config.signal
+    });
+  } finally {
+    if (typeof awaitDrain === "function") {
+      await awaitDrain();
+    }
+  }
+  const callerCheckoutRestoreError = await restoreCallerCheckoutIfNeeded(callerCheckout);
+  if (callerCheckoutRestoreError) {
+    logger.error(chalk.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
+  );
+  const resultPath = getResultPath(config.workflowId);
+  const resultArtifactPath = path.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(
+      chalk.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(
+      chalk.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(
+        chalk.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(chalk.red(message));
+      return {
+        status: "error",
+        executionResult: {
+          ...executionResult,
+          success: false,
+          errors: [...executionResult.errors, message]
+        },
+        reviewBaseSha,
+        reviewBranch
+      };
+    }
+  } else if (!config.apply && executionResult.success) {
+    logger.log(
+      chalk.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(chalk.red("\nVerification failures detected"));
+        logger.log(chalk.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(
+            chalk.yellow(
+              `Reconciled ${reconciledCount} task status(es) back to review after merge failure`
+            )
+          );
+        }
+      }
+      logger.error(chalk.red("\nMerge failed"));
+      if (mergeResult.error) {
+        logger.log(chalk.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(chalk.green("Results merged into current branch"));
+    if (mergeResult.postApplyError) {
+      logger.log(chalk.yellow(`Post-apply cleanup warning: ${mergeResult.postApplyError}`));
+    }
+    let distStale = false;
+    const selfScope = resolvePoeticSelfExecutionScope({ root: process.cwd() });
+    if (selfScope.status === "pass") {
+      try {
+        const distIndex = path.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(chalk.yellow("Source files are newer than dist/ \u2014 CLI may be stale"));
+          logger.log(
+            chalk.dim("  Run `npm run build` to update the CLI after this command exits.")
+          );
+        }
+      } catch {
+      }
+    }
+    let sprintClosed = false;
+    if (config.closeSprint) {
+      sprintClosed = await tryCloseSprint(config, logger);
+    }
+    return {
+      status: "success",
+      executionResult,
+      mergeResult,
+      sprintClosed,
+      reviewBaseSha,
+      reviewBranch,
+      distStale
+    };
+  }
+  await persistExecutionTelemetryIfConfigured({
+    config,
+    executionResult,
+    verificationPolicy: effectiveVerificationPolicy,
+    logger
+  });
+  return {
+    status: executionResult.success ? "success" : "error",
+    executionResult,
+    reviewBaseSha,
+    reviewBranch
+  };
+}
+async function tryCloseSprint(config, logger) {
+  try {
+    const tasks = await listTasksInSprint(config.sprintId);
+    const allTerminal = tasks.length === 0 || tasks.every((t) => t.status === "done" || t.status === "blocked" || t.status === "cancelled");
+    const allDone = tasks.length > 0 && tasks.every((t) => t.status === "done");
+    if (allTerminal) {
+      logger.log(chalk.cyan("Closing sprint..."));
+      await closeSprint(config.sprintId, {
+        force: !allDone,
+        // force if some tasks are blocked but all are terminal
+        noArchive: false,
+        dryRun: false
+      });
+      const doneCount = tasks.filter((t) => t.status === "done").length;
+      const blockedCount = tasks.filter((t) => t.status === "blocked").length;
+      const cancelledCount = tasks.filter((t) => t.status === "cancelled").length;
+      logger.log(
+        chalk.green(
+          `Sprint ${config.sprintId} closed (${doneCount} done` + (blockedCount > 0 ? `, ${blockedCount} blocked` : "") + (cancelledCount > 0 ? `, ${cancelledCount} cancelled` : "") + ")"
+        )
+      );
+      if (config.archiveBacklog && config.archiveLinkedBacklogItems) {
+        try {
+          const linked = await config.archiveLinkedBacklogItems(config.sprintId, {
+            dryRun: false
+          });
+          if (linked.archived.length > 0) {
+            logger.log(chalk.green(`Archived ${linked.archived.length} linked backlog item(s)`));
+          } else {
+            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}`));
+          }
+        } catch (error) {
+          logger.log(
+            chalk.yellow(
+              `Failed to archive linked backlog items: ${error instanceof Error ? error.message : String(error)}`
+            )
+          );
+        }
+      }
+      return true;
+    }
+    logger.log(chalk.yellow("Sprint not ready to close (not all tasks are terminal)"));
+    const incompleteTasks = tasks.filter(
+      (t) => t.status !== "done" && t.status !== "blocked" && t.status !== "cancelled"
+    );
+    if (incompleteTasks.length > 0) {
+      logger.log(chalk.dim("Non-terminal tasks:"));
+      for (const t of incompleteTasks) {
+        logger.log(chalk.dim(`  - ${t.id}: ${t.title} (${t.status})`));
+      }
+    }
+    return false;
+  } catch (error) {
+    logger.log(chalk.yellow("Failed to close sprint:"));
+    logger.log(chalk.yellow(`  ${error instanceof Error ? error.message : String(error)}`));
+    return false;
+  }
+}
+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
+  };
+}
+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 = path.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,
+          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 = {
+            validationPassed: sr.validationPassed,
+            cost: sr.cost,
+            provider: sr.provider,
+            model: sr.model,
+            resolvedModel: sr.resolvedModel,
+            summary: sr.summary,
+            durationMs: sr.durationMs,
+            changedFilesCount: sr.changedFilesCount ?? sr.changedFiles?.length,
+            changedFiles: sr.changedFiles,
+            completeness: sr.completeness,
+            completenessSource: sr.completenessSource,
+            verifyCommands: sr.verifyCommands,
+            requiredFiles: sr.requiredFiles,
+            missingRequiredFiles: sr.missingRequiredFiles,
+            untouchedRequiredFiles: sr.untouchedRequiredFiles,
+            intentionalNoOp: sr.intentionalNoOp,
+            warnings: sr.warnings,
+            recovery: sr.recovery,
+            provenance: sr.provenance,
+            modelSelectionSource: sr.modelSelectionSource
+          };
+          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,
+          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(
+      chalk.yellow(
+        `Failed to persist plan execution telemetry: ${error instanceof Error ? error.message : String(error)}`
+      )
+    );
+  }
+}
+
+export {
+  enforceExecutionPolicyStamp,
+  workflowHasTaskExecutionStages,
+  executeSprintWorkflow
+};
+//# sourceMappingURL=chunk-RSXSD4MH.js.map