fifony 0.1.43 → 0.1.47

package/dist/chunk-EBCSQFPR.js

@@ -0,0 +1,682 @@
+// src/agents/review-profile.ts
+var UI_EXTENSIONS = [".jsx", ".tsx", ".css", ".scss", ".vue", ".svelte", ".html"];
+function collectCandidatePaths(issue) {
+  const planPaths = issue.plan?.suggestedPaths ?? [];
+  const issuePaths = issue.paths ?? [];
+  const contractAreas = issue.plan?.executionContract?.focusAreas ?? [];
+  return [.../* @__PURE__ */ new Set([...issuePaths, ...planPaths, ...contractAreas])];
+}
+function collectCandidateText(issue) {
+  return [
+    issue.title,
+    issue.description,
+    issue.issueType,
+    ...issue.labels ?? [],
+    ...issue.plan?.suggestedPaths ?? []
+  ].filter(Boolean).join(" ").toLowerCase();
+}
+function hasPath(paths, pattern) {
+  return paths.some((path) => pattern.test(path));
+}
+function hasCategory(criteria, category) {
+  return criteria.some((criterion) => criterion.category === category);
+}
+function includesAny(text, terms) {
+  return terms.some((term) => text.includes(term));
+}
+function buildFocusAreas(paths, fallback) {
+  const combined = [...paths, ...fallback].filter(Boolean);
+  return [...new Set(combined)].slice(0, 6);
+}
+function deriveReviewProfile(issue) {
+  const paths = collectCandidatePaths(issue);
+  const text = collectCandidateText(issue);
+  const criteria = issue.plan?.acceptanceCriteria ?? [];
+  const complexity = issue.plan?.estimatedComplexity;
+  const lowScope = complexity === "trivial" || complexity === "low";
+  const scores = [
+    { name: "general-quality", score: 1, rationale: ["Fallback profile for broad correctness, regression risk, and code quality review."] },
+    { name: "ui-polish", score: 0, rationale: [] },
+    { name: "workflow-fsm", score: 0, rationale: [] },
+    { name: "integration-safety", score: 0, rationale: [] },
+    { name: "api-contract", score: 0, rationale: [] },
+    { name: "security-hardening", score: 0, rationale: [] }
+  ];
+  const pathWeight = lowScope ? 1 : 5;
+  const keywordWeight = lowScope ? 1 : 3;
+  const broadKeywordWeight = lowScope ? 0 : 2;
+  const uiScore = scores.find((entry) => entry.name === "ui-polish");
+  if (paths.some((path) => UI_EXTENSIONS.some((ext) => path.endsWith(ext)))) {
+    uiScore.score += lowScope ? 2 : 4;
+    uiScore.rationale.push("Touched frontend files that can regress visual polish, interaction flow, or responsiveness.");
+  }
+  if (hasCategory(criteria, "design") || includesAny(text, ["frontend", "ui", "ux", "drawer", "onboarding", "layout", "mobile"])) {
+    uiScore.score += keywordWeight;
+    uiScore.rationale.push("Issue signals UI/UX work that needs stronger product-behavior and visual scrutiny.");
+  }
+  const workflowScore = scores.find((entry) => entry.name === "workflow-fsm");
+  if (hasPath(paths, /src\/persistence\/plugins\/fsm-|src\/commands\/|src\/domains\/issues\.ts|src\/agents\//)) {
+    workflowScore.score += pathWeight;
+    workflowScore.rationale.push("Touched workflow/FSM/orchestration code where lifecycle invariants and retry semantics are fragile.");
+  }
+  if (includesAny(text, ["fsm", "workflow", "queue", "review gate", "lifecycle", "orchestration", "agent"])) {
+    workflowScore.score += keywordWeight;
+    workflowScore.rationale.push("Issue description or labels indicate orchestration semantics rather than isolated implementation.");
+  }
+  const integrationScore = scores.find((entry) => entry.name === "integration-safety");
+  if (hasPath(paths, /workspace|merge|push|rebase|git|dirty-tracker|services?|store\.ts/)) {
+    integrationScore.score += pathWeight;
+    integrationScore.rationale.push("Touched integration or git/workspace code where destructive behavior and state drift must be caught.");
+  }
+  if (hasCategory(criteria, "integration") || hasCategory(criteria, "regression")) {
+    integrationScore.score += broadKeywordWeight;
+    integrationScore.rationale.push("Acceptance criteria explicitly call out integration or regression guarantees.");
+  }
+  const apiScore = scores.find((entry) => entry.name === "api-contract");
+  if (hasPath(paths, /src\/routes\/|src\/persistence\/resources\/|src\/mcp\//)) {
+    apiScore.score += lowScope ? 2 : 4;
+    apiScore.rationale.push("Touched API/resource surface that can drift from contract or persistence schema.");
+  }
+  if (includesAny(text, ["api", "route", "http", "endpoint", "resource", "schema"])) {
+    apiScore.score += broadKeywordWeight;
+    apiScore.rationale.push("Issue language implies request/response or schema contract changes.");
+  }
+  const securityScore = scores.find((entry) => entry.name === "security-hardening");
+  if (hasCategory(criteria, "security")) {
+    securityScore.score += 5;
+    securityScore.rationale.push("Security-sensitive acceptance criteria are present and should be treated as blocking by default.");
+  } else if (includesAny(text, ["auth", "security", "token", "permission", "secret"])) {
+    securityScore.score += lowScope ? 1 : 4;
+    securityScore.rationale.push("Issue language hints at security-sensitive work.");
+  }
+  if (hasPath(paths, /auth|permission|secret|credential|shell|command-executor/)) {
+    securityScore.score += lowScope ? 1 : 3;
+    securityScore.rationale.push("Touched code paths that can introduce auth, privilege, or command-execution risk.");
+  }
+  const ranked = [...scores].sort((a, b) => b.score - a.score);
+  const primary = ranked[0];
+  const secondary = ranked.filter((entry) => entry.name !== primary.name && entry.score >= 3).slice(0, 2).map((entry) => entry.name);
+  const byName = {
+    "general-quality": {
+      focusAreas: buildFocusAreas(paths, ["Correctness under real usage", "Regression risk", "Code quality and maintainability"]),
+      failureModes: [
+        "Partial implementations that look complete but leave core behavior stubbed",
+        "Missing validation, tests, or evidence for blocking criteria",
+        "Code that technically works but introduces obvious maintainability debt"
+      ],
+      evidencePriorities: [
+        "Run or inspect the most relevant validation commands",
+        "Trace the dominant code path end to end",
+        "Call out unverified assumptions explicitly instead of hand-waving them"
+      ],
+      severityBias: "Bias toward FAIL when behavior is only implied rather than demonstrated."
+    },
+    "ui-polish": {
+      focusAreas: buildFocusAreas(paths, ["Primary interaction flow", "Responsive layout", "Accessibility and clarity of actions"]),
+      failureModes: [
+        "Broken or unintuitive interaction flow, especially onboarding, drawers, and primary actions",
+        "Visual regressions, overflow, spacing collapse, or inaccessible controls",
+        "Interfaces that technically render but feel unfinished or confusing in use"
+      ],
+      evidencePriorities: [
+        "Navigate the affected UI and describe what users can and cannot do",
+        "Verify mobile-width and edge-state behavior, not just the happy path",
+        "Use Playwright evidence when visible behavior is part of the contract"
+      ],
+      severityBias: "Treat usability breaks and visually misleading states as blocking defects, not polish nits."
+    },
+    "workflow-fsm": {
+      focusAreas: buildFocusAreas(paths, ["State transitions", "Retry semantics", "Lifecycle invariants", "Counter reset behavior"]),
+      failureModes: [
+        "Illegal transitions that bypass approval, review, or terminal-state rules",
+        "Retry and checkpoint flows that jump to the wrong phase or double-increment counters",
+        "State cleanup/reset bugs that leave stale error, checkpoint, or lifecycle metadata behind"
+      ],
+      evidencePriorities: [
+        "Trace the exact state path for the critical scenario, including failure paths",
+        "Verify counters and lifecycle fields are reset or preserved intentionally",
+        "Treat ambiguous transition behavior as a defect until proven safe"
+      ],
+      severityBias: "Any lifecycle inconsistency that can misroute an issue or bypass a gate is blocking."
+    },
+    "integration-safety": {
+      focusAreas: buildFocusAreas(paths, ["Git/worktree operations", "Persistence side effects", "Idempotency and cleanup"]),
+      failureModes: [
+        "Destructive workspace behavior that can delete user work or dirty target branches",
+        "Cross-system drift between runtime state, resources, and filesystem artifacts",
+        "Merge/push/service-management flows that work only in the happy path and break under dirty state"
+      ],
+      evidencePriorities: [
+        "Verify failure handling, not just success path behavior",
+        "Check idempotency and cleanup paths explicitly",
+        "Call out any command or filesystem side effect that is not safely guarded"
+      ],
+      severityBias: "Prefer FAIL when integration code assumes a clean environment or safe side effects without enforcing them."
+    },
+    "api-contract": {
+      focusAreas: buildFocusAreas(paths, ["Route handlers", "Resource schema", "Input/output contract"]),
+      failureModes: [
+        "HTTP/API behavior that no longer matches route or resource contract",
+        "Schema drift between persisted fields, normalization, and route responses",
+        "Missing validation or status-code mismatches that break downstream callers"
+      ],
+      evidencePriorities: [
+        "Read the route/resource code and trace request-to-response behavior",
+        "Verify persisted fields, normalization, and response shape stay aligned",
+        "Treat silent contract drift as blocking even if the implementation compiles"
+      ],
+      severityBias: "Contract drift is blocking because it breaks automation and downstream clients silently."
+    },
+    "security-hardening": {
+      focusAreas: buildFocusAreas(paths, ["Authorization boundaries", "Secret handling", "Shell/command safety"]),
+      failureModes: [
+        "Authorization bypass, over-broad permissions, or unsafe defaults",
+        "Leaked secrets, credentials, or unsafe command composition",
+        "Security-sensitive criteria marked as effectively optional or unverified"
+      ],
+      evidencePriorities: [
+        "Look for privilege escalation and shell/filepath injection opportunities",
+        "Verify security checks with concrete evidence, not inference alone",
+        "Escalate uncertainty instead of allowing a soft PASS on security-sensitive paths"
+      ],
+      severityBias: "Security uncertainty should fail closed; do not grant benefit of the doubt."
+    }
+  };
+  return {
+    primary: primary.name,
+    secondary,
+    rationale: primary.rationale.length ? primary.rationale : ["Selected as the highest-risk profile based on touched code and acceptance criteria."],
+    ...byName[primary.name]
+  };
+}
+
+// src/agents/harness-policy.ts
+var HIGH_RISK_PROFILES = /* @__PURE__ */ new Set([
+  "workflow-fsm",
+  "integration-safety",
+  "api-contract",
+  "security-hardening"
+]);
+var HIGH_CHECKPOINT_PROFILES = /* @__PURE__ */ new Set([
+  "workflow-fsm",
+  "integration-safety",
+  "security-hardening"
+]);
+var ROUTE_AFFINITY = {
+  "general-quality": { claude: 2.4, codex: 1.8, gemini: 1.4 },
+  "ui-polish": { claude: 3.2, codex: 1.8, gemini: 1.6 },
+  "workflow-fsm": { codex: 3.1, claude: 2, gemini: 1 },
+  "integration-safety": { codex: 3, claude: 2, gemini: 1 },
+  "api-contract": { codex: 3.1, claude: 1.9, gemini: 1.2 },
+  "security-hardening": { claude: 2.6, codex: 2.6, gemini: 0.8 }
+};
+function rate(numerator, denominator) {
+  return denominator > 0 ? numerator / denominator : null;
+}
+function isCompletedIssue(issue) {
+  return issue.state === "Approved" || issue.state === "Merged";
+}
+function hadReviewRework(issue) {
+  return (issue.previousAttemptSummaries ?? []).some((summary) => summary.phase === "review");
+}
+function resolveEffectiveReviewProfile(issue) {
+  return issue.reviewProfile ?? deriveReviewProfile(issue);
+}
+function serializeReviewRouteSnapshot(route) {
+  const providerLabel = `${route.provider}${route.model ? `/${route.model}` : ""}`;
+  const effortLabel = route.reasoningEffort ? `[${route.reasoningEffort}]` : "";
+  const overlayLabel = route.overlays?.length ? `overlays:${[...route.overlays].sort().join(",")}` : "";
+  return [providerLabel, effortLabel, overlayLabel].filter(Boolean).join(" | ");
+}
+function buildReviewRouteKey(candidate) {
+  return serializeReviewRouteSnapshot({
+    provider: candidate.provider,
+    model: candidate.model,
+    reasoningEffort: candidate.reasoningEffort,
+    overlays: candidate.overlays ?? []
+  });
+}
+function applyHarnessModeToPlan(plan, mode) {
+  plan.harnessMode = mode;
+  if (mode !== "contractual") {
+    plan.executionContract.checkpointPolicy = "final_only";
+  } else if (plan.executionContract.checkpointPolicy !== "checkpointed") {
+    plan.executionContract.checkpointPolicy = "final_only";
+  }
+}
+function applyCheckpointPolicyToPlan(plan, checkpointPolicy) {
+  plan.executionContract.checkpointPolicy = plan.harnessMode === "contractual" ? checkpointPolicy : "final_only";
+}
+function resolveLatestCompletedReviewRun(issue, scope = "final") {
+  const reviewRuns = Array.isArray(issue.reviewRuns) ? issue.reviewRuns : [];
+  const completed = reviewRuns.filter((entry) => entry.status === "completed");
+  const matchingScope = completed.filter((entry) => entry.scope === scope);
+  const pool = matchingScope.length > 0 ? matchingScope : completed;
+  if (pool.length === 0) return null;
+  return [...pool].sort((left, right) => {
+    const leftAt = Date.parse(left.completedAt ?? left.startedAt);
+    const rightAt = Date.parse(right.completedAt ?? right.startedAt);
+    if (!Number.isNaN(leftAt) && !Number.isNaN(rightAt) && leftAt !== rightAt) return rightAt - leftAt;
+    if ((left.planVersion ?? 0) !== (right.planVersion ?? 0)) return (right.planVersion ?? 0) - (left.planVersion ?? 0);
+    return (right.attempt ?? 0) - (left.attempt ?? 0);
+  })[0] ?? null;
+}
+function resolveLatestCompletedContractNegotiationRuns(issue) {
+  const runs = Array.isArray(issue.contractNegotiationRuns) ? issue.contractNegotiationRuns : [];
+  const completed = runs.filter((entry) => entry.status === "completed");
+  if (completed.length === 0) return [];
+  const latestPlanVersion = completed.reduce((maxPlanVersion, entry) => Math.max(maxPlanVersion, entry.planVersion ?? 0), 0);
+  return completed.filter((entry) => (entry.planVersion ?? 0) === latestPlanVersion).sort((left, right) => {
+    if ((left.attempt ?? 0) !== (right.attempt ?? 0)) return (left.attempt ?? 0) - (right.attempt ?? 0);
+    const leftAt = Date.parse(left.completedAt ?? left.startedAt);
+    const rightAt = Date.parse(right.completedAt ?? right.startedAt);
+    if (!Number.isNaN(leftAt) && !Number.isNaN(rightAt) && leftAt !== rightAt) return leftAt - rightAt;
+    return left.id.localeCompare(right.id);
+  });
+}
+function resolveLatestCompletedScopedReviewRuns(issue, scope) {
+  const reviewRuns = Array.isArray(issue.reviewRuns) ? issue.reviewRuns : [];
+  const completed = reviewRuns.filter((entry) => entry.status === "completed" && entry.scope === scope);
+  if (completed.length === 0) return [];
+  const latestPlanVersion = completed.reduce((maxPlanVersion, entry) => Math.max(maxPlanVersion, entry.planVersion ?? 0), 0);
+  return completed.filter((entry) => (entry.planVersion ?? 0) === latestPlanVersion).sort((left, right) => {
+    if ((left.attempt ?? 0) !== (right.attempt ?? 0)) return (left.attempt ?? 0) - (right.attempt ?? 0);
+    const leftAt = Date.parse(left.completedAt ?? left.startedAt);
+    const rightAt = Date.parse(right.completedAt ?? right.startedAt);
+    if (!Number.isNaN(leftAt) && !Number.isNaN(rightAt) && leftAt !== rightAt) return leftAt - rightAt;
+    return left.id.localeCompare(right.id);
+  });
+}
+function computeHarnessModeStats(issues, profileName) {
+  const buckets = {
+    solo: { reviewedIssues: 0, completedReviewedIssues: 0, gatePasses: 0, firstPassPasses: 0, reworkIssues: 0 },
+    standard: { reviewedIssues: 0, completedReviewedIssues: 0, gatePasses: 0, firstPassPasses: 0, reworkIssues: 0 },
+    contractual: { reviewedIssues: 0, completedReviewedIssues: 0, gatePasses: 0, firstPassPasses: 0, reworkIssues: 0 }
+  };
+  for (const issue of issues) {
+    const reviewRun = resolveLatestCompletedReviewRun(issue, "final");
+    if (!reviewRun) continue;
+    const effectiveProfile = reviewRun.reviewProfile ?? resolveEffectiveReviewProfile(issue);
+    if (effectiveProfile.primary !== profileName) continue;
+    const mode = issue.plan?.harnessMode ?? "standard";
+    const bucket = buckets[mode];
+    bucket.reviewedIssues += 1;
+    if (isCompletedIssue(issue)) bucket.completedReviewedIssues += 1;
+    if (reviewRun.blockingVerdict === "PASS") bucket.gatePasses += 1;
+    if ((issue.reviewAttempt ?? 0) <= 1 && !hadReviewRework(issue) && isCompletedIssue(issue)) bucket.firstPassPasses += 1;
+    if (hadReviewRework(issue)) bucket.reworkIssues += 1;
+  }
+  return {
+    solo: {
+      ...buckets.solo,
+      gatePassRate: rate(buckets.solo.gatePasses, buckets.solo.reviewedIssues),
+      firstPassPassRate: rate(buckets.solo.firstPassPasses, buckets.solo.completedReviewedIssues),
+      reviewReworkRate: rate(buckets.solo.reworkIssues, buckets.solo.reviewedIssues)
+    },
+    standard: {
+      ...buckets.standard,
+      gatePassRate: rate(buckets.standard.gatePasses, buckets.standard.reviewedIssues),
+      firstPassPassRate: rate(buckets.standard.firstPassPasses, buckets.standard.completedReviewedIssues),
+      reviewReworkRate: rate(buckets.standard.reworkIssues, buckets.standard.reviewedIssues)
+    },
+    contractual: {
+      ...buckets.contractual,
+      gatePassRate: rate(buckets.contractual.gatePasses, buckets.contractual.reviewedIssues),
+      firstPassPassRate: rate(buckets.contractual.firstPassPasses, buckets.contractual.completedReviewedIssues),
+      reviewReworkRate: rate(buckets.contractual.reworkIssues, buckets.contractual.reviewedIssues)
+    }
+  };
+}
+function computeCheckpointPolicyStats(issues, profileName) {
+  const buckets = {
+    final_only: {
+      reviewedIssues: 0,
+      completedReviewedIssues: 0,
+      gatePasses: 0,
+      firstPassPasses: 0,
+      reworkIssues: 0,
+      checkpointFailures: 0,
+      checkpointPasses: 0,
+      checkpointRuns: 0
+    },
+    checkpointed: {
+      reviewedIssues: 0,
+      completedReviewedIssues: 0,
+      gatePasses: 0,
+      firstPassPasses: 0,
+      reworkIssues: 0,
+      checkpointFailures: 0,
+      checkpointPasses: 0,
+      checkpointRuns: 0
+    }
+  };
+  for (const issue of issues) {
+    if ((issue.plan?.harnessMode ?? "standard") !== "contractual") continue;
+    const finalReviewRun = resolveLatestCompletedReviewRun(issue, "final");
+    if (!finalReviewRun) continue;
+    const effectiveProfile = finalReviewRun.reviewProfile ?? resolveEffectiveReviewProfile(issue);
+    if (effectiveProfile.primary !== profileName) continue;
+    const checkpointPolicy = issue.plan?.executionContract?.checkpointPolicy === "checkpointed" ? "checkpointed" : "final_only";
+    const bucket = buckets[checkpointPolicy];
+    bucket.reviewedIssues += 1;
+    if (isCompletedIssue(issue)) bucket.completedReviewedIssues += 1;
+    if (finalReviewRun.blockingVerdict === "PASS") bucket.gatePasses += 1;
+    if ((issue.reviewAttempt ?? 0) <= 1 && !hadReviewRework(issue) && isCompletedIssue(issue)) bucket.firstPassPasses += 1;
+    if (hadReviewRework(issue)) bucket.reworkIssues += 1;
+    if (checkpointPolicy === "checkpointed") {
+      const checkpointRuns = resolveLatestCompletedScopedReviewRuns(issue, "checkpoint");
+      bucket.checkpointRuns += checkpointRuns.length;
+      if (checkpointRuns.some((entry) => entry.blockingVerdict === "FAIL")) bucket.checkpointFailures += 1;
+      if (checkpointRuns.some((entry) => entry.blockingVerdict === "PASS")) bucket.checkpointPasses += 1;
+    }
+  }
+  return {
+    final_only: {
+      ...buckets.final_only,
+      gatePassRate: rate(buckets.final_only.gatePasses, buckets.final_only.reviewedIssues),
+      firstPassPassRate: rate(buckets.final_only.firstPassPasses, buckets.final_only.completedReviewedIssues),
+      reviewReworkRate: rate(buckets.final_only.reworkIssues, buckets.final_only.reviewedIssues),
+      checkpointFailureRate: rate(buckets.final_only.checkpointFailures, buckets.final_only.reviewedIssues),
+      checkpointPassRate: rate(buckets.final_only.checkpointPasses, buckets.final_only.reviewedIssues),
+      avgCheckpointRunsPerIssue: rate(buckets.final_only.checkpointRuns, buckets.final_only.reviewedIssues)
+    },
+    checkpointed: {
+      ...buckets.checkpointed,
+      gatePassRate: rate(buckets.checkpointed.gatePasses, buckets.checkpointed.reviewedIssues),
+      firstPassPassRate: rate(buckets.checkpointed.firstPassPasses, buckets.checkpointed.completedReviewedIssues),
+      reviewReworkRate: rate(buckets.checkpointed.reworkIssues, buckets.checkpointed.reviewedIssues),
+      checkpointFailureRate: rate(buckets.checkpointed.checkpointFailures, buckets.checkpointed.reviewedIssues),
+      checkpointPassRate: rate(buckets.checkpointed.checkpointPasses, buckets.checkpointed.reviewedIssues),
+      avgCheckpointRunsPerIssue: rate(buckets.checkpointed.checkpointRuns, buckets.checkpointed.reviewedIssues)
+    }
+  };
+}
+function computeContractNegotiationStats(issues, profileName) {
+  const bucket = {
+    negotiatedIssues: 0,
+    approvedIssues: 0,
+    firstPassApprovals: 0,
+    revisedIssues: 0,
+    blockingConcernIssues: 0,
+    totalRounds: 0
+  };
+  for (const issue of issues) {
+    const planRuns = resolveLatestCompletedContractNegotiationRuns(issue);
+    if (planRuns.length === 0) continue;
+    const latestRun = planRuns[planRuns.length - 1];
+    const effectiveProfile = latestRun.reviewProfile ?? resolveEffectiveReviewProfile(issue);
+    if (effectiveProfile.primary !== profileName) continue;
+    bucket.negotiatedIssues += 1;
+    bucket.totalRounds += planRuns.length;
+    if (latestRun.decisionStatus === "approved") bucket.approvedIssues += 1;
+    if (planRuns.length === 1 && planRuns[0]?.decisionStatus === "approved") bucket.firstPassApprovals += 1;
+    if (planRuns.some((entry) => entry.decisionStatus === "revise" || entry.appliedRefinement)) bucket.revisedIssues += 1;
+    if (planRuns.some((entry) => (entry.blockingConcernsCount ?? 0) > 0)) bucket.blockingConcernIssues += 1;
+  }
+  return {
+    ...bucket,
+    approvalRate: rate(bucket.approvedIssues, bucket.negotiatedIssues),
+    firstPassApprovalRate: rate(bucket.firstPassApprovals, bucket.negotiatedIssues),
+    revisionRate: rate(bucket.revisedIssues, bucket.negotiatedIssues),
+    blockingConcernRate: rate(bucket.blockingConcernIssues, bucket.negotiatedIssues),
+    avgRoundsPerIssue: rate(bucket.totalRounds, bucket.negotiatedIssues)
+  };
+}
+function recommendCheckpointPolicyForIssue(issues, issue, currentCheckpointPolicy, minSamples = 3) {
+  if (issue.plan?.harnessMode !== "contractual") {
+    if (currentCheckpointPolicy !== "final_only") {
+      const profile2 = resolveEffectiveReviewProfile(issue);
+      return {
+        checkpointPolicy: "final_only",
+        profile: profile2,
+        basis: "heuristic",
+        rationale: "Non-contractual plans must not request checkpoint review."
+      };
+    }
+    return null;
+  }
+  const profile = resolveEffectiveReviewProfile(issue);
+  const complexity = issue.plan?.estimatedComplexity ?? "medium";
+  const lowScope = complexity === "trivial" || complexity === "low";
+  if (lowScope) {
+    if (currentCheckpointPolicy !== "final_only") {
+      return {
+        checkpointPolicy: "final_only",
+        profile,
+        basis: "heuristic",
+        rationale: `Disabled checkpoint review because ${complexity} complexity does not warrant an intermediate review pass.`
+      };
+    }
+    return null;
+  }
+  const highCheckpointRisk = HIGH_CHECKPOINT_PROFILES.has(profile.primary);
+  const stats = computeCheckpointPolicyStats(issues, profile.primary);
+  const finalOnly = stats.final_only;
+  const checkpointed = stats.checkpointed;
+  const checkpointedSamplesReady = checkpointed.reviewedIssues >= minSamples;
+  const finalOnlySamplesReady = finalOnly.reviewedIssues >= minSamples;
+  if (currentCheckpointPolicy !== "checkpointed" && highCheckpointRisk) {
+    if (checkpointedSamplesReady && (checkpointed.checkpointFailureRate ?? 0) >= 0.15) {
+      return {
+        checkpointPolicy: "checkpointed",
+        profile,
+        basis: "historical",
+        rationale: `Enabled checkpoint review for ${profile.primary}: checkpointed runs caught blocking issues before final review in ${Math.round((checkpointed.checkpointFailureRate ?? 0) * 100)}% of ${checkpointed.reviewedIssues} comparable issue(s).`
+      };
+    }
+    if (!checkpointedSamplesReady) {
+      return {
+        checkpointPolicy: "checkpointed",
+        profile,
+        basis: "heuristic",
+        rationale: `Enabled checkpoint review because ${profile.primary} changes are high-risk enough to benefit from an intermediate gate before final review.`
+      };
+    }
+  }
+  if (checkpointedSamplesReady && finalOnlySamplesReady) {
+    const gateLift = (checkpointed.gatePassRate ?? 0) - (finalOnly.gatePassRate ?? 0);
+    const firstPassLift = (checkpointed.firstPassPassRate ?? 0) - (finalOnly.firstPassPassRate ?? 0);
+    const checkpointCatchRate = checkpointed.checkpointFailureRate ?? 0;
+    if (currentCheckpointPolicy !== "checkpointed" && (checkpointCatchRate >= 0.18 || gateLift >= 0.08 || firstPassLift >= 0.1)) {
+      return {
+        checkpointPolicy: "checkpointed",
+        profile,
+        basis: "historical",
+        rationale: `Enabled checkpoint review for ${profile.primary}: checkpointed runs show ${Math.round(checkpointCatchRate * 100)}% checkpoint catch rate, ${Math.round(gateLift * 100)}pp final gate lift, and ${Math.round(firstPassLift * 100)}pp first-pass lift over final-only contractual runs.`
+      };
+    }
+    if (currentCheckpointPolicy === "checkpointed" && !highCheckpointRisk && checkpointCatchRate <= 0.05 && (finalOnly.gatePassRate ?? 0) >= (checkpointed.gatePassRate ?? 0) - 0.05 && (finalOnly.firstPassPassRate ?? 0) >= (checkpointed.firstPassPassRate ?? 0) - 0.05) {
+      return {
+        checkpointPolicy: "final_only",
+        profile,
+        basis: "historical",
+        rationale: `Disabled checkpoint review for ${profile.primary}: checkpointed runs almost never catch issues before final review (${Math.round(checkpointCatchRate * 100)}%), while final-only contractual runs stay within 5pp on final gate and first-pass outcomes.`
+      };
+    }
+  }
+  return null;
+}
+function recommendHarnessModeForIssue(issues, issue, currentMode, minSamples = 3) {
+  const profile = resolveEffectiveReviewProfile(issue);
+  const complexity = issue.plan?.estimatedComplexity ?? "medium";
+  const stats = computeHarnessModeStats(issues, profile.primary);
+  const negotiation = computeContractNegotiationStats(issues, profile.primary);
+  const highRisk = HIGH_RISK_PROFILES.has(profile.primary);
+  const lowScope = complexity === "trivial" || complexity === "low";
+  const negotiationSamplesReady = negotiation.negotiatedIssues >= minSamples;
+  const highRiskNegotiationPressure = negotiationSamplesReady && ((negotiation.blockingConcernRate ?? 0) >= 0.15 || (negotiation.revisionRate ?? 0) >= 0.3);
+  const generalNegotiationPressure = negotiationSamplesReady && !lowScope && ((negotiation.blockingConcernRate ?? 0) >= 0.25 || (negotiation.revisionRate ?? 0) >= 0.4 || (negotiation.avgRoundsPerIssue ?? 0) >= 1.6);
+  const negotiationLowValue = negotiationSamplesReady && (negotiation.firstPassApprovalRate ?? 0) >= 0.9 && (negotiation.blockingConcernRate ?? 1) <= 0.08 && (negotiation.revisionRate ?? 1) <= 0.15;
+  if (highRisk && currentMode !== "contractual") {
+    if (lowScope) {
+      if (currentMode === "solo") {
+        return {
+          mode: "standard",
+          profile,
+          basis: "heuristic",
+          rationale: `Upgraded from solo to standard for ${profile.primary} (high-risk profile), but kept lightweight because complexity is ${complexity}.`
+        };
+      }
+      return null;
+    }
+    if (highRiskNegotiationPressure) {
+      return {
+        mode: "contractual",
+        profile,
+        basis: "historical",
+        rationale: `Switched to contractual for ${profile.primary}: contract negotiation found blocking concerns in ${Math.round((negotiation.blockingConcernRate ?? 0) * 100)}% of ${negotiation.negotiatedIssues} comparable issue(s) and forced revisions in ${Math.round((negotiation.revisionRate ?? 0) * 100)}%.`
+      };
+    }
+    const contractual2 = stats.contractual;
+    if (contractual2.reviewedIssues >= minSamples) {
+      return {
+        mode: "contractual",
+        profile,
+        basis: "historical",
+        rationale: `Switched to contractual for ${profile.primary}: historical gate pass ${Math.round((contractual2.gatePassRate ?? 0) * 100)}% across ${contractual2.reviewedIssues} reviewed issue(s).`
+      };
+    }
+    return {
+      mode: "contractual",
+      profile,
+      basis: "heuristic",
+      rationale: `Switched to contractual because ${profile.primary} is a high-risk profile and needs stronger contract negotiation plus skeptical review semantics.`
+    };
+  }
+  if (profile.primary === "general-quality" && lowScope) {
+    const solo = stats.solo;
+    if (solo.reviewedIssues >= minSamples && (solo.gatePassRate ?? 0) >= 0.95 && (solo.reviewReworkRate ?? 1) <= 0.1) {
+      if (currentMode !== "solo") {
+        return {
+          mode: "solo",
+          profile,
+          basis: "historical",
+          rationale: `Downgraded to solo for low-scope general work: solo gate pass ${Math.round((solo.gatePassRate ?? 0) * 100)}% with low rework over ${solo.reviewedIssues} reviewed issue(s).`
+        };
+      }
+      return null;
+    }
+  }
+  if (currentMode !== "contractual" && generalNegotiationPressure) {
+    return {
+      mode: "contractual",
+      profile,
+      basis: "historical",
+      rationale: `Switched to contractual for ${profile.primary}: contract negotiation found blocking concerns in ${Math.round((negotiation.blockingConcernRate ?? 0) * 100)}% of ${negotiation.negotiatedIssues} comparable issue(s), with revisions required in ${Math.round((negotiation.revisionRate ?? 0) * 100)}% and ${Math.round((negotiation.avgRoundsPerIssue ?? 0) * 10) / 10} rounds per issue on average.`
+    };
+  }
+  const standard = stats.standard;
+  const contractual = stats.contractual;
+  const contractualSamplesReady = contractual.reviewedIssues >= minSamples;
+  const standardSamplesReady = standard.reviewedIssues >= minSamples;
+  if (contractualSamplesReady && standardSamplesReady) {
+    const contractualGateLift = (contractual.gatePassRate ?? 0) - (standard.gatePassRate ?? 0);
+    const contractualFirstPassLift = (contractual.firstPassPassRate ?? 0) - (standard.firstPassPassRate ?? 0);
+    if (currentMode !== "contractual" && (contractualGateLift >= 0.12 || contractualFirstPassLift >= 0.15)) {
+      return {
+        mode: "contractual",
+        profile,
+        basis: "historical",
+        rationale: `Switched to contractual for ${profile.primary}: first-pass lift ${Math.round(contractualFirstPassLift * 100)}pp and gate lift ${Math.round(contractualGateLift * 100)}pp over standard.`
+      };
+    }
+    if (currentMode === "contractual" && !highRisk && !lowScope && negotiationLowValue && (standard.gatePassRate ?? 0) >= (contractual.gatePassRate ?? 0) - 0.05 && (standard.firstPassPassRate ?? 0) >= (contractual.firstPassPassRate ?? 0) - 0.05) {
+      return {
+        mode: "standard",
+        profile,
+        basis: "historical",
+        rationale: `Downgraded to standard for ${profile.primary}: contract negotiation approved on first pass in ${Math.round((negotiation.firstPassApprovalRate ?? 0) * 100)}% of ${negotiation.negotiatedIssues} comparable issue(s), and standard review performance stays within 5pp of contractual.`
+      };
+    }
+  }
+  if (!highRisk && currentMode === "solo" && !lowScope) {
+    return {
+      mode: "standard",
+      profile,
+      basis: "heuristic",
+      rationale: `Upgraded from solo to standard because ${complexity} complexity should keep an automated reviewer in the loop.`
+    };
+  }
+  return null;
+}
+function computeReviewRouteStats(issues, profileName) {
+  const buckets = {};
+  for (const issue of issues) {
+    const reviewRun = resolveLatestCompletedReviewRun(issue, "final");
+    if (!reviewRun) continue;
+    const effectiveProfile = reviewRun.reviewProfile ?? resolveEffectiveReviewProfile(issue);
+    if (effectiveProfile.primary !== profileName) continue;
+    const routeKey = serializeReviewRouteSnapshot(reviewRun.routing);
+    const bucket = buckets[routeKey] ||= {
+      reviewedIssues: 0,
+      completedReviewedIssues: 0,
+      gatePasses: 0,
+      blockingFailRuns: 0,
+      advisoryFailRuns: 0
+    };
+    bucket.reviewedIssues += 1;
+    if (isCompletedIssue(issue)) bucket.completedReviewedIssues += 1;
+    if (reviewRun.blockingVerdict === "PASS") bucket.gatePasses += 1;
+    if (reviewRun.blockingVerdict === "FAIL") bucket.blockingFailRuns += 1;
+    if ((reviewRun.advisoryFailedCriteriaCount ?? 0) > 0) bucket.advisoryFailRuns += 1;
+  }
+  return Object.fromEntries(
+    Object.entries(buckets).map(([routeKey, bucket]) => [
+      routeKey,
+      {
+        ...bucket,
+        gatePassRate: rate(bucket.gatePasses, bucket.reviewedIssues),
+        blockingFailRate: rate(bucket.blockingFailRuns, bucket.reviewedIssues)
+      }
+    ])
+  );
+}
+function recommendReviewRouteForIssue(issues, issue, candidates, minSamples = 3) {
+  if (candidates.length === 0) return null;
+  const profile = resolveEffectiveReviewProfile(issue);
+  const routeStats = computeReviewRouteStats(issues, profile.primary);
+  const scored = candidates.map((candidate) => {
+    const routeKey = buildReviewRouteKey(candidate);
+    const stats = routeStats[routeKey];
+    const affinity = ROUTE_AFFINITY[profile.primary][candidate.provider] ?? 0;
+    const historicalScore = stats ? (stats.gatePassRate ?? 0) * 4 - (stats.blockingFailRate ?? 0) * 3 + Math.min(stats.reviewedIssues, 6) * 0.15 : 0;
+    return {
+      candidate,
+      routeKey,
+      stats,
+      score: affinity + historicalScore,
+      affinity
+    };
+  }).sort((left, right) => {
+    if (right.score !== left.score) return right.score - left.score;
+    return left.routeKey.localeCompare(right.routeKey);
+  });
+  const current = scored[0];
+  if (!current) return null;
+  if (current.stats && current.stats.reviewedIssues >= minSamples) {
+    return {
+      candidate: current.candidate,
+      profile,
+      basis: "historical",
+      rationale: `Adaptive reviewer route for ${profile.primary}: ${current.routeKey} has ${Math.round((current.stats.gatePassRate ?? 0) * 100)}% gate pass over ${current.stats.reviewedIssues} reviewed issue(s).`
+    };
+  }
+  return {
+    candidate: current.candidate,
+    profile,
+    basis: "heuristic",
+    rationale: `Adaptive reviewer route for ${profile.primary}: preferred ${current.candidate.provider} based on profile affinity while historical samples are still sparse.`
+  };
+}
+
+export {
+  deriveReviewProfile,
+  serializeReviewRouteSnapshot,
+  buildReviewRouteKey,
+  applyHarnessModeToPlan,
+  applyCheckpointPolicyToPlan,
+  recommendCheckpointPolicyForIssue,
+  recommendHarnessModeForIssue,
+  recommendReviewRouteForIssue
+};
+//# sourceMappingURL=chunk-EBCSQFPR.js.map