@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-YTVVTIWJ.js

@@ -0,0 +1,716 @@
+import {
+  REVIEW_INSPECTION_RULE
+} from "./chunk-HBZ322WZ.js";
+import {
+  EXECUTION_CONTRACT_STRUCTURED_ID
+} from "./chunk-R2W3LESH.js";
+import {
+  appendNativeSubagentGuidance,
+  removeNativeSubagentGuidance
+} from "./chunk-7SEWU4QG.js";
+import {
+  extractAcceptanceCriteria
+} from "./chunk-XON4ZCYX.js";
+import {
+  DEFAULT_ORCHESTRATOR_MAX_SUB_STAGES
+} from "./chunk-EJVCDTAN.js";
+import {
+  parseReviewPolicy,
+  reviewPolicyBlocks,
+  reviewPolicyFromLegacy,
+  reviewPolicyRepairs
+} from "./chunk-7RMARDVH.js";
+import {
+  getProviderRuntimeQuirks
+} from "./chunk-Y733RB7T.js";
+import {
+  getCapability
+} from "./chunk-QJ6OEH4K.js";
+import {
+  normalizeReasoningEffortInput
+} from "./chunk-4BTDUT2S.js";
+
+// src/automation/execution-policy-applier.ts
+import { createHash } from "crypto";
+
+// src/automation/execution-policy-substage-budget.ts
+function widenSeededSubStageBudget(orchestrator, injectedSubStageCount) {
+  const ceiling = orchestrator?.maxSubStages ?? DEFAULT_ORCHESTRATOR_MAX_SUB_STAGES;
+  if (ceiling >= injectedSubStageCount) return orchestrator;
+  return {
+    ...orchestrator,
+    maxSubStages: injectedSubStageCount,
+    plannedSubStageCeiling: orchestrator?.plannedSubStageCeiling ?? ceiling
+  };
+}
+
+// src/automation/review-acceptance-criteria.ts
+function isCriteriaList(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string" && entry.trim().length > 0);
+}
+function resolveReviewAcceptanceCriteria(stage) {
+  if (stage.templateVariables && Object.hasOwn(stage.templateVariables, "reviewAcceptanceCriteria")) {
+    const criteria = stage.templateVariables.reviewAcceptanceCriteria;
+    if (!isCriteriaList(criteria))
+      throw new Error("reviewAcceptanceCriteria must be an array of nonempty strings");
+    return [...criteria];
+  }
+  return extractAcceptanceCriteria(stage.prompt ?? "", { checkboxFallback: false });
+}
+function hasLegacyReviewAcceptancePrompt(stage, diffOutputName, reviewerPrompt) {
+  return !Object.hasOwn(stage.templateVariables ?? {}, "reviewAcceptanceCriteria") && resolveReviewAcceptanceCriteria(stage).length > 0 && reviewerPrompt === buildReviewerPrompt(stage.id, diffOutputName);
+}
+function encodeReviewAcceptanceCriteria(criteria) {
+  return Buffer.from(JSON.stringify(criteria), "utf8").toString("base64url");
+}
+function decodeReviewAcceptanceCriteria(encoded) {
+  if (!/^[A-Za-z0-9_-]+$/.test(encoded))
+    throw new Error("acceptance criteria must be base64url-encoded JSON");
+  const bytes = Buffer.from(encoded, "base64url");
+  if (bytes.toString("base64url") !== encoded)
+    throw new Error("acceptance criteria encoding is malformed");
+  const criteria = JSON.parse(bytes.toString("utf8"));
+  if (!isCriteriaList(criteria))
+    throw new Error("acceptance criteria must decode to an array of nonempty strings");
+  return criteria;
+}
+function assessReviewAcceptanceCriteria(raw, expected) {
+  const invalid = (untrustedReason) => ({ rows: [], untrustedReason });
+  if (!Array.isArray(raw)) return invalid("reviewer omitted the expected acceptance criteria rows");
+  const expectedById = new Map(expected.map((criterion, index) => [`AC${index + 1}`, criterion]));
+  const rowsById = /* @__PURE__ */ new Map();
+  for (const entry of raw) {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry))
+      return invalid("malformed acceptance criterion row");
+    const row = entry;
+    if (typeof row.id !== "string" || !expectedById.has(row.id))
+      return invalid("unexpected acceptance criterion ID");
+    if (rowsById.has(row.id)) return invalid(`duplicate acceptance criterion ${row.id}`);
+    if (row.status !== "met" && row.status !== "not_met" && row.status !== "not_assessable")
+      return invalid(`malformed acceptance criterion status for ${row.id}`);
+    if (typeof row.evidence !== "string" || row.evidence.trim().length === 0)
+      return invalid(`missing acceptance criterion evidence for ${row.id}`);
+    rowsById.set(row.id, {
+      id: row.id,
+      criterion: expectedById.get(row.id),
+      status: row.status,
+      evidence: row.evidence
+    });
+  }
+  const missing = [...expectedById.keys()].filter((id) => !rowsById.has(id));
+  if (missing.length > 0) return invalid(`missing acceptance criteria: ${missing.join(", ")}`);
+  return { rows: [...expectedById.keys()].map((id) => rowsById.get(id)) };
+}
+function buildReviewerPrompt(execId, diffOutputName, criteria = []) {
+  const findingsContract = '{"inspection":"completed"|"unavailable","reason":"<why the inspection was unavailable, omit when completed>","findings":[{"severity":"critical"|"high"|"medium"|"low","file":"<path>","line":<number optional>,"summary":"<one line>","evidence":"<file:line you read, or command you ran, that confirms the claim>"}]}';
+  const contract = criteria.length > 0 ? `${findingsContract.slice(0, -1)},"acceptanceCriteria":[{"id":"AC<n>","status":"met"|"not_met"|"not_assessable","evidence":"<what establishes this assessment or prevents assessment>"}]}` : findingsContract;
+  return [
+    `You are performing a read-only code review of the diff produced by the '${execId}' execution stage.`,
+    "This is a fresh review invocation: do not continue any prior mutation-owning session, and do not modify any files.",
+    `The diff is provided as input artifact '${execId}.${diffOutputName}'.`,
+    "The full post-change repository is checked out read-only in your working directory.",
+    "",
+    "Analyze the diff for correctness bugs, security issues, and clear regressions.",
+    "",
+    "Verification duty:",
+    "- Before reporting a finding that depends on how a called function, helper, resolver, or configuration behaves, open that definition in the checkout and confirm the claim. Do not infer callee behaviour from the diff alone.",
+    "- Report only defects this diff introduces or newly exposes. Do not report behaviour the diff leaves unchanged as a finding.",
+    "- Each finding names the concrete failure: which input or state produces which wrong output, crash, data loss, or exposure.",
+    ...criteria.length > 0 ? [
+      "",
+      "Acceptance criteria assigned to this execution stage:",
+      JSON.stringify(criteria.map((criterion, index) => ({ id: `AC${index + 1}`, criterion }))),
+      "Assess every listed criterion against the delivered work. Report met, not_met, or not_assessable with evidence for each exact ID. Missing evidence is not_assessable, never met.",
+      "Report criterion assessments separately from source findings; do not invent a filename or repair finding for an unmet criterion."
+    ] : [],
+    "",
+    "Respond with ONLY a JSON object matching this exact contract:",
+    contract,
+    "",
+    "Rules:",
+    `- ${REVIEW_INSPECTION_RULE}`,
+    '- "findings" must be an array (empty when you find nothing).',
+    '- "severity" must be one of "critical", "high", "medium", or "low".',
+    '- "evidence" is required for every finding at severity "medium" or above.',
+    "- Emit the JSON object as your entire response; wrapping it in a ```json fenced block is acceptable."
+  ].join("\n");
+}
+
+// src/automation/stage-provider-selection.ts
+function resolveNativeSubagentsTransport(provider) {
+  return getProviderRuntimeQuirks(provider)?.nativeSubagentsDefaultTransport;
+}
+function supportsNativeSubagents(provider) {
+  return getCapability(provider, "provider_native_subagents") === true;
+}
+function executorRoleSelection(before, bound, cliProviderOverride, role) {
+  if (cliProviderOverride || before.provider || before.model || !bound.provider) return void 0;
+  const subagents = role.subagents.value === "off" ? void 0 : role.subagents.value;
+  return {
+    candidates: "provider-order",
+    provider: bound.provider,
+    ...bound.model ? { model: bound.model } : {},
+    ...subagents !== void 0 ? { subagents } : {},
+    ...subagents !== void 0 && before.providerExecutionTransport == null ? { transport: role.transport.value } : {}
+  };
+}
+function automaticProviderSelection(stage, current, unpinned) {
+  const selection = stage.providerSelection;
+  if (selection) {
+    const unchanged = selection.provider === stage.provider && (selection.model ?? "") === (stage.model ?? "");
+    return unchanged ? selection : void 0;
+  }
+  if (stage.provider || stage.model) return void 0;
+  return {
+    candidates: unpinned,
+    provider: current.provider,
+    ...current.model ? { model: current.model } : {}
+  };
+}
+function rebindPromptForProvider(prompt, selection, provider) {
+  if (selection?.subagents === void 0) return prompt;
+  const base = removeNativeSubagentGuidance(prompt);
+  return supportsNativeSubagents(provider) ? appendNativeSubagentGuidance(base, selection.subagents).prompt : base;
+}
+function rebindStageForProvider(stage, target) {
+  const selection = stage.providerSelection;
+  const next = { ...stage, provider: target.provider, model: target.model };
+  if (!selection) return next;
+  next.providerSelection = { ...selection, provider: target.provider, model: target.model };
+  if (stage.prompt !== void 0) {
+    next.prompt = rebindPromptForProvider(stage.prompt, selection, target.provider);
+  }
+  if (selection.transport !== void 0) {
+    next.providerExecutionTransport = supportsNativeSubagents(target.provider) ? selection.transport !== "auto" ? selection.transport : resolveNativeSubagentsTransport(target.provider) ?? "tmux-exec" : void 0;
+  }
+  return next;
+}
+function isStageProviderSelection(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return (record.candidates === "provider-order" || record.candidates === "planning-order") && typeof record.provider === "string" && record.provider.length > 0 && (record.model === void 0 || typeof record.model === "string");
+}
+
+// src/automation/execution-policy-applier.ts
+var EXECUTION_POLICY_STAMP_VERSION = 6;
+function hasCurrentExecutionPolicyStampShape(stamp) {
+  if (!stamp || stamp.applied !== true || stamp.version !== EXECUTION_POLICY_STAMP_VERSION) {
+    return false;
+  }
+  const assurance = stamp.reviewAssurance;
+  const preflight = stamp.preflight;
+  return Boolean(
+    /^[a-f0-9]{16}$/.test(stamp.rolesFingerprint) && assurance && assurance.executorSeparation === "separated" && assurance.invocationSeparation === "required-fresh-readonly" && assurance.invocationSeparationVerified === false && preflight?.executor.provider.trim() && preflight.reviewer.provider.trim() && parseReviewPolicy(preflight.reviewer.policy) !== null && preflight.reviewer.gate !== "off" && ["critical", "high", "medium", "low"].includes(preflight.reviewer.threshold) && preflight.reviewer.sameVendorReview === false && !providerIdsEqual(preflight.executor.provider, preflight.reviewer.provider)
+  );
+}
+function providerIdsEqual(left, right) {
+  return left.trim().toLowerCase() === right.trim().toLowerCase();
+}
+function canonicalJson(value) {
+  if (value === void 0) return "null";
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  const entries = Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+  return `{${entries.map(([key, entryValue]) => `${JSON.stringify(key)}:${canonicalJson(entryValue)}`).join(",")}}`;
+}
+function computeExecutionPolicyFingerprint(stages, reviewAssurance, preflight) {
+  const {
+    policySource: _policySource,
+    policySourceKind: _policySourceKind,
+    ...reviewer
+  } = preflight.reviewer;
+  const fingerprintPreflight = { ...preflight, reviewer };
+  return createHash("sha256").update(canonicalJson({ stages, reviewAssurance, preflight: fingerprintPreflight })).digest("hex").slice(0, 16);
+}
+function describeExecutionPolicyStampMismatch(stamp, workflow) {
+  if (stamp.version !== EXECUTION_POLICY_STAMP_VERSION) {
+    return `found version ${String(stamp.version)}, expected ${EXECUTION_POLICY_STAMP_VERSION}`;
+  }
+  const stages = workflow?.stages.flatMap((stage) => [
+    stage,
+    ...stage.seededPlan?.subStages ?? []
+  ]);
+  if (stages?.some(
+    (stage) => hasLegacyReviewAcceptancePrompt(
+      stage,
+      stage.type === "competition" ? COMPETITION_WINNER_DIFF_OUTPUT : EXECUTION_DIFF_OUTPUT,
+      stages.find((review) => review.id === reviewerStageId(stage.id))?.prompt
+    )
+  )) {
+    return "saved workflow uses the earlier criteria-free reviewer contract for a task with acceptance criteria; generate a current workflow with `build run sprint <sprint-id> --dry-run` and inspect it before starting a new run. Automatic migration of completed stages is unavailable; keep the existing workflow and run artifacts for recovery";
+  }
+  return `stamp version ${String(stamp.version)} is current, but the stamp no longer matches the persisted workflow (stage topology or role bindings drifted)`;
+}
+function hasCanonicalReviewTuple(stagesById, executionStage, preflight) {
+  const { reviewer } = preflight;
+  const isCompetition = executionStage.type === "competition";
+  const diffOutputName = isCompetition ? COMPETITION_WINNER_DIFF_OUTPUT : EXECUTION_DIFF_OUTPUT;
+  const reviewId = reviewerStageId(executionStage.id);
+  const reviewStage = stagesById.get(reviewId);
+  let acceptanceCriteria;
+  try {
+    acceptanceCriteria = resolveReviewAcceptanceCriteria(executionStage);
+  } catch {
+    return false;
+  }
+  if (!reviewStage || reviewStage.type !== "standard" || !providerIdsEqual(reviewStage.provider ?? "", reviewer.provider) || reviewer.model && reviewStage.model !== reviewer.model || reviewStage.deps?.length !== 1 || reviewStage.deps[0] !== executionStage.id || reviewStage.capabilities?.modifiesFiles !== false || reviewStage.capabilities.executionIntent !== "analysis" || reviewStage.templateVariables?.reviewInvocationSeparation !== "required-fresh-readonly" || reviewStage.templateVariables.reviewInvocationSeparationVerified !== false || reviewStage.templateVariables.reviewRole !== "reviewer" || reviewStage.inputs?.length !== 1 || reviewStage.inputs[0] !== `${executionStage.id}.${diffOutputName}` || reviewStage.outputs?.findings !== "text" || reviewStage.prompt !== buildReviewerPrompt(executionStage.id, diffOutputName, acceptanceCriteria)) {
+    return false;
+  }
+  const gateStage = stagesById.get(gateStageId(executionStage.id));
+  const parsedPolicy = parseReviewPolicy(reviewer.policy);
+  if (!parsedPolicy) return false;
+  const expectedGate = buildGateStage(executionStage, reviewStage, parsedPolicy);
+  return Boolean(
+    gateStage && gateStage.type === "verify" && JSON.stringify(gateStage.deps) === JSON.stringify(expectedGate.deps) && JSON.stringify(gateStage.inputs) === JSON.stringify(expectedGate.inputs) && JSON.stringify(gateStage.verify) === JSON.stringify(expectedGate.verify)
+  );
+}
+function isInjectedReviewStage(stage) {
+  return stage.type === "standard" && stage.capabilities?.modifiesFiles === false && stage.capabilities.executionIntent === "analysis" && stage.templateVariables?.reviewRole === "reviewer" && stage.templateVariables.reviewInvocationSeparation === "required-fresh-readonly";
+}
+function reviewStageVariantOverrides(stage) {
+  return isInjectedReviewStage(stage) ? {
+    analysisVerificationPolicy: "skip",
+    promptContractOverride: { id: EXECUTION_CONTRACT_STRUCTURED_ID }
+  } : {};
+}
+function isInjectedReviewGateStage(stage) {
+  return stage.type === "verify" && typeof stage.templateVariables?.reviewGateAnnotationFile === "string";
+}
+function mapGateStagesToExecutionStages(workflow) {
+  const gateToExecution = /* @__PURE__ */ new Map();
+  const stageLists = [workflow.stages];
+  for (const stage of workflow.stages) {
+    if (stage.type === "orchestrator" && stage.seededPlan) {
+      stageLists.push(stage.seededPlan.subStages);
+    }
+  }
+  for (const stages of stageLists) {
+    const byId = new Map(stages.map((stage) => [stage.id, stage]));
+    for (const stage of stages) {
+      if (!isInjectedReviewGateStage(stage)) continue;
+      const reviewerId = stage.deps?.[0];
+      const reviewer = reviewerId ? byId.get(reviewerId) : void 0;
+      const executionId = reviewer?.deps?.[0];
+      if (reviewer && executionId && byId.has(executionId)) {
+        gateToExecution.set(stage.id, executionId);
+      }
+    }
+  }
+  return gateToExecution;
+}
+function isCurrentExecutionPolicyWorkflow(workflow) {
+  const stamp = workflow.metadata?.executionPolicy;
+  if (!hasCurrentExecutionPolicyStampShape(stamp) || !stamp?.preflight) return false;
+  const { executor, reviewer } = stamp.preflight;
+  if (stamp.rolesFingerprint !== computeExecutionPolicyFingerprint(workflow.stages, stamp.reviewAssurance, stamp.preflight)) {
+    return false;
+  }
+  const stageLists = [workflow.stages];
+  for (const stage of workflow.stages) {
+    if (stage.type === "orchestrator" && stage.seededPlan) {
+      stageLists.push(stage.seededPlan.subStages);
+    }
+  }
+  for (const stages of stageLists) {
+    const byId = new Map(stages.map((stage) => [stage.id, stage]));
+    const potentialExecutionStages = stages.filter(isExecutionStage);
+    const reviewerIds = /* @__PURE__ */ new Set();
+    for (const executionStage of potentialExecutionStages) {
+      if (hasCanonicalReviewTuple(byId, executionStage, stamp.preflight)) {
+        reviewerIds.add(reviewerStageId(executionStage.id));
+      }
+    }
+    const executionStages = potentialExecutionStages.filter((stage) => !reviewerIds.has(stage.id));
+    for (const executionStage of executionStages) {
+      const isCompetition = executionStage.type === "competition";
+      const diffOutputName = isCompetition ? COMPETITION_WINNER_DIFF_OUTPUT : EXECUTION_DIFF_OUTPUT;
+      if (executionStage.outputs?.[diffOutputName] !== "diff") return false;
+      if (isCompetition) {
+        const variants = executionStage.competition?.variants ?? [];
+        if (variants.length === 0 || variants.some(
+          (variant) => !variant.provider.trim() || providerIdsEqual(variant.provider, reviewer.provider)
+        )) {
+          return false;
+        }
+      } else if (!providerIdsEqual(executionStage.provider ?? "", executor.provider)) {
+        return false;
+      }
+      const reviewId = reviewerStageId(executionStage.id);
+      if (!hasCanonicalReviewTuple(byId, executionStage, stamp.preflight)) return false;
+      for (const stage of stages) {
+        if (stage.id !== reviewId && stage.deps?.includes(executionStage.id)) return false;
+      }
+    }
+  }
+  return true;
+}
+var EXECUTION_STAGE_TYPES = /* @__PURE__ */ new Set([
+  "standard",
+  "competition"
+]);
+var EXECUTION_DIFF_OUTPUT = "executionDiff";
+var COMPETITION_WINNER_DIFF_OUTPUT = "winnerDiff";
+function isExecutionPolicyEngaged(roles) {
+  if (!roles.reviewer.policy && roles.reviewer.gate?.source === "fallback") {
+    return false;
+  }
+  const policyValue = roles.reviewer.policy?.value ?? reviewPolicyFromLegacy(
+    roles.reviewer.gate?.value ?? "off",
+    roles.reviewer.threshold?.value ?? "high"
+  );
+  const policy = parseReviewPolicy(policyValue);
+  if (!policy || policy.action === "off") return false;
+  if ((roles.reviewer.policy?.source ?? roles.reviewer.gate.source) === "fallback" && (roles.reviewAssurance?.executorSeparation === "same-as-executor" || roles.sameVendorReview)) {
+    return false;
+  }
+  return true;
+}
+function applyExecutionPolicy(workflow, roles, opts = {}) {
+  const existingStamp = workflow.metadata?.executionPolicy;
+  if (existingStamp !== void 0) {
+    if (isCurrentExecutionPolicyWorkflow(workflow)) return workflow;
+    throw new Error(
+      `Execution policy stamp is stale or malformed (${describeExecutionPolicyStampMismatch(existingStamp, workflow)}); regenerate the workflow.`
+    );
+  }
+  if (!isExecutionPolicyEngaged(roles)) {
+    return workflow;
+  }
+  if (roles.reviewer.policyNotice) {
+    opts.onNotice?.(roles.reviewer.policyNotice);
+  }
+  const rolesWithEffort = roles;
+  const policyBinding = roles.reviewer.policy ?? {
+    value: reviewPolicyFromLegacy(
+      roles.reviewer.gate?.value ?? "off",
+      roles.reviewer.threshold?.value ?? "high"
+    ),
+    source: roles.reviewer.gate?.source ?? "fallback",
+    sourcePath: roles.reviewer.gate?.sourcePath
+  };
+  const policy = parseReviewPolicy(policyBinding.value);
+  if (!policy) {
+    throw new Error(`Invalid resolved review policy '${policyBinding.value}'`);
+  }
+  const orderedStages = materializeDefaultSequentialDeps(workflow);
+  const nextStages = processStageList(orderedStages, rolesWithEffort, policy, opts).map((stage) => {
+    if (stage.type !== "orchestrator") return stage;
+    let withProcessedPlan = stage;
+    if (stage.seededPlan) {
+      const processedSubStages = processStageList(
+        stage.seededPlan.subStages,
+        rolesWithEffort,
+        policy,
+        opts
+      );
+      withProcessedPlan = {
+        ...stage,
+        seededPlan: {
+          ...stage.seededPlan,
+          subStages: processedSubStages
+        },
+        orchestrator: widenSeededSubStageBudget(stage.orchestrator, processedSubStages.length)
+      };
+    }
+    return bindOrchestratorRole(withProcessedPlan, rolesWithEffort, opts);
+  });
+  const reviewAssurance = roles.reviewAssurance ?? {
+    executorSeparation: roles.sameVendorReview ? "same-as-executor" : "separated",
+    invocationSeparation: "required-fresh-readonly",
+    invocationSeparationVerified: false
+  };
+  const stampedAssurance = {
+    executorSeparation: reviewAssurance.executorSeparation,
+    invocationSeparation: "required-fresh-readonly",
+    // Declared stage contract only — identity is not observable.
+    invocationSeparationVerified: false
+  };
+  const cliChangesExecutorProvider = Boolean(
+    opts.cliProviderOverride && !providerIdsEqual(opts.cliProviderOverride, roles.executor.provider.value)
+  );
+  const preflight = {
+    executor: {
+      provider: opts.cliProviderOverride ?? roles.executor.provider.value,
+      ...cliChangesExecutorProvider ? {} : { model: roles.executor.model.value }
+    },
+    reviewer: {
+      provider: roles.reviewer.provider.value,
+      model: roles.reviewer.model.value,
+      policy: policyBinding.value,
+      policySource: policyBinding.sourcePath ?? policyBinding.source,
+      policySourceKind: policyBinding.source,
+      gate: policy.action === "off" ? "off" : policy.action === "advisory" ? "advisory" : "high-severity-blocks",
+      threshold: policy.level ?? "high",
+      // Compatibility: same meaning as reviewAssurance.executorSeparation === 'same-as-executor'.
+      sameVendorReview: reviewAssurance.executorSeparation === "same-as-executor",
+      ...roles.reviewer.provider.sourcePath ? { providerSource: roles.reviewer.provider.sourcePath } : {}
+    }
+  };
+  const stamp = {
+    applied: true,
+    version: EXECUTION_POLICY_STAMP_VERSION,
+    rolesFingerprint: computeExecutionPolicyFingerprint(nextStages, stampedAssurance, preflight),
+    reviewAssurance: stampedAssurance,
+    preflight
+  };
+  return {
+    ...workflow,
+    stages: nextStages,
+    metadata: {
+      ...workflow.metadata ?? {},
+      executionPolicy: stamp
+    }
+  };
+}
+function materializeDefaultSequentialDeps(workflow) {
+  if (workflow.strict?.requireExplicitDeps === true) return workflow.stages;
+  return workflow.stages.map((stage, index) => {
+    if (stage.deps !== void 0 || index === 0) return stage;
+    const prevStageId = workflow.stages[index - 1]?.id;
+    if (typeof prevStageId !== "string" || prevStageId.length === 0) return stage;
+    return { ...stage, deps: [prevStageId] };
+  });
+}
+function processStageList(stages, roles, policy, opts) {
+  const gateEnabled = policy.action !== "off";
+  const bound = stages.map(
+    (stage) => isExecutionStage(stage) && stage.type !== "competition" ? bindExecutorRole(stage, roles, opts) : stage
+  );
+  if (!gateEnabled) {
+    return bound;
+  }
+  const occupiedIds = new Set(bound.map((stage) => stage.id));
+  for (const stage of bound) {
+    if (!isExecutionStage(stage)) continue;
+    for (const reservedId of [reviewerStageId(stage.id), gateStageId(stage.id)]) {
+      if (occupiedIds.has(reservedId)) {
+        throw new Error(
+          `Execution policy cannot inject review stages: stage id '${reservedId}' is already taken by an existing stage. Rename that stage (ids '<exec>-review' and '<exec>-gate' are reserved for policy-injected stages).`
+        );
+      }
+    }
+  }
+  const gateIdByExecId = /* @__PURE__ */ new Map();
+  const injectedReviewerIds = /* @__PURE__ */ new Set();
+  const injected = [];
+  for (const stage of bound) {
+    if (!isExecutionStage(stage)) {
+      injected.push(stage);
+      continue;
+    }
+    const isCompetition = stage.type === "competition";
+    const diffOutputName = isCompetition ? COMPETITION_WINNER_DIFF_OUTPUT : EXECUTION_DIFF_OUTPUT;
+    const execWithDiff = {
+      ...stage,
+      outputs: { ...stage.outputs ?? {}, [diffOutputName]: "diff" }
+    };
+    injected.push(execWithDiff);
+    const reviewerStage = buildReviewerStage(execWithDiff, roles, diffOutputName);
+    const gateStage = buildGateStage(execWithDiff, reviewerStage, policy);
+    if (stage.type === "competition" && reviewPolicyRepairs(policy)) {
+      opts.onNotice?.(
+        `Review policy '${policy.value}' reviews competition winner '${stage.id}' but cannot automatically repair competition stages; blocking findings halt for user action.`
+      );
+    }
+    gateIdByExecId.set(stage.id, gateStage.id);
+    injectedReviewerIds.add(reviewerStage.id);
+    injected.push(reviewerStage, gateStage);
+  }
+  return injected.map((stage) => {
+    if (injectedReviewerIds.has(stage.id)) return stage;
+    if (!stage.deps || stage.deps.length === 0) return stage;
+    let changed = false;
+    const rewritten = stage.deps.map((dep) => {
+      const gateId = gateIdByExecId.get(dep);
+      if (gateId && stage.id !== gateId) {
+        changed = true;
+        return gateId;
+      }
+      return dep;
+    });
+    return changed ? { ...stage, deps: dedupe(rewritten) } : stage;
+  });
+}
+function isExecutionStage(stage) {
+  const type = stage.type ?? "standard";
+  return EXECUTION_STAGE_TYPES.has(type);
+}
+function reviewerStageId(execId) {
+  return `${execId}-review`;
+}
+function gateStageId(execId) {
+  return `${execId}-gate`;
+}
+function bindExecutorRole(stage, roles, opts) {
+  const next = { ...stage };
+  const executorProvider = opts.cliProviderOverride ?? roles.executor.provider.value;
+  next.provider = executorProvider;
+  if (!next.model && !opts.cliProviderOverride) {
+    next.model = roles.executor.model.value;
+  }
+  if (next.modelReasoningEffort == null) {
+    const effort = readRoleReasoningEffort(roles.executor);
+    if (effort) {
+      next.modelReasoningEffort = effort;
+    }
+  }
+  const subagents = roles.executor.subagents.value;
+  if (subagents !== "off") {
+    const supportsNativeSubagents2 = getCapability(executorProvider, "provider_native_subagents") === true;
+    if (supportsNativeSubagents2) {
+      next.prompt = appendNativeSubagentGuidance(next.prompt ?? "", subagents).prompt;
+      if (next.providerExecutionTransport == null) {
+        const rolesTransport = roles.executor.transport.value;
+        next.providerExecutionTransport = rolesTransport !== "auto" ? rolesTransport : resolveNativeSubagentsTransport(executorProvider) ?? "tmux-exec";
+      }
+    } else {
+      opts.onNotice?.(
+        `Execution policy: provider '${executorProvider}' does not support provider-native subagents; subagent guidance skipped for stage '${stage.id}'.`
+      );
+    }
+  }
+  const selection = executorRoleSelection(stage, next, opts.cliProviderOverride, roles.executor);
+  if (selection) next.providerSelection = selection;
+  return next;
+}
+function bindOrchestratorRole(stage, roles, opts) {
+  const orch = roles.orchestrator;
+  if (!orch) return stage;
+  const next = { ...stage };
+  const roleMayOverrideComputedDefaults = opts.cliProviderOverride == null;
+  if (orch.provider?.value && (!next.provider || roleMayOverrideComputedDefaults)) {
+    next.provider = orch.provider.value;
+    if (roleMayOverrideComputedDefaults && !orch.model?.value) {
+      next.model = void 0;
+    }
+  }
+  if (orch.model?.value && (!next.model || roleMayOverrideComputedDefaults)) {
+    next.model = orch.model.value;
+  }
+  if (next.modelReasoningEffort == null) {
+    const effort = readRoleReasoningEffort(orch);
+    if (effort) {
+      next.modelReasoningEffort = effort;
+    }
+  }
+  if (orch.provider?.value || orch.model?.value || orch.fallbackModel?.value) {
+    const fallbackModel = orch.fallbackModel?.value;
+    const clearComputedOrchestrationModel = roleMayOverrideComputedDefaults && orch.provider?.value && !orch.model?.value;
+    const retainedProvider = next.orchestrator?.orchestrationProvider ?? next.provider;
+    const retainedModel = next.orchestrator?.orchestrationModel ?? next.model;
+    const fallbackMatchesRetainedBinding = Boolean(
+      fallbackModel && orch.provider?.value && retainedProvider && providerIdsEqual(retainedProvider, orch.provider.value) && (!retainedModel || !orch.model?.value || retainedModel === orch.model.value)
+    );
+    const bindFallback = fallbackModel && (roleMayOverrideComputedDefaults || fallbackMatchesRetainedBinding);
+    next.orchestrator = {
+      ...next.orchestrator ?? {},
+      ...orch.provider?.value && (!next.orchestrator?.orchestrationProvider || roleMayOverrideComputedDefaults) ? { orchestrationProvider: orch.provider.value } : {},
+      ...orch.model?.value && (!next.orchestrator?.orchestrationModel || roleMayOverrideComputedDefaults) ? { orchestrationModel: orch.model.value } : {},
+      ...bindFallback ? { orchestrationFallbackModel: fallbackModel } : {},
+      ...clearComputedOrchestrationModel ? { orchestrationModel: void 0 } : {}
+    };
+  }
+  return next;
+}
+function readRoleReasoningEffort(role) {
+  if (!role?.reasoningEffort) return void 0;
+  return normalizeReasoningEffortInput(role.reasoningEffort.value);
+}
+function buildReviewerStage(execStage, roles, diffOutputName = EXECUTION_DIFF_OUTPUT) {
+  const execId = execStage.id;
+  const reviewerEffort = readRoleReasoningEffort(roles.reviewer);
+  const reviewer = {
+    id: reviewerStageId(execId),
+    name: `Review: ${execStage.name ?? execId}`,
+    type: "standard",
+    deps: [execId],
+    provider: roles.reviewer.provider.value,
+    model: roles.reviewer.model.value,
+    modelRole: roles.reviewer.modelRole?.value ?? "reviewer",
+    ...reviewerEffort ? { modelReasoningEffort: reviewerEffort } : {},
+    capabilities: {
+      modifiesFiles: false,
+      producesText: true,
+      executionIntent: "analysis"
+    },
+    // Declared (not verified) assurance: review must be a fresh read-only context.
+    templateVariables: {
+      reviewInvocationSeparation: "required-fresh-readonly",
+      reviewInvocationSeparationVerified: false,
+      reviewRole: "reviewer"
+    },
+    inputs: [`${execId}.${diffOutputName}`],
+    outputs: { findings: "text" },
+    prompt: buildReviewerPrompt(execId, diffOutputName, resolveReviewAcceptanceCriteria(execStage))
+  };
+  return reviewer;
+}
+function buildGateStage(execStage, reviewerStage, policy) {
+  const execId = execStage.id;
+  const reviewerId = reviewerStage.id;
+  const mode = reviewPolicyBlocks(policy) ? "blocking" : "advisory";
+  const threshold = policy.level ?? "high";
+  const findingsFile = `.build-stage-inputs/${reviewerId}.findings.txt`;
+  const diffOutputName = execStage.type === "competition" ? COMPETITION_WINNER_DIFF_OUTPUT : EXECUTION_DIFF_OUTPUT;
+  const reviewDiffFile = `.build-stage-inputs/${execId}.${diffOutputName}.diff`;
+  const annotationFile = `.build-project/tmp/review-gates/${reviewerId}.json`;
+  const acceptanceCriteria = resolveReviewAcceptanceCriteria(execStage);
+  const command = [
+    "build internal review-gate",
+    `--findings ${findingsFile}`,
+    `--review-diff ${reviewDiffFile}`,
+    `--threshold ${threshold}`,
+    `--authorization-threshold ${reviewPolicyRepairs(policy) ? threshold : "none"}`,
+    `--mode ${mode}`,
+    `--policy ${policy.value}`,
+    `--annotation-out ${annotationFile}`,
+    ...acceptanceCriteria.length > 0 ? [`--acceptance-criteria ${encodeReviewAcceptanceCriteria(acceptanceCriteria)}`] : []
+  ].join(" ");
+  const authorizedReviewRepair = reviewPolicyRepairs(policy) && execStage.type !== "competition" && execStage.provider && reviewerStage.provider ? {
+    enabled: true,
+    annotationFile,
+    repairProvider: execStage.provider,
+    ...execStage.model ? { repairModel: execStage.model } : {},
+    ...execStage.providerSelection ? { repairSelection: execStage.providerSelection } : {},
+    verifierProvider: reviewerStage.provider,
+    ...reviewerStage.model ? { verifierModel: reviewerStage.model } : {},
+    maxAttempts: 2
+  } : void 0;
+  return {
+    id: gateStageId(execId),
+    name: `Review gate: ${execStage.name ?? execId}`,
+    type: "verify",
+    deps: [reviewerId],
+    inputs: [`${reviewerId}.findings`, `${execId}.${diffOutputName}`],
+    templateVariables: {
+      reviewPolicy: policy.value,
+      reviewGateAnnotationFile: annotationFile,
+      ...authorizedReviewRepair ? { authorizedReviewRepair } : {}
+    },
+    verify: {
+      commands: [command]
+    }
+  };
+}
+function dedupe(values) {
+  return Array.from(new Set(values));
+}
+
+export {
+  decodeReviewAcceptanceCriteria,
+  assessReviewAcceptanceCriteria,
+  automaticProviderSelection,
+  rebindPromptForProvider,
+  rebindStageForProvider,
+  isStageProviderSelection,
+  EXECUTION_POLICY_STAMP_VERSION,
+  describeExecutionPolicyStampMismatch,
+  isInjectedReviewStage,
+  reviewStageVariantOverrides,
+  isInjectedReviewGateStage,
+  mapGateStagesToExecutionStages,
+  isCurrentExecutionPolicyWorkflow,
+  isExecutionPolicyEngaged,
+  applyExecutionPolicy
+};
+//# sourceMappingURL=chunk-YTVVTIWJ.js.map