fifony 0.1.42 → 0.1.43

package/dist/{chunk-NB44PCD2.js → chunk-FJNH3G2Z.js}

@@ -1,48 +1,74 @@
-import {
-  appendFileTail,
-  idToSafePath,
-  now,
-  renderPrompt
-} from "./chunk-2CVTK5F2.js";
-import {
-  SOURCE_MARKER,
-  SOURCE_ROOT,
-  TARGET_ROOT,
-  WORKSPACE_ROOT
-} from "./chunk-37N5OFHM.js";
 import {
   logger
 } from "./chunk-DVU3CXWA.js";
-
-// src/domains/workspace.ts
 import {
-  existsSync as existsSync7,
-  mkdirSync,
-  readdirSync,
-  readFileSync as readFileSync4,
-  rmSync as rmSync2,
-  statSync,
-  writeFileSync as writeFileSync2
-} from "fs";
-import { copyFile, mkdir, readdir, stat, writeFile } from "fs/promises";
-import { extname as extname2, join as join7, resolve } from "path";
-import { execSync } from "child_process";
-
-// src/agents/command-executor.ts
+  renderPrompt
+} from "./chunk-ESWHDHH6.js";
 import {
-  appendFileSync,
-  rmSync,
-  writeFileSync
-} from "fs";
-import { join as join6 } from "path";
-import { env as env2 } from "process";
-import { spawn } from "child_process";
+  sleep
+} from "./chunk-42AMQAJG.js";
 
-// src/agents/providers.ts
-import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
-import { join as join5 } from "path";
-import { homedir as homedir2 } from "os";
+// src/persistence/dirty-tracker.ts
+var dirtyIssueIds = /* @__PURE__ */ new Set();
+var dirtyMilestoneIds = /* @__PURE__ */ new Set();
+var dirtyIssuePlanIds = /* @__PURE__ */ new Set();
+var dirtyEventIds = /* @__PURE__ */ new Set();
+function markIssueDirty(id) {
+  dirtyIssueIds.add(id);
+}
+function markMilestoneDirty(id) {
+  dirtyMilestoneIds.add(id);
+}
+function markIssuePlanDirty(id) {
+  dirtyIssuePlanIds.add(id);
+}
+function markEventDirty(id) {
+  dirtyEventIds.add(id);
+}
+function hasDirtyState() {
+  return dirtyIssueIds.size > 0 || dirtyMilestoneIds.size > 0 || dirtyEventIds.size > 0;
+}
+function getDirtyIssueIds() {
+  return dirtyIssueIds;
+}
+function getDirtyMilestoneIds() {
+  return dirtyMilestoneIds;
+}
+function getDirtyEventIds() {
+  return dirtyEventIds;
+}
+function snapshotAndClearDirtyIssueIds() {
+  const snapshot = new Set(dirtyIssueIds);
+  for (const id of snapshot) dirtyIssueIds.delete(id);
+  return snapshot;
+}
+function snapshotAndClearDirtyMilestoneIds() {
+  const snapshot = new Set(dirtyMilestoneIds);
+  for (const id of snapshot) dirtyMilestoneIds.delete(id);
+  return snapshot;
+}
+function snapshotAndClearDirtyIssuePlanIds() {
+  const snapshot = new Set(dirtyIssuePlanIds);
+  for (const id of snapshot) dirtyIssuePlanIds.delete(id);
+  return snapshot;
+}
+function snapshotAndClearDirtyEventIds() {
+  const snapshot = new Set(dirtyEventIds);
+  for (const id of snapshot) dirtyEventIds.delete(id);
+  return snapshot;
+}
+function markAllIssuesDirty(ids) {
+  for (const id of ids) dirtyIssueIds.add(id);
+}
+function markAllMilestonesDirty(ids) {
+  for (const id of ids) dirtyMilestoneIds.add(id);
+}
+function markAllIssuePlansDirty(ids) {
+  for (const id of ids) dirtyIssuePlanIds.add(id);
+}
+function markAllEventsDirty(ids) {
+  for (const id of ids) dirtyEventIds.add(id);
+}
 
 // src/agents/adapters/claude.ts
 import { existsSync as existsSync2 } from "fs";
@@ -52,7 +78,7 @@ import { join } from "path";
 import { existsSync, readFileSync } from "fs";
 import { basename, extname } from "path";
 function buildPlanContextSection(plan) {
-  const parts = ["## Plan Context", "", `**Summary:** ${plan.summary}`];
+  const parts = ["## Plan Context", "", `**Summary:** ${plan.summary}`, `**Harness mode:** ${plan.harnessMode}`];
   if (plan.assumptions?.length) {
     parts.push("", "**Assumptions:**");
     plan.assumptions.forEach((a) => parts.push(`- ${a}`));
@@ -105,11 +131,43 @@ function buildRiskSection(plan) {
   }
   return parts.join("\n");
 }
+function normalizeAcceptanceCriteria(plan) {
+  return plan.acceptanceCriteria.map((criterion, index) => ({
+    id: criterion.id || `AC-${index + 1}`,
+    description: criterion.description,
+    category: criterion.category,
+    verificationMethod: criterion.verificationMethod,
+    evidenceExpected: criterion.evidenceExpected,
+    blocking: criterion.blocking,
+    weight: criterion.weight
+  }));
+}
+function deriveExecutionContract(plan) {
+  const ec = plan.executionContract;
+  return {
+    summary: ec.summary,
+    deliverables: Array.isArray(ec.deliverables) ? ec.deliverables.slice() : [],
+    requiredChecks: Array.isArray(ec.requiredChecks) ? ec.requiredChecks.slice() : [],
+    requiredEvidence: Array.isArray(ec.requiredEvidence) ? ec.requiredEvidence.slice() : [],
+    focusAreas: Array.isArray(ec.focusAreas) ? ec.focusAreas.slice() : [],
+    checkpointPolicy: ec.checkpointPolicy === "checkpointed" ? "checkpointed" : "final_only",
+    blueprintId: ec.blueprintId,
+    delegationPolicy: ec.delegationPolicy,
+    budgetPolicy: ec.budgetPolicy
+  };
+}
 function buildValidationSection(plan) {
   const parts = [];
-  if (plan.successCriteria?.length) {
-    parts.push("## Success Criteria");
-    plan.successCriteria.forEach((c) => parts.push(`- ${c}`));
+  const acceptanceCriteria = normalizeAcceptanceCriteria(plan);
+  const executionContract = deriveExecutionContract(plan);
+  if (acceptanceCriteria.length) {
+    parts.push("## Acceptance Criteria");
+    acceptanceCriteria.forEach((criterion) => {
+      parts.push(`- **${criterion.id}** [${criterion.category}]${criterion.blocking ? " blocking" : " advisory"} \u2014 ${criterion.description}`);
+      parts.push(`  Verify via: ${criterion.verificationMethod}`);
+      parts.push(`  Evidence expected: ${criterion.evidenceExpected}`);
+      parts.push(`  Weight: ${criterion.weight}`);
+    });
   }
   if (plan.validation?.length) {
     parts.push("", "## Validation Checks");
@@ -120,6 +178,25 @@ function buildValidationSection(plan) {
     parts.push("", "## Deliverables");
     plan.deliverables.forEach((d) => parts.push(`- ${d}`));
   }
+  parts.push("", "## Execution Contract");
+  parts.push(`Summary: ${executionContract.summary}`);
+  parts.push(`Checkpoint policy: ${executionContract.checkpointPolicy}`);
+  if (executionContract.blueprintId) parts.push(`Blueprint: ${executionContract.blueprintId}`);
+  if (executionContract.focusAreas.length) parts.push(`Focus areas: ${executionContract.focusAreas.join(", ")}`);
+  if (executionContract.delegationPolicy) {
+    parts.push(`Delegation policy: ${executionContract.delegationPolicy.mode} (max fanout ${executionContract.delegationPolicy.maxFanout})`);
+  }
+  if (executionContract.budgetPolicy) {
+    parts.push(`Budget policy: local retries=${executionContract.budgetPolicy.maxLocalRetries}, remote rounds=${executionContract.budgetPolicy.maxRemoteRounds}, wall clock=${executionContract.budgetPolicy.maxWallClockMinutes}m`);
+  }
+  if (executionContract.requiredChecks.length) {
+    parts.push("Required checks:");
+    executionContract.requiredChecks.forEach((check) => parts.push(`- ${check}`));
+  }
+  if (executionContract.requiredEvidence.length) {
+    parts.push("Required evidence:");
+    executionContract.requiredEvidence.forEach((evidence) => parts.push(`- ${evidence}`));
+  }
   return parts.join("\n");
 }
 function buildToolingSection(plan) {
@@ -207,6 +284,8 @@ function buildImagePromptSection(imagePaths) {
 function buildExecutionPayload(issue, provider, plan, workspacePath) {
   const strategy = plan.executionStrategy;
   const hasPhases = Boolean(plan.phases?.length);
+  const acceptanceCriteria = normalizeAcceptanceCriteria(plan);
+  const executionContract = deriveExecutionContract(plan);
   return {
     version: 1,
     issue: {
@@ -226,6 +305,7 @@ function buildExecutionPayload(issue, provider, plan, workspacePath) {
     },
     executionIntent: {
       complexity: plan.estimatedComplexity,
+      harnessMode: plan.harnessMode,
       approach: strategy?.approach || "",
       rationale: strategy?.whyThisApproach || "",
       workPattern: hasPhases ? "phased" : "sequential"
@@ -248,9 +328,10 @@ function buildExecutionPayload(issue, provider, plan, workspacePath) {
       }))
     },
     constraints: plan.constraints || [],
-    successCriteria: plan.successCriteria || [],
+    acceptanceCriteria,
     validation: plan.validation || [],
     deliverables: plan.deliverables || [],
+    executionContract,
     assumptions: plan.assumptions || [],
     unknowns: (plan.unknowns || []).map((u) => ({
       question: u.question,
@@ -322,9 +403,6 @@ function extractPlanDirs(plan) {
 
 // src/agents/adapters/usage.ts
 import { cwd, env } from "process";
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
 async function createPtyProcess(command, args) {
   try {
     const nodePty = await import("node-pty");
@@ -415,7 +493,7 @@ function parseResetTime(value) {
 function parseResetDateFromText(raw) {
   const text = normalizeResetText(raw);
   if (!text) return null;
-  const now2 = /* @__PURE__ */ new Date();
+  const now = /* @__PURE__ */ new Date();
   const explicitDateMatch = text.match(/([A-Za-z]{3,9})\s*(\d{1,2})(?:,?|\s+)(\d{1,2}:\d{2}(?:\s*[AaPp][Mm])?)/i) || text.match(/(\d{1,2})\s+([A-Za-z]{3,9})(?:,\s*)?(\d{1,2}:\d{2}(?:\s*[AaPp][Mm])?)/i);
   if (explicitDateMatch) {
     const [, monthRaw, dayRaw, timeRaw] = explicitDateMatch;
@@ -423,12 +501,12 @@ function parseResetDateFromText(raw) {
     const monthIndex = toMonthIndex(monthRaw);
     const time2 = parseResetTime(timeRaw);
     if (!Number.isNaN(day) && monthIndex !== null && time2) {
-      const candidate = new Date(now2);
+      const candidate = new Date(now);
       candidate.setMonth(monthIndex);
       candidate.setDate(day);
       candidate.setHours(time2.hour, time2.minute, 0, 0);
-      if (candidate.getTime() <= now2.getTime()) {
-        candidate.setFullYear(now2.getFullYear() + 1);
+      if (candidate.getTime() <= now.getTime()) {
+        candidate.setFullYear(now.getFullYear() + 1);
       }
       return candidate.toISOString();
     }
@@ -436,9 +514,9 @@ function parseResetDateFromText(raw) {
   const timeMatch = text.match(/(\d{1,2}:\d{2}(?:\s*[AaPp][Mm])?)/i) || text.match(/(\d{1,2})(?:\s*([AaPp][Mm]))/i);
   const time = timeMatch?.[1] ? parseResetTime(timeMatch[1]) : null;
   if (time) {
-    const candidate = new Date(now2);
+    const candidate = new Date(now);
     candidate.setHours(time.hour, time.minute, 0, 0);
-    if (candidate.getTime() <= now2.getTime()) {
+    if (candidate.getTime() <= now.getTime()) {
       candidate.setDate(candidate.getDate() + 1);
     }
     return candidate.toISOString();
@@ -476,10 +554,10 @@ function initSnapshot(raw) {
 }
 function waitForOutput(getOutput, pattern, timeoutMs, pollMs = 100) {
   const deadline = Date.now() + timeoutMs;
-  return new Promise((resolve2) => {
+  return new Promise((resolve) => {
     const check = () => {
-      if (pattern.test(getOutput())) return resolve2(true);
-      if (Date.now() >= deadline) return resolve2(false);
+      if (pattern.test(getOutput())) return resolve(true);
+      if (Date.now() >= deadline) return resolve(false);
       setTimeout(check, pollMs);
     };
     check();
@@ -552,7 +630,6 @@ function parseClaudeUsageFromStatus(raw) {
   const lines = raw.split(/[\r\n]+/).map((line) => line.trim()).filter(Boolean);
   let currentHeading = null;
   let lastPercentSection = null;
-  let lastPercentUsed = null;
   for (const line of lines) {
     const normalized = line.toLowerCase();
     if (/^esc to cancel/i.test(normalized)) continue;
@@ -584,7 +661,6 @@ function parseClaudeUsageFromStatus(raw) {
     if (percentMatch?.[1] && currentHeading) {
       const used = parseInt(percentMatch[1], 10);
       lastPercentSection = currentHeading;
-      lastPercentUsed = used;
       if (currentHeading.section === "current-week-all") {
         base.weeklyPercentUsed = keepLargest(base.weeklyPercentUsed, used);
       }
@@ -613,7 +689,6 @@ function parseClaudeUsageFromStatus(raw) {
         last.nextResetAt = nextResetAt;
       }
       lastPercentSection = null;
-      lastPercentUsed = null;
     }
   }
   const allModelsLine = lines.find((line) => parseClaudeUsageHeading(line)?.section === "current-week-all");
@@ -839,6 +914,16 @@ function collectProviderUsageSnapshotFromCli(command, usageCommand, parseSnapsho
 }
 
 // src/agents/adapters/claude.ts
+var CLAUDE_CAPABILITIES = {
+  readOnlyExecution: "plan",
+  structuredOutput: {
+    mode: "json-schema",
+    requiresToolDisable: true
+  },
+  imageInput: "prompt-inline",
+  usageReporting: "cli-command",
+  nativeSubagents: "native"
+};
 var CLAUDE_USAGE_COMMAND = "/usage";
 var collectClaudeUsageFromCli = () => collectProviderUsageSnapshotFromCli("claude", CLAUDE_USAGE_COMMAND, parseClaudeUsageFromStatus, [
   "--dangerously-skip-permissions"
@@ -852,7 +937,8 @@ function buildClaudeCommand(options) {
   }
   parts.push("--no-session-persistence", "--output-format json");
   if (options.effort) {
-    parts.push(`--effort ${options.effort}`);
+    const claudeEffort = options.effort === "extra-high" ? "max" : options.effort;
+    parts.push(`--effort ${claudeEffort}`);
   }
   if (options.maxBudgetUsd && options.maxBudgetUsd > 0) {
     parts.push(`--max-budget-usd ${options.maxBudgetUsd}`);
@@ -882,6 +968,7 @@ async function compile(issue, provider, plan, config, workspacePath, skillContex
     planPrompt: buildFullPlanPrompt(plan),
     suggestedSkills: plan.suggestedSkills ?? [],
     suggestedAgents: plan.suggestedAgents ?? [],
+    hasNativeSubagents: CLAUDE_CAPABILITIES.nativeSubagents === "native",
     suggestedPaths: plan.suggestedPaths ?? [],
     workspacePath,
     issueIdentifier: issue.identifier,
@@ -905,20 +992,20 @@ async function compile(issue, provider, plan, config, workspacePath, skillContex
     readOnly: isReadOnlyRole,
     maxBudgetUsd: config.maxBudgetUsd
   });
-  const env3 = {
+  const env2 = {
     FIFONY_PLAN_COMPLEXITY: plan.estimatedComplexity,
     FIFONY_PLAN_STEPS: String(plan.steps.length),
     FIFONY_EXECUTION_PAYLOAD_FILE: "execution-payload.json"
   };
-  if (plan.suggestedPaths?.length) env3.FIFONY_PLAN_PATHS = plan.suggestedPaths.join(",");
+  if (plan.suggestedPaths?.length) env2.FIFONY_PLAN_PATHS = plan.suggestedPaths.join(",");
   if (plan.suggestedSkills?.length) {
-    env3.FIFONY_PLAN_SKILLS = plan.suggestedSkills.join(",");
+    env2.FIFONY_PLAN_SKILLS = plan.suggestedSkills.join(",");
   }
   const { pre, post } = extractValidationCommands(plan);
   return {
     prompt,
     command,
-    env: env3,
+    env: env2,
     preHooks: pre,
     postHooks: post,
     outputSchema: CLAUDE_RESULT_SCHEMA,
@@ -927,6 +1014,7 @@ async function compile(issue, provider, plan, config, workspacePath, skillContex
       adapter: "claude",
       reasoningEffort: effort || "default",
       model: provider.model || "default",
+      providerCapabilities: CLAUDE_CAPABILITIES,
       skillsActivated: plan.suggestedSkills || [],
       subagentsRequested: plan.suggestedAgents || [],
       phasesCount: plan.phases?.length || 0
@@ -934,6 +1022,7 @@ async function compile(issue, provider, plan, config, workspacePath, skillContex
   };
 }
 var claudeAdapter = {
+  capabilities: CLAUDE_CAPABILITIES,
   buildCommand: buildClaudeCommand,
   buildReviewCommand: (reviewer, config) => buildClaudeCommand({
     model: reviewer.model,
@@ -948,6 +1037,16 @@ var claudeAdapter = {
 // src/agents/adapters/codex.ts
 import { existsSync as existsSync3 } from "fs";
 import { join as join2 } from "path";
+var CODEX_CAPABILITIES = {
+  readOnlyExecution: "none",
+  structuredOutput: {
+    mode: "prompt-contract",
+    requiresToolDisable: false
+  },
+  imageInput: "cli-flag",
+  usageReporting: "cli-command",
+  nativeSubagents: "runtime-only"
+};
 var CODEX_USAGE_COMMAND = "/status";
 var collectCodexUsageFromCli = () => collectProviderUsageSnapshotFromCli("codex", CODEX_USAGE_COMMAND, parseCodexUsageFromStatus, [
   "--dangerously-bypass-approvals-and-sandbox"
@@ -1016,6 +1115,8 @@ async function compile2(issue, provider, plan, config, workspacePath, skillConte
       goal: phase.goal,
       outputs: phase.outputs ?? []
     })),
+    suggestedAgents: plan.suggestedAgents ?? [],
+    hasNativeSubagents: CODEX_CAPABILITIES.nativeSubagents === "native",
     suggestedPaths: plan.suggestedPaths ?? [],
     suggestedSkills: plan.suggestedSkills ?? [],
     validationItems: (plan.validation ?? []).map((value) => ({ value })),
@@ -1030,18 +1131,18 @@ async function compile2(issue, provider, plan, config, workspacePath, skillConte
     effort,
     imagePaths: issue.images?.filter((p) => existsSync3(p))
   });
-  const env3 = {
+  const env2 = {
     FIFONY_PLAN_COMPLEXITY: plan.estimatedComplexity,
     FIFONY_PLAN_STEPS: String(plan.steps.length),
     FIFONY_PLAN_PHASES: String(plan.phases?.length || 0),
     FIFONY_EXECUTION_PAYLOAD_FILE: "execution-payload.json"
   };
-  if (plan.suggestedPaths?.length) env3.FIFONY_PLAN_PATHS = plan.suggestedPaths.join(",");
+  if (plan.suggestedPaths?.length) env2.FIFONY_PLAN_PATHS = plan.suggestedPaths.join(",");
   const { pre, post } = extractValidationCommands(plan);
   return {
     prompt,
     command,
-    env: env3,
+    env: env2,
     preHooks: pre,
     postHooks: post,
     outputSchema: "",
@@ -1050,13 +1151,15 @@ async function compile2(issue, provider, plan, config, workspacePath, skillConte
       adapter: "codex",
       reasoningEffort: effort || "default",
       model: provider.model || "default",
+      providerCapabilities: CODEX_CAPABILITIES,
       skillsActivated: plan.suggestedSkills || [],
-      subagentsRequested: [],
+      subagentsRequested: plan.suggestedAgents || [],
       phasesCount: plan.phases?.length || 0
     }
   };
 }
 var codexAdapter = {
+  capabilities: CODEX_CAPABILITIES,
   buildCommand: buildCodexCommand,
   buildReviewCommand: (reviewer, _config) => buildCodexCommand({
     model: reviewer.model,
@@ -1069,6 +1172,16 @@ var codexAdapter = {
 // src/agents/adapters/gemini.ts
 import { existsSync as existsSync4 } from "fs";
 import { join as join3 } from "path";
+var GEMINI_CAPABILITIES = {
+  readOnlyExecution: "approval",
+  structuredOutput: {
+    mode: "prompt-contract",
+    requiresToolDisable: false
+  },
+  imageInput: "prompt-inline",
+  usageReporting: "cli-command",
+  nativeSubagents: "runtime-only"
+};
 var GEMINI_USAGE_COMMAND = "/stats session";
 var collectGeminiUsageFromCli = () => collectProviderUsageSnapshotFromCli("gemini", GEMINI_USAGE_COMMAND, parseGeminiUsageFromStatus);
 var GEMINI_RESULT_CONTRACT = `
@@ -1124,6 +1237,8 @@ async function compile3(issue, provider, plan, config, workspacePath, skillConte
       goal: phase.goal,
       outputs: phase.outputs ?? []
     })),
+    suggestedAgents: plan.suggestedAgents ?? [],
+    hasNativeSubagents: GEMINI_CAPABILITIES.nativeSubagents === "native",
     suggestedPaths: plan.suggestedPaths ?? [],
     suggestedSkills: plan.suggestedSkills ?? [],
     validationItems: (plan.validation ?? []).map((value) => ({ value })),
@@ -1142,18 +1257,18 @@ async function compile3(issue, provider, plan, config, workspacePath, skillConte
     addDirs: absoluteDirs,
     readOnly: isReadOnlyRole
   });
-  const env3 = {
+  const env2 = {
     FIFONY_PLAN_COMPLEXITY: plan.estimatedComplexity,
     FIFONY_PLAN_STEPS: String(plan.steps.length),
     FIFONY_PLAN_PHASES: String(plan.phases?.length || 0),
     FIFONY_EXECUTION_PAYLOAD_FILE: "execution-payload.json"
   };
-  if (plan.suggestedPaths?.length) env3.FIFONY_PLAN_PATHS = plan.suggestedPaths.join(",");
+  if (plan.suggestedPaths?.length) env2.FIFONY_PLAN_PATHS = plan.suggestedPaths.join(",");
   const { pre, post } = extractValidationCommands(plan);
   return {
     prompt,
     command,
-    env: env3,
+    env: env2,
     preHooks: pre,
     postHooks: post,
     outputSchema: "",
@@ -1162,13 +1277,15 @@ async function compile3(issue, provider, plan, config, workspacePath, skillConte
       adapter: "gemini",
       reasoningEffort: effort || "default",
       model: provider.model || "default",
+      providerCapabilities: GEMINI_CAPABILITIES,
       skillsActivated: plan.suggestedSkills || [],
-      subagentsRequested: [],
+      subagentsRequested: plan.suggestedAgents || [],
       phasesCount: plan.phases?.length || 0
     }
   };
 }
 var geminiAdapter = {
+  capabilities: GEMINI_CAPABILITIES,
   buildCommand: buildGeminiCommand,
   buildReviewCommand: (reviewer) => buildGeminiCommand({
     model: reviewer.model,
@@ -1183,6 +1300,700 @@ var ADAPTERS = {
   codex: codexAdapter,
   gemini: geminiAdapter
 };
+var UNSUPPORTED_CAPABILITIES = {
+  readOnlyExecution: "none",
+  structuredOutput: {
+    mode: "none",
+    requiresToolDisable: false
+  },
+  imageInput: "none",
+  usageReporting: "none",
+  nativeSubagents: "runtime-only"
+};
+function getProviderCapabilities(provider, overrides) {
+  if (overrides) return overrides;
+  return ADAPTERS[provider]?.capabilities ?? UNSUPPORTED_CAPABILITIES;
+}
+function supportsReadOnlyExecution(capabilities) {
+  return capabilities.readOnlyExecution !== "none";
+}
+function usesNativeStructuredOutput(capabilities) {
+  return capabilities.structuredOutput.mode === "json-schema";
+}
+function supportsNativeSubagents(capabilities) {
+  return capabilities.nativeSubagents === "native";
+}
+function describeProviderCapabilityWarnings(provider, capabilities) {
+  const warnings = [];
+  if (!supportsReadOnlyExecution(capabilities)) {
+    warnings.push(`${provider} does not expose CLI-enforced read-only execution; planner/reviewer runs fall back to prompt/runtime discipline.`);
+  }
+  if (!usesNativeStructuredOutput(capabilities)) {
+    warnings.push(`${provider} does not expose native JSON schema enforcement; structured output falls back to prompt-contract parsing.`);
+  }
+  if (!supportsNativeSubagents(capabilities)) {
+    warnings.push(`${provider} does not expose native subagents; delegation will use Fifony runtime orchestration instead.`);
+  }
+  if (capabilities.usageReporting === "none") {
+    warnings.push(`${provider} does not expose usage reporting; provider budget telemetry may be incomplete.`);
+  }
+  return warnings;
+}
+
+// src/agents/providers.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir2 } from "os";
+
+// 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 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 uiScore = scores.find((entry) => entry.name === "ui-polish");
+  if (paths.some((path) => UI_EXTENSIONS.some((ext) => path.endsWith(ext)))) {
+    uiScore.score += 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 += 3;
+    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 += 5;
+    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 += 3;
+    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 += 5;
+    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 += 2;
+    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 += 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 += 2;
+    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") || includesAny(text, ["auth", "security", "token", "permission", "secret"])) {
+    securityScore.score += 5;
+    securityScore.rationale.push("Security-sensitive behavior or criteria are present and should be treated as blocking by default.");
+  }
+  if (hasPath(paths, /auth|permission|secret|credential|shell|command-executor/)) {
+    securityScore.score += 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";
+  const highCheckpointRisk = HIGH_CHECKPOINT_PROFILES.has(profile.primary) && !lowScope;
+  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.`
+      };
+    }
+  }
+  if (currentCheckpointPolicy === "checkpointed" && lowScope) {
+    return {
+      checkpointPolicy: "final_only",
+      profile,
+      basis: "heuristic",
+      rationale: `Disabled checkpoint review because ${complexity} contractual work should keep the contract gate but avoid an intermediate review pass.`
+    };
+  }
+  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 (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.`
+  };
+}
 
 // src/agents/model-discovery.ts
 import { execFileSync } from "child_process";
@@ -1191,17 +2002,6 @@ import { join as join4, dirname } from "path";
 import { homedir } from "os";
 var modelCache = /* @__PURE__ */ new Map();
 var MODEL_CACHE_TTL_MS = 5 * 60 * 1e3;
-function readClaudeConfig() {
-  try {
-    const settingsPath = join4(homedir(), ".claude", "settings.json");
-    if (!existsSync5(settingsPath)) return {};
-    const raw = readFileSync2(settingsPath, "utf8");
-    const settings = JSON.parse(raw);
-    return { model: typeof settings.model === "string" ? settings.model : void 0 };
-  } catch {
-    return {};
-  }
-}
 function resolveGeminiModelsFile() {
   try {
     const binPath = execFileSync("which", ["gemini"], { encoding: "utf8", timeout: 3e3 }).trim();
@@ -1343,6 +2143,18 @@ function normalizeAgentProvider(value) {
   if (!normalized) return "codex";
   return normalized;
 }
+function resolveProviderCapabilities(provider, overrides) {
+  return getProviderCapabilities(provider, overrides ?? null);
+}
+function getProviderCapabilityWarnings(provider, overrides) {
+  return describeProviderCapabilityWarnings(provider, resolveProviderCapabilities(provider, overrides));
+}
+function resolveAgentCommand(provider, explicitCommand, codexCommand, claudeCommand, reasoningEffort) {
+  if (explicitCommand.trim()) return explicitCommand.trim();
+  if (provider === "claude" && claudeCommand.trim()) return claudeCommand.trim();
+  if (provider === "codex" && codexCommand.trim()) return codexCommand.trim();
+  return getProviderDefaultCommand(provider, reasoningEffort);
+}
 function resolveEffort(role, issueEffort, globalEffort) {
   const roleKey = role;
   if (issueEffort?.[roleKey]) return issueEffort[roleKey];
@@ -1353,7 +2165,8 @@ function resolveEffort(role, issueEffort, globalEffort) {
 function getProviderDefaultCommand(provider, reasoningEffort, model) {
   const adapter = ADAPTERS[provider];
   if (!adapter) return "";
-  const jsonSchema = provider === "claude" ? CLAUDE_RESULT_SCHEMA : void 0;
+  const capabilities = resolveProviderCapabilities(provider);
+  const jsonSchema = usesNativeStructuredOutput(capabilities) ? CLAUDE_RESULT_SCHEMA : void 0;
   return adapter.buildCommand({ model, effort: reasoningEffort, jsonSchema });
 }
 var cachedProviders = null;
@@ -1365,11 +2178,12 @@ function detectAvailableProviders() {
   }
   const providers = [];
   for (const name of ["claude", "codex", "gemini"]) {
+    const capabilities = resolveProviderCapabilities(name);
     try {
       const path = execFileSync2("which", [name], { encoding: "utf8", timeout: 5e3 }).trim();
-      providers.push({ name, available: true, path });
+      providers.push({ name, available: true, path, capabilities });
     } catch {
-      providers.push({ name, available: false, path: "" });
+      providers.push({ name, available: false, path: "", capabilities });
     }
   }
   cachedProviders = providers;
@@ -1402,23 +2216,133 @@ function readGeminiConfig() {
     return {};
   }
 }
+function readClaudeConfig() {
+  try {
+    const settingsPath = join5(homedir2(), ".claude", "settings.json");
+    if (!existsSync6(settingsPath)) return {};
+    const raw = readFileSync3(settingsPath, "utf8");
+    const settings = JSON.parse(raw);
+    return {
+      model: typeof settings.model === "string" ? settings.model : void 0
+    };
+  } catch {
+    return {};
+  }
+}
 function resolveDefaultProvider(detected) {
   const available = detected.filter((p) => p.available);
   if (available.length === 0) return "";
   if (available.some((p) => p.name === "codex")) return "codex";
   return available[0].name;
 }
-function getBaseAgentProviders(state) {
-  return [
-    {
-      provider: state.config.agentProvider,
-      role: "executor",
-      command: state.config.agentCommand,
-      profile: "",
-      profilePath: "",
-      profileInstructions: ""
-    }
-  ];
+var EFFORT_ORDER = ["low", "medium", "high", "extra-high"];
+var REVIEW_PROFILE_MIN_EFFORT = {
+  "general-quality": "medium",
+  "ui-polish": "high",
+  "workflow-fsm": "high",
+  "integration-safety": "high",
+  "api-contract": "high",
+  "security-hardening": "extra-high"
+};
+var REVIEW_PROFILE_OVERLAYS = {
+  "general-quality": [],
+  "ui-polish": ["impeccable", "frontend-design"],
+  "workflow-fsm": ["workflow-audit"],
+  "integration-safety": ["integration-safety"],
+  "api-contract": ["api-contract"],
+  "security-hardening": ["security-hardening"]
+};
+function maxEffort(left, right) {
+  if (!left) return right;
+  if (!right) return left;
+  return EFFORT_ORDER[Math.max(EFFORT_ORDER.indexOf(left), EFFORT_ORDER.indexOf(right))] ?? left;
+}
+function stageToRole(stage) {
+  if (stage === "plan") return "planner";
+  if (stage === "review") return "reviewer";
+  return "executor";
+}
+function buildStageProvider(state, issue, stage, workflowConfig) {
+  const role = stageToRole(stage);
+  const stageConfig = workflowConfig?.[roleToStageKey(stageToRole(stage))];
+  const effort = stageConfig?.effort || resolveEffort(role, issue.effort, state.config.defaultEffort);
+  const providerName = stageConfig?.provider || state.config.agentProvider;
+  const model = stageConfig?.model || void 0;
+  const command = stageConfig ? getProviderDefaultCommand(providerName, effort, model) : stage === "execute" ? resolveAgentCommand(providerName, state.config.agentCommand, "", "", effort) : getProviderDefaultCommand(providerName, effort, model);
+  return {
+    provider: providerName,
+    role,
+    command,
+    model,
+    profile: "",
+    profilePath: "",
+    profileInstructions: "",
+    reasoningEffort: effort,
+    selectionReason: stageConfig ? `Using workflow ${stage} stage configuration.` : `Using default ${stage} stage provider configuration.`,
+    overlays: [],
+    capabilities: resolveProviderCapabilities(providerName)
+  };
+}
+function specializeReviewerProvider(baseProvider, issue) {
+  const reviewProfile = issue.reviewProfile ?? deriveReviewProfile(issue);
+  const minEffort = REVIEW_PROFILE_MIN_EFFORT[reviewProfile.primary];
+  const reasoningEffort = maxEffort(baseProvider.reasoningEffort, minEffort);
+  const overlays = [.../* @__PURE__ */ new Set([...baseProvider.overlays ?? [], ...REVIEW_PROFILE_OVERLAYS[reviewProfile.primary]])];
+  const command = getProviderDefaultCommand(baseProvider.provider, reasoningEffort, baseProvider.model) || baseProvider.command;
+  return {
+    ...baseProvider,
+    command,
+    reasoningEffort,
+    overlays,
+    selectionReason: `Reviewer specialized for ${reviewProfile.primary}; raised scrutiny with ${reasoningEffort ?? "default"} effort.`
+  };
+}
+function resolveSynchronousProviderModel(provider, workflowConfig) {
+  const stages = workflowConfig ? [workflowConfig.review, workflowConfig.execute, workflowConfig.plan] : [];
+  const fromWorkflow = stages.find((stage) => stage?.provider === provider)?.model;
+  if (fromWorkflow) return fromWorkflow;
+  if (provider === "codex") return readCodexConfig().model;
+  if (provider === "gemini") return readGeminiConfig().model;
+  if (provider === "claude") return readClaudeConfig().model;
+  return void 0;
+}
+function buildAdaptiveReviewCandidates(baseProvider, workflowConfig) {
+  const availableProviders = detectAvailableProviders().filter((provider) => provider.available).map((provider) => provider.name);
+  const candidates = /* @__PURE__ */ new Map();
+  const addCandidate = (providerName, reason) => {
+    const model = resolveSynchronousProviderModel(providerName, workflowConfig ?? null);
+    const command = getProviderDefaultCommand(providerName, baseProvider.reasoningEffort, model) || baseProvider.command;
+    const candidate = {
+      ...baseProvider,
+      provider: providerName,
+      model,
+      command,
+      selectionReason: reason,
+      capabilities: resolveProviderCapabilities(providerName)
+    };
+    candidates.set(buildReviewRouteKey(candidate), candidate);
+  };
+  addCandidate(baseProvider.provider, baseProvider.selectionReason || "Configured review route.");
+  for (const providerName of availableProviders) {
+    if (providerName === baseProvider.provider) continue;
+    addCandidate(providerName, `Adaptive routing candidate using available ${providerName} reviewer.`);
+  }
+  return [...candidates.values()];
+}
+function adaptReviewerProvider(state, issue, baseProvider, workflowConfig) {
+  if (state.config.adaptiveReviewRouting === false) return baseProvider;
+  const candidates = buildAdaptiveReviewCandidates(baseProvider, workflowConfig ?? null);
+  const recommendation = recommendReviewRouteForIssue(
+    state.issues,
+    issue,
+    candidates,
+    state.config.adaptivePolicyMinSamples ?? 3
+  );
+  if (!recommendation) return baseProvider;
+  return {
+    ...recommendation.candidate,
+    selectionReason: `${recommendation.rationale} ${baseProvider.selectionReason ?? ""}`.trim()
+  };
 }
 function roleToStageKey(role) {
   switch (role) {
@@ -1430,1020 +2354,45 @@ function roleToStageKey(role) {
       return "review";
   }
 }
-function applyWorkflowConfigToProviders(providers, workflowConfig) {
-  if (!workflowConfig) return providers;
-  return providers.map((provider) => {
-    const stageKey = roleToStageKey(provider.role);
-    const stageConfig = workflowConfig[stageKey];
-    if (!stageConfig) return provider;
-    const newProvider = stageConfig.provider || provider.provider;
-    const newModel = stageConfig.model || void 0;
-    const newEffort = stageConfig.effort || provider.reasoningEffort;
-    const command = getProviderDefaultCommand(newProvider, newEffort, newModel);
-    return {
-      ...provider,
-      provider: newProvider,
-      model: newModel,
-      command: command || provider.command,
-      reasoningEffort: newEffort
-    };
-  });
+function getExecutionProviders(state, issue, workflowConfig) {
+  return [buildStageProvider(state, issue, "execute", workflowConfig ?? null)];
 }
-function getEffectiveAgentProviders(state, issue, _workflowDefinition, workflowConfig) {
-  const baseProviders = getBaseAgentProviders(state);
-  const providers = baseProviders.map((provider) => {
-    const effort = resolveEffort(provider.role, issue.effort, state.config.defaultEffort);
-    return {
-      ...provider,
-      reasoningEffort: effort
-    };
-  });
-  return applyWorkflowConfigToProviders(providers, workflowConfig ?? null);
+function getReviewProvider(state, issue, workflowConfig) {
+  const specialized = specializeReviewerProvider(buildStageProvider(state, issue, "review", workflowConfig ?? null), issue);
+  return adaptReviewerProvider(state, issue, specialized, workflowConfig ?? null);
 }
-
-// src/agents/command-executor.ts
-var HOOK_RUNTIME_CONFIG = {
-  pollIntervalMs: 0,
-  workerConcurrency: 1,
-  maxConcurrentByState: {},
-  commandTimeoutMs: 18e5,
-  maxAttemptsDefault: 1,
-  maxTurns: 1,
-  retryDelayMs: 0,
-  staleInProgressTimeoutMs: 0,
-  logLinesTail: 12e3,
-  maxPreviousOutputChars: 12e3,
-  agentProvider: "codex",
-  agentCommand: "",
-  defaultEffort: { default: "medium" },
-  runMode: "filesystem",
-  autoReviewApproval: true,
-  afterCreateHook: "",
-  beforeRunHook: "",
-  afterRunHook: "",
-  beforeRemoveHook: ""
-};
-async function runCommandWithTimeout(command, workspacePath, issue, config, promptText, promptFile, extraEnv = {}, outputFile) {
-  return new Promise((resolve2) => {
-    const started = Date.now();
-    const resultFile = extraEnv.FIFONY_RESULT_FILE;
-    if (resultFile && extraEnv.FIFONY_PRESERVE_RESULT_FILE !== "1") {
-      rmSync(resultFile, { force: true });
-    }
-    const allVars = {
-      FIFONY_ISSUE_ID: issue.id,
-      FIFONY_ISSUE_IDENTIFIER: issue.identifier,
-      FIFONY_ISSUE_TITLE: issue.title,
-      FIFONY_WORKSPACE_PATH: issue.worktreePath ?? workspacePath,
-      FIFONY_PROMPT_FILE: promptFile
-    };
-    for (const [key, value] of Object.entries(extraEnv)) {
-      if (value.length > 4e3) {
-        const valFile = join6(workspacePath, `${key.toLowerCase()}.txt`);
-        writeFileSync(valFile, value, "utf8");
-        allVars[`${key}_FILE`] = valFile;
-      } else {
-        allVars[key] = value;
-      }
-    }
-    const envFilePath = join6(workspacePath, ".env.sh");
-    const envFileLines = Object.entries(allVars).map(([k, v]) => `export ${k}='${String(v).replace(/'/g, "'\\''")}'`).join("\n");
-    writeFileSync(envFilePath, envFileLines, "utf8");
-    const wrappedCommand = `. "${envFilePath}" && ${command}`;
-    const child = spawn(wrappedCommand, {
-      shell: true,
-      cwd: issue.worktreePath ?? workspacePath,
-      detached: true,
-      // Survive parent death
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    child.unref();
-    if (child.stdin) {
-      child.stdin.end();
-    }
-    const pidFile = join6(workspacePath, "agent.pid");
-    const pid = child.pid;
-    if (pid) {
-      logger.debug({ issueId: issue.id, pid, command: command.slice(0, 120), cwd: workspacePath }, "[Agent] Process spawned");
-      writeFileSync(pidFile, JSON.stringify({
-        pid,
-        issueId: issue.id,
-        startedAt: new Date(started).toISOString(),
-        command: command.slice(0, 200)
-      }), "utf8");
-    }
-    let output = "";
-    let timedOut = false;
-    let outputBytes = 0;
-    let outputHeader = "";
-    const liveLogFile = join6(workspacePath, "live-output.log");
-    writeFileSync(liveLogFile, "", "utf8");
-    if (outputFile) {
-      try {
-        const header = `# fifony stdout capture
-# turn: ${extraEnv.FIFONY_TURN_INDEX ?? "?"}
-# provider: ${extraEnv.FIFONY_AGENT_PROVIDER ?? "?"}
-# role: ${extraEnv.FIFONY_AGENT_ROLE ?? "?"}
-# timestamp: ${(/* @__PURE__ */ new Date()).toISOString()}
----
-`;
-        writeFileSync(outputFile, header, "utf8");
-      } catch {
-      }
-    }
-    const onChunk = (chunk) => {
-      const text = String(chunk);
-      if (outputHeader.length < 2e3) outputHeader = (outputHeader + text).slice(0, 2e3);
-      output = appendFileTail(output, text, config.logLinesTail);
-      outputBytes += text.length;
-      try {
-        appendFileSync(liveLogFile, text);
-      } catch {
-      }
-      if (outputFile) {
-        try {
-          appendFileSync(outputFile, text);
-        } catch {
-        }
-      }
-      issue.commandOutputTail = output;
-    };
-    child.stdout?.on("data", onChunk);
-    child.stderr?.on("data", onChunk);
-    const AGENT_STALE_OUTPUT_MS = 18e5;
-    const timer = setTimeout(() => {
-      timedOut = true;
-      if (pid) {
-        try {
-          process.kill(-pid, "SIGTERM");
-        } catch {
-        }
-      } else {
-        child.kill("SIGTERM");
-      }
-    }, config.commandTimeoutMs);
-    let lastWatchdogBytes = 0;
-    let lastOutputGrowthAt = Date.now();
-    let watchdogKilled = false;
-    const watchdog = setInterval(() => {
-      if (pid) {
-        try {
-          process.kill(pid, 0);
-        } catch {
-          clearInterval(watchdog);
-          clearTimeout(timer);
-          watchdogKilled = true;
-          try {
-            rmSync(pidFile, { force: true });
-          } catch {
-          }
-          resolve2({ success: false, code: null, output: appendFileTail(output, `
-Agent process died unexpectedly (PID ${pid}).`, config.logLinesTail) });
-          return;
-        }
-      }
-      if (outputBytes > lastWatchdogBytes) {
-        lastWatchdogBytes = outputBytes;
-        lastOutputGrowthAt = Date.now();
-      } else if (Date.now() - lastOutputGrowthAt > AGENT_STALE_OUTPUT_MS) {
-        clearInterval(watchdog);
-        clearTimeout(timer);
-        timedOut = true;
-        watchdogKilled = true;
-        if (pid) {
-          try {
-            process.kill(-pid, "SIGTERM");
-          } catch {
-          }
-        } else {
-          child.kill("SIGTERM");
-        }
-        try {
-          rmSync(pidFile, { force: true });
-        } catch {
-        }
-        resolve2({ success: false, code: null, output: appendFileTail(output, `
-Agent process stuck \u2014 no output for ${Math.round(AGENT_STALE_OUTPUT_MS / 6e4)} minutes.`, config.logLinesTail) });
-      }
-    }, 3e4);
-    const cleanup = () => {
-      clearInterval(watchdog);
-      try {
-        rmSync(pidFile, { force: true });
-      } catch {
-      }
-    };
-    child.on("error", () => {
-      clearTimeout(timer);
-      cleanup();
-      if (watchdogKilled) return;
-      resolve2({ success: false, code: null, output: `Command execution failed for issue ${issue.id}.` });
-    });
-    child.on("close", (code) => {
-      clearTimeout(timer);
-      cleanup();
-      if (watchdogKilled) return;
-      const buildOutput = (suffix) => {
-        const tail = appendFileTail(output, suffix, config.logLinesTail);
-        return outputHeader.length > 0 && !tail.startsWith(outputHeader.slice(0, 80)) ? `${outputHeader}
-${tail}` : tail;
-      };
-      if (timedOut) {
-        resolve2({ success: false, code: null, output: buildOutput(`
-Execution timeout after ${config.commandTimeoutMs}ms.`) });
-        return;
-      }
-      const duration = Math.max(0, Date.now() - started);
-      if (code === 0) {
-        resolve2({ success: true, code, output: buildOutput(`
-Execution succeeded in ${duration}ms.`) });
-        return;
-      }
-      resolve2({ success: false, code, output: buildOutput(`
-Command exit code ${code ?? "unknown"} after ${duration}ms.`) });
-    });
-  });
-}
-async function runHook(command, workspacePath, issue, hookName, extraEnv = {}) {
-  if (!command.trim()) return;
-  const result = await runCommandWithTimeout(command, workspacePath, issue, {
-    ...HOOK_RUNTIME_CONFIG,
-    agentProvider: normalizeAgentProvider(env2.FIFONY_AGENT_PROVIDER ?? "codex"),
-    agentCommand: command
-  }, "", "", { FIFONY_HOOK_NAME: hookName, ...extraEnv });
-  if (!result.success) {
-    throw new Error(`${hookName} hook failed: ${result.output}`);
-  }
-}
-
-// src/agents/prompt-builder.ts
-function buildRetryContext(issue) {
-  const summaries = issue.previousAttemptSummaries;
-  if (!summaries || summaries.length === 0) return "";
-  const lines = ["## Previous Attempts\n"];
-  lines.push("The following previous attempts FAILED. Do NOT repeat the same approach. Try a fundamentally different strategy.\n");
-  for (let i = 0; i < summaries.length; i++) {
-    const s = summaries[i];
-    const phaseLabel = s.phase === "review" ? "review" : s.phase === "crash" ? "crash" : s.phase === "plan" ? "plan" : "execution";
-    lines.push(`### Attempt ${i + 1} \u2014 ${phaseLabel} failure (plan v${s.planVersion}, exec #${s.executeAttempt})`);
-    if (s.phase === "review") {
-      lines.push("*The reviewer identified issues with the previous implementation. Focus on addressing the reviewer's feedback \u2014 do not redo work that was already approved.*");
-    } else if (s.phase === "crash") {
-      lines.push("*The agent process crashed or timed out. Simplify the approach \u2014 break the work into smaller steps.*");
-    }
-    if (s.insight) {
-      lines.push(`**Failure type:** ${s.insight.errorType}`);
-      lines.push(`**Root cause:** ${s.insight.rootCause}`);
-      if (s.insight.failedCommand) lines.push(`**Failed command:** \`${s.insight.failedCommand}\``);
-      if (s.insight.filesInvolved.length > 0) {
-        lines.push(`**Files involved:** ${s.insight.filesInvolved.map((f) => `\`${f}\``).join(", ")}`);
-      }
-      lines.push(`**What to do differently:** ${s.insight.suggestion}`);
-    } else {
-      lines.push(`**Error:** ${s.error}`);
-    }
-    if (s.outputTail) {
-      lines.push(`
-<details><summary>Output tail</summary>
-
-\`\`\`
-${s.outputTail}
-\`\`\`
-</details>`);
-    }
-    if (s.outputFile) {
-      lines.push(`*Full output saved in: outputs/${s.outputFile}*`);
-    }
-    lines.push("");
-  }
-  const full = lines.join("\n");
-  return full.length > 8e3 ? full.slice(0, 8e3) + "\n[...truncated]" : full;
-}
-async function buildPrompt(issue, _workflowDefinition) {
-  const rendered = await renderPrompt("workflow-default", { issue, attempt: issue.attempts || 0 });
-  if (!issue.plan?.steps?.length) {
-    return rendered;
-  }
-  const planSection = await renderPrompt("workflow-plan-section", {
-    estimatedComplexity: issue.plan.estimatedComplexity,
-    summary: issue.plan.summary,
-    steps: issue.plan.steps.map((step) => ({
-      step: step.step,
-      action: step.action,
-      files: step.files ?? [],
-      details: step.details ?? ""
-    }))
-  });
-  return `${rendered}
-
-${planSection}`;
-}
-async function buildTurnPrompt(issue, basePrompt, previousOutput, turnIndex, maxTurns, nextPrompt) {
-  if (turnIndex === 1) return basePrompt;
-  return renderPrompt("agent-turn", {
-    issueIdentifier: issue.identifier,
-    turnIndex,
-    maxTurns,
-    basePrompt,
-    continuation: nextPrompt.trim() || "Continue the work, inspect the workspace, and move the issue toward completion.",
-    outputTail: previousOutput.trim() || "No previous output captured."
-  });
-}
-async function buildProviderBasePrompt(provider, issue, basePrompt, workspacePath, skillContext, capabilitiesManifest) {
-  return renderPrompt("agent-provider-base", {
-    isPlanner: provider.role === "planner",
-    isReviewer: provider.role === "reviewer",
-    hasImpeccableOverlay: provider.overlays?.includes("impeccable") ?? false,
-    hasFrontendDesignOverlay: provider.overlays?.includes("frontend-design") ?? false,
-    profileInstructions: provider.profileInstructions || "",
-    skillContext,
-    capabilitiesManifest: capabilitiesManifest || "",
-    capabilityCategory: "",
-    selectionReason: provider.selectionReason ?? "",
-    overlays: provider.overlays ?? [],
-    targetPaths: issue.paths ?? [],
-    workspacePath,
-    basePrompt
-  });
-}
-
-// src/domains/workspace.ts
-var SKIP_DIRS = /* @__PURE__ */ new Set([
-  ".git",
-  ".fifony",
-  "node_modules",
-  ".venv",
-  "data",
-  "dist",
-  "build",
-  ".turbo",
-  ".next",
-  ".nuxt",
-  ".tanstack",
-  "coverage",
-  "artifacts",
-  "captures",
-  "tmp",
-  "temp"
-]);
-function shouldSkipPath(relativePath) {
-  const parts = relativePath.split("/");
-  if (parts.some((segment) => SKIP_DIRS.has(segment))) return true;
-  const base = parts.at(-1) ?? "";
-  if (base.startsWith("map_scan_") && extname2(base) === ".json") return true;
-  if (extname2(base) === ".xlsx") return true;
-  return false;
-}
-function bootstrapSource() {
-  if (existsSync7(SOURCE_MARKER)) return;
-  logger.info("Creating local source snapshot for Fifony (local-only runtime)...");
-  const copyRecursive = (source, target, rel = "") => {
-    mkdirSync(target, { recursive: true });
-    const items = readdirSync(source, { withFileTypes: true });
-    for (const item of items) {
-      const nextRel = rel ? `${rel}/${item.name}` : item.name;
-      if (shouldSkipPath(nextRel)) continue;
-      const sourcePath = `${source}/${item.name}`;
-      const targetPath = `${target}/${item.name}`;
-      const itemStat = statSync(sourcePath);
-      if (item.isDirectory()) {
-        copyRecursive(sourcePath, targetPath, nextRel);
-        continue;
-      }
-      if (item.isSymbolicLink() || itemStat.isSymbolicLink()) continue;
-      if (itemStat.isFile() || itemStat.isFIFO()) {
-        try {
-          const file = readFileSync4(sourcePath);
-          writeFileSync2(targetPath, file);
-        } catch (error) {
-          if (error.code === "ENOENT") {
-            logger.debug(`Skipped missing source file: ${sourcePath}`);
-          } else {
-            throw error;
-          }
-        }
-      }
-    }
-  };
-  mkdirSync(SOURCE_ROOT, { recursive: true });
-  copyRecursive(TARGET_ROOT, SOURCE_ROOT);
-  writeFileSync2(SOURCE_MARKER, `${now()}
-`, "utf8");
-}
-var sourceReadyPromise = null;
-var skipSourceFlag = false;
-function setSkipSource(skip) {
-  skipSourceFlag = skip;
-}
-async function ensureSourceReady(onProgress) {
-  if (skipSourceFlag) {
-    onProgress?.("ready");
-    return;
-  }
-  if (existsSync7(SOURCE_MARKER)) {
-    onProgress?.("ready");
-    return;
-  }
-  if (sourceReadyPromise) return sourceReadyPromise;
-  sourceReadyPromise = (async () => {
-    onProgress?.("copying");
-    logger.info("Creating local source snapshot (async) for Fifony...");
-    const copyRecursiveAsync = async (source, target, rel = "") => {
-      await mkdir(target, { recursive: true });
-      const items = await readdir(source, { withFileTypes: true });
-      for (const item of items) {
-        const nextRel = rel ? `${rel}/${item.name}` : item.name;
-        if (shouldSkipPath(nextRel)) continue;
-        const sourcePath = `${source}/${item.name}`;
-        const targetPath = `${target}/${item.name}`;
-        const itemStat = await stat(sourcePath);
-        if (item.isDirectory()) {
-          await copyRecursiveAsync(sourcePath, targetPath, nextRel);
-          continue;
-        }
-        if (item.isSymbolicLink() || itemStat.isSymbolicLink()) continue;
-        if (itemStat.isFile() || itemStat.isFIFO()) {
-          try {
-            await copyFile(sourcePath, targetPath);
-          } catch (error) {
-            if (error.code === "ENOENT") {
-              logger.debug(`Skipped missing source file: ${sourcePath}`);
-            } else {
-              throw error;
-            }
-          }
-        }
-      }
-    };
-    await mkdir(SOURCE_ROOT, { recursive: true });
-    await copyRecursiveAsync(TARGET_ROOT, SOURCE_ROOT);
-    await writeFile(SOURCE_MARKER, `${now()}
-`, "utf8");
-    onProgress?.("ready");
-    logger.info("Source snapshot ready (async).");
-  })();
-  return sourceReadyPromise;
-}
-function getGitRepoStatus(dir) {
-  const isGit = (() => {
-    try {
-      execSync("git rev-parse --git-dir", { cwd: dir, stdio: "pipe" });
-      return true;
-    } catch {
-      return false;
-    }
-  })();
-  if (!isGit) {
-    return { isGit: false, hasCommits: false, branch: null };
-  }
-  const branch = (() => {
-    try {
-      return execSync("git symbolic-ref --short HEAD", { cwd: dir, encoding: "utf8", stdio: "pipe" }).trim() || null;
-    } catch {
-      try {
-        return execSync("git rev-parse --abbrev-ref HEAD", { cwd: dir, encoding: "utf8", stdio: "pipe" }).trim() || null;
-      } catch {
-        return null;
-      }
-    }
-  })();
-  const hasCommits = (() => {
-    try {
-      execSync("git rev-parse --verify HEAD", { cwd: dir, stdio: "pipe" });
-      return true;
-    } catch {
-      return false;
-    }
-  })();
-  let isClean = true;
-  let untrackedCount = 0;
-  if (hasCommits) {
-    try {
-      const porcelain = execSync("git status --porcelain", { cwd: dir, encoding: "utf8", timeout: 5e3 }).trim();
-      isClean = porcelain.length === 0;
-      untrackedCount = porcelain.split("\n").filter((l) => l.startsWith("??")).length;
-    } catch {
-    }
-  }
-  return { isGit: true, hasCommits, branch, isClean, untrackedCount };
-}
-function gitRequirementMessage(action) {
-  return `fifony requires a git repository with at least one commit to ${action}. Initialize git in this project and create an initial commit, or use the onboarding Setup step.`;
-}
-function ensureGitRepoReadyForWorktrees(dir, action = "run issue worktrees") {
-  const status = getGitRepoStatus(dir);
-  if (!status.isGit) {
-    throw new Error(gitRequirementMessage(action));
-  }
-  if (!status.hasCommits) {
-    throw new Error(`fifony requires at least one commit to ${action} because git worktree needs a base commit. Create an initial commit, then retry.`);
-  }
-  return status;
-}
-function initializeGitRepoForWorktrees(dir) {
-  let status = getGitRepoStatus(dir);
-  if (!status.isGit) {
-    try {
-      execSync("git init -b main", { cwd: dir, stdio: "pipe" });
-    } catch {
-      execSync("git init", { cwd: dir, stdio: "pipe" });
-    }
-    status = getGitRepoStatus(dir);
-  }
-  if (!status.hasCommits) {
-    execSync(
-      'git -c user.name="fifony" -c user.email="fifony@local.invalid" commit --allow-empty -m "Initial commit"',
-      { cwd: dir, stdio: "pipe" }
-    );
-    status = getGitRepoStatus(dir);
-  }
-  return status;
-}
-function assertIssueHasGitWorktree(issue, action) {
-  if (!issue.branchName || !issue.baseBranch || !issue.worktreePath) {
-    throw new Error(
-      `Issue ${issue.identifier} has no git worktree \u2014 cannot ${action}. This usually means the issue was executed before git was initialized for the project. Initialize git, then re-run the issue.`
-    );
-  }
-}
-function detectDefaultBranch(dir) {
-  try {
-    const current = execSync("git rev-parse --abbrev-ref HEAD", { cwd: dir, encoding: "utf8" }).trim();
-    if (current && current !== "HEAD") return current;
-    const remote = execSync("git symbolic-ref refs/remotes/origin/HEAD", { cwd: dir, encoding: "utf8" }).trim();
-    return remote.replace("refs/remotes/origin/", "");
-  } catch {
-    return "main";
-  }
-}
-var CLI_CONFIG_DIRS = [".claude", ".codex", ".gemini"];
-var CLI_CONFIG_FILES = ["CLAUDE.md"];
-function copyCliConfigDirs(sourceRoot, worktreePath) {
-  for (const dir of CLI_CONFIG_DIRS) {
-    const src = join7(sourceRoot, dir);
-    const dst = join7(worktreePath, dir);
-    if (existsSync7(src) && statSync(src).isDirectory() && !existsSync7(dst)) {
-      try {
-        execSync(`cp -R "${src}" "${dst}"`, { stdio: "pipe", timeout: 1e4 });
-        logger.debug({ dir, worktreePath }, "[Workspace] Copied CLI config dir to worktree");
-      } catch (err) {
-        logger.warn({ err: String(err), dir }, "[Workspace] Failed to copy CLI config dir");
-      }
-    }
-  }
-  for (const file of CLI_CONFIG_FILES) {
-    const src = join7(sourceRoot, file);
-    const dst = join7(worktreePath, file);
-    if (existsSync7(src) && !existsSync7(dst)) {
-      try {
-        execSync(`cp "${src}" "${dst}"`, { stdio: "pipe", timeout: 5e3 });
-        logger.debug({ file, worktreePath }, "[Workspace] Copied CLI config file to worktree");
-      } catch (err) {
-        logger.warn({ err: String(err), file }, "[Workspace] Failed to copy CLI config file");
-      }
-    }
-  }
-}
-function isGitWorkingTree(dir) {
-  try {
-    execSync("git rev-parse --git-dir", { cwd: dir, stdio: "pipe", timeout: 5e3 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function resolveTestWorkspacePath(issue) {
-  const workspaceRoot = issue.workspacePath ?? join7(WORKSPACE_ROOT, idToSafePath(issue.id));
-  return join7(workspaceRoot, "test-worktree");
-}
-function createTestWorkspace(issue) {
-  ensureGitRepoReadyForWorktrees(TARGET_ROOT, "create isolated test workspaces");
-  assertIssueHasGitWorktree(issue, "create a test workspace");
-  const workspaceRoot = issue.workspacePath ?? join7(WORKSPACE_ROOT, idToSafePath(issue.id));
-  const testWorkspacePath = issue.testWorkspacePath ?? resolveTestWorkspacePath(issue);
-  mkdirSync(workspaceRoot, { recursive: true });
-  if (existsSync7(testWorkspacePath)) {
-    if (isGitWorkingTree(testWorkspacePath)) {
-      issue.testWorkspacePath = testWorkspacePath;
-      issue.testApplied = true;
-      return testWorkspacePath;
-    }
-    rmSync2(testWorkspacePath, { recursive: true, force: true });
-  }
-  try {
-    execSync(`git worktree add --detach "${testWorkspacePath}" "${issue.branchName}"`, {
-      cwd: TARGET_ROOT,
-      stdio: "pipe",
-      timeout: 3e4
-    });
-  } catch (err) {
-    const msg = err.stderr || err.stdout || String(err);
-    throw new Error(`Failed to create isolated test workspace: ${msg}`);
-  }
-  copyCliConfigDirs(TARGET_ROOT, testWorkspacePath);
-  issue.testWorkspacePath = testWorkspacePath;
-  issue.testApplied = true;
-  return testWorkspacePath;
-}
-function removeTestWorkspace(issue) {
-  const testWorkspacePath = issue.testWorkspacePath;
-  issue.testApplied = false;
-  issue.testWorkspacePath = void 0;
-  if (!testWorkspacePath) return;
-  try {
-    execSync(`git worktree remove --force "${testWorkspacePath}"`, {
-      cwd: TARGET_ROOT,
-      stdio: "pipe",
-      timeout: 3e4
-    });
-    logger.info({ issueId: issue.id, testWorkspacePath }, "[Workspace] Removed isolated test workspace");
-    return;
-  } catch (error) {
-    logger.warn({ issueId: issue.id, testWorkspacePath, err: String(error) }, "[Workspace] Failed to remove isolated test workspace via git worktree");
-  }
-  try {
-    rmSync2(testWorkspacePath, { recursive: true, force: true });
-  } catch (error) {
-    logger.warn({ issueId: issue.id, testWorkspacePath, err: String(error) }, "[Workspace] Failed to remove isolated test workspace directory");
-  }
-}
-async function createGitWorktree(issue, worktreePath, baseBranch) {
-  let headCommitAtStart = "";
-  const resolvedBaseBranch = baseBranch ?? detectDefaultBranch(TARGET_ROOT);
-  try {
-    headCommitAtStart = execSync("git rev-parse HEAD", { cwd: TARGET_ROOT, encoding: "utf8" }).trim();
-  } catch {
-  }
-  const branchName = `fifony/${issue.id}`;
-  execSync(`git worktree add "${worktreePath}" -B "${branchName}"`, {
-    cwd: TARGET_ROOT,
-    stdio: "pipe"
-  });
-  try {
-    const gitFileContent = readFileSync4(join7(worktreePath, ".git"), "utf8").trim();
-    const gitDirRel = gitFileContent.replace("gitdir: ", "").trim();
-    const gitDirPath = resolve(worktreePath, gitDirRel);
-    mkdirSync(join7(gitDirPath, "info"), { recursive: true });
-    writeFileSync2(join7(gitDirPath, "info", "exclude"), "fifony-*\n.fifony-*\nfifony_*\n", "utf8");
-  } catch (err) {
-    logger.warn({ err: String(err) }, "[Agent] Failed to write worktree excludes");
-  }
-  issue.branchName = branchName;
-  issue.baseBranch = resolvedBaseBranch;
-  issue.headCommitAtStart = headCommitAtStart;
-  issue.worktreePath = worktreePath;
-  copyCliConfigDirs(TARGET_ROOT, worktreePath);
-  logger.debug({ issueId: issue.id, branchName, baseBranch: resolvedBaseBranch, worktreePath }, "[Agent] Git worktree created");
-}
-async function prepareWorkspace(issue, state, defaultBranch) {
-  const safeId = idToSafePath(issue.id);
-  const workspaceRoot = join7(WORKSPACE_ROOT, safeId);
-  const worktreePath = join7(workspaceRoot, "worktree");
-  const createdNow = !existsSync7(worktreePath);
-  if (createdNow) {
-    mkdirSync(workspaceRoot, { recursive: true });
-    logger.debug({ issueId: issue.id, identifier: issue.identifier, workspacePath: workspaceRoot }, "[Agent] Creating workspace");
-    ensureGitRepoReadyForWorktrees(TARGET_ROOT, "execute issues");
-    if (state.config.afterCreateHook) {
-      mkdirSync(worktreePath, { recursive: true });
-      await runHook(state.config.afterCreateHook, worktreePath, issue, "after_create");
-    } else {
-      await createGitWorktree(issue, worktreePath, defaultBranch);
-    }
-    logger.debug({ issueId: issue.id, workspacePath: workspaceRoot, worktreePath }, "[Agent] Workspace created");
-  } else {
-    logger.debug({ issueId: issue.id, workspacePath: workspaceRoot }, "[Agent] Reusing existing workspace");
-  }
-  const metaPath = join7(workspaceRoot, "issue.json");
-  const promptText = await buildPrompt(issue, null);
-  const promptFile = join7(workspaceRoot, "prompt.md");
-  writeFileSync2(metaPath, JSON.stringify({ ...issue, runtimeSource: SOURCE_ROOT, bootstrapAt: now() }, null, 2), "utf8");
-  writeFileSync2(promptFile, `${promptText}
-`, "utf8");
-  issue.workspacePath = workspaceRoot;
-  issue.worktreePath = worktreePath;
-  issue.workspacePreparedAt = now();
-  return { workspacePath: workspaceRoot, promptText, promptFile };
-}
-async function cleanWorkspace(issueId, issue, state) {
-  const safeId = idToSafePath(issueId);
-  const workspacePath = issue?.workspacePath ?? join7(WORKSPACE_ROOT, safeId);
-  if (!existsSync7(workspacePath)) return;
-  if (state.config.beforeRemoveHook) {
-    try {
-      const dummyIssue = issue ?? { id: issueId, identifier: issueId };
-      await runHook(state.config.beforeRemoveHook, workspacePath, dummyIssue, "before_remove");
-    } catch (error) {
-      logger.warn(`before_remove hook failed for ${issueId}: ${String(error)}`);
-    }
-  }
-  if (issue?.testWorkspacePath) {
-    removeTestWorkspace(issue);
-  }
-  if (issue?.branchName && issue.worktreePath) {
-    try {
-      execSync(`git worktree remove --force "${issue.worktreePath}"`, { cwd: TARGET_ROOT, stdio: "pipe" });
-      logger.info(`Removed worktree for ${issueId}: ${issue.worktreePath}`);
-    } catch (error) {
-      logger.warn(`Failed to remove worktree for ${issueId}: ${String(error)}`);
-      try {
-        rmSync2(issue.worktreePath, { recursive: true, force: true });
-      } catch {
-      }
-    }
-    try {
-      execSync(`git branch -D "${issue.branchName}"`, { cwd: TARGET_ROOT, stdio: "pipe" });
-    } catch {
-    }
-    try {
-      rmSync2(workspacePath, { recursive: true, force: true });
-    } catch {
-    }
-    return;
-  }
-  try {
-    rmSync2(workspacePath, { recursive: true, force: true });
-    logger.info(`Cleaned workspace for ${issueId}: ${workspacePath}`);
-  } catch (error) {
-    logger.warn(`Failed to clean workspace for ${issueId}: ${String(error)}`);
-  }
-}
-function inferChangedWorkspacePaths(workspacePath, limit = 32, issue) {
-  if (!issue?.baseBranch || !issue.branchName) return [];
-  try {
-    const output = execSync(
-      `git diff --name-only "${issue.baseBranch}"..."${issue.branchName}"`,
-      { cwd: TARGET_ROOT, encoding: "utf8", timeout: 1e4, stdio: "pipe" }
-    );
-    return output.trim().split("\n").filter(Boolean).slice(0, limit);
-  } catch {
-    return [];
-  }
-}
-function computeDiffStats(issue) {
-  if (!issue.baseBranch || !issue.branchName) return;
-  try {
-    let raw = "";
-    try {
-      raw = execSync(
-        `git diff --stat "${issue.baseBranch}"..."${issue.branchName}"`,
-        { cwd: TARGET_ROOT, encoding: "utf8", maxBuffer: 512e3, timeout: 1e4, stdio: "pipe" }
-      );
-    } catch (err) {
-      raw = err.stdout || "";
-    }
-    if (raw) parseDiffStats(issue, raw);
-  } catch {
-  }
-}
-function parseDiffStats(issue, raw) {
-  const lines = raw.trim().split("\n");
-  const summary = lines[lines.length - 1] || "";
-  const filesMatch = summary.match(/(\d+)\s+files?\s+changed/);
-  const addMatch = summary.match(/(\d+)\s+insertions?\(\+\)/);
-  const delMatch = summary.match(/(\d+)\s+deletions?\(-\)/);
-  const internalRe = /fifony[-_]|\.fifony-|WORKFLOW\.local/;
-  const fileLines = lines.slice(0, -1).filter((l) => {
-    const name = l.trim().split("|")[0]?.trim().split("/").pop() || "";
-    return !internalRe.test(name);
-  });
-  const regexFiles = filesMatch ? parseInt(filesMatch[1], 10) : 0;
-  issue.filesChanged = fileLines.length > 0 ? fileLines.length : regexFiles;
-  issue.linesAdded = addMatch ? parseInt(addMatch[1], 10) : 0;
-  issue.linesRemoved = delMatch ? parseInt(delMatch[1], 10) : 0;
-}
-async function syncIssueDiffStatsToStore(issue) {
-  if (!issue?.id) return;
-  const { getIssueStateResource } = await import("./store-4HCGBN4L.js");
-  const issueResource = getIssueStateResource();
-  if (!issueResource) return;
-  const toNumber = (value) => {
-    const parsed = typeof value === "number" ? value : Number(value ?? 0);
-    return Number.isFinite(parsed) ? parsed : 0;
-  };
-  const nextLinesAdded = toNumber(issue.linesAdded);
-  const nextLinesRemoved = toNumber(issue.linesRemoved);
-  const nextFilesChanged = toNumber(issue.filesChanged);
-  if (nextLinesAdded === 0 && nextLinesRemoved === 0 && nextFilesChanged === 0 && !issue.branchName) {
-    return;
-  }
-  const current = await issueResource.get?.(issue.id).catch(() => null);
-  const previousLinesAdded = toNumber(current?.linesAdded);
-  const previousLinesRemoved = toNumber(current?.linesRemoved);
-  const previousFilesChanged = toNumber(current?.filesChanged);
-  await issueResource.patch(issue.id, {
-    linesAdded: nextLinesAdded,
-    linesRemoved: nextLinesRemoved,
-    filesChanged: nextFilesChanged,
-    branchName: issue.branchName
-  });
-  const add = issueResource.add;
-  const sub = issueResource.sub;
-  if (typeof add !== "function" || typeof sub !== "function") {
-    logger.debug({ issueId: issue.id }, "[DiffStats] resource.add/sub not available \u2014 EC plugin may not be installed");
-    return;
-  }
-  const deltaAdded = nextLinesAdded - previousLinesAdded;
-  const deltaRemoved = nextLinesRemoved - previousLinesRemoved;
-  const deltaFiles = nextFilesChanged - previousFilesChanged;
-  if (deltaAdded === 0 && deltaRemoved === 0 && deltaFiles === 0) {
-    logger.debug({ issueId: issue.id, nextLinesAdded, previousLinesAdded }, "[DiffStats] No delta to send to EC (values already synced)");
-    return;
-  }
-  logger.debug({ issueId: issue.id, deltaAdded, deltaRemoved, deltaFiles }, "[DiffStats] Sending deltas to EC");
-  const applyDelta = async (field, delta) => {
-    if (delta > 0) {
-      await add.call(issueResource, issue.id, field, delta);
-    } else if (delta < 0) {
-      await sub.call(issueResource, issue.id, field, Math.abs(delta));
-    }
-  };
-  await Promise.all([
-    applyDelta("linesAdded", deltaAdded),
-    applyDelta("linesRemoved", deltaRemoved),
-    applyDelta("filesChanged", deltaFiles)
-  ]);
-}
-function ensureWorktreeCommitted(issue) {
-  const worktreePath = issue.worktreePath;
-  if (!worktreePath || !issue.branchName) return;
-  execSync("git add -A", { cwd: worktreePath, stdio: "pipe" });
-  const statusBeforeCommit = execSync("git status --porcelain", { cwd: worktreePath, encoding: "utf8" }).trim();
-  if (!statusBeforeCommit) return;
-  try {
-    execSync(`git commit -m "fifony: agent changes for ${issue.identifier}"`, { cwd: worktreePath, stdio: "pipe" });
-  } catch (error) {
-    const remaining = execSync("git status --porcelain", { cwd: worktreePath, encoding: "utf8" }).trim();
-    if (remaining) {
-      throw new Error(`Failed to commit agent changes for ${issue.identifier}: ${String(error)}`);
-    }
-  }
-  const statusAfterCommit = execSync("git status --porcelain", { cwd: worktreePath, encoding: "utf8" }).trim();
-  if (statusAfterCommit) {
-    throw new Error(`Worktree for ${issue.identifier} still has uncommitted changes after commit.`);
-  }
-}
-function mergeWorktree(issue, worktreePath, abortOnConflict = true) {
-  const result = { copied: [], deleted: [], skipped: [], conflicts: [] };
-  ensureWorktreeCommitted(issue);
-  const currentBranch = execSync("git rev-parse --abbrev-ref HEAD", { cwd: TARGET_ROOT, encoding: "utf8" }).trim();
-  if (currentBranch !== issue.baseBranch) {
-    throw new Error(`Cannot merge ${issue.identifier}: current branch is ${currentBranch}, expected ${issue.baseBranch}.`);
-  }
-  const targetStatus = execSync("git status --porcelain", { cwd: TARGET_ROOT, encoding: "utf8" }).trim();
-  if (targetStatus) {
-    throw new Error(`Cannot merge ${issue.identifier}: target repository has uncommitted changes.`);
-  }
-  try {
-    const diffOut = execSync(
-      `git diff --name-status "${issue.baseBranch}"..."${issue.branchName}"`,
-      { cwd: TARGET_ROOT, encoding: "utf8" }
-    );
-    for (const line of diffOut.trim().split("\n").filter(Boolean)) {
-      const [statusChar, ...parts] = line.split("	");
-      const filePath = parts.join("	");
-      if (statusChar === "D") result.deleted.push(filePath);
-      else result.copied.push(filePath);
-    }
-  } catch {
-  }
-  try {
-    execSync(
-      `git merge --no-ff "${issue.branchName}" -m "fifony: merge ${issue.identifier}"`,
-      { cwd: TARGET_ROOT, stdio: "pipe" }
-    );
-  } catch (err) {
-    try {
-      const conflictOut = execSync(
-        "git diff --name-only --diff-filter=U",
-        { cwd: TARGET_ROOT, encoding: "utf8" }
-      );
-      result.conflicts.push(...conflictOut.trim().split("\n").filter(Boolean));
-    } catch {
-    }
-    if (abortOnConflict) {
-      try {
-        execSync("git merge --abort", { cwd: TARGET_ROOT, stdio: "pipe" });
-      } catch {
-      }
-      logger.warn({ issueId: issue.id, err: String(err) }, "[Agent] Git merge failed, aborted");
-    } else {
-      logger.info({ issueId: issue.id, conflicts: result.conflicts }, "[Agent] Git merge has conflicts \u2014 leaving markers for agent resolution");
-    }
-  }
-  return result;
-}
-function shouldSkipMergePath(relativePath) {
-  const parts = relativePath.split("/");
-  if (parts.some((s) => s === ".git" || s === "node_modules" || s === ".fifony" || s === "dist" || s === ".tanstack")) {
-    return true;
-  }
-  const base = parts.at(-1) ?? "";
-  return base === "WORKFLOW.local.md" || base === ".fifony-env.sh" || base === ".fifony-compiled-env.sh" || base === ".fifony-local-source-ready" || base.startsWith("fifony-") || base.startsWith("fifony_");
-}
-function mergeWorkspace(issue, abortOnConflict = true) {
-  ensureGitRepoReadyForWorktrees(TARGET_ROOT, "merge issues");
-  assertIssueHasGitWorktree(issue, "merge");
-  return mergeWorktree(issue, issue.worktreePath, abortOnConflict);
-}
-function dryMerge(issue) {
-  ensureGitRepoReadyForWorktrees(TARGET_ROOT, "preview merges");
-  assertIssueHasGitWorktree(issue, "preview merge");
-  ensureWorktreeCommitted(issue);
-  const currentBranch = execSync("git rev-parse --abbrev-ref HEAD", { cwd: TARGET_ROOT, encoding: "utf8" }).trim();
-  if (currentBranch !== issue.baseBranch) {
-    throw new Error(`Cannot preview merge: current branch is ${currentBranch}, expected ${issue.baseBranch}.`);
-  }
-  const targetStatus = execSync("git status --porcelain", { cwd: TARGET_ROOT, encoding: "utf8" }).trim();
-  if (targetStatus) {
-    throw new Error(`Cannot preview merge: target repository has uncommitted changes.`);
-  }
-  let conflictFiles = [];
-  let willConflict = false;
-  try {
-    execSync(
-      `git merge --no-commit --no-ff "${issue.branchName}"`,
-      { cwd: TARGET_ROOT, stdio: "pipe" }
-    );
-  } catch {
-    willConflict = true;
-    try {
-      const conflictOut = execSync(
-        "git diff --name-only --diff-filter=U",
-        { cwd: TARGET_ROOT, encoding: "utf8" }
-      );
-      conflictFiles = conflictOut.trim().split("\n").filter(Boolean);
-    } catch {
-    }
-  }
-  try {
-    execSync("git merge --abort", { cwd: TARGET_ROOT, stdio: "pipe" });
-  } catch {
-    try {
-      execSync("git reset --merge ORIG_HEAD", { cwd: TARGET_ROOT, stdio: "pipe" });
-    } catch {
-      try {
-        execSync("git reset --merge", { cwd: TARGET_ROOT, stdio: "pipe" });
-      } catch (error) {
-        logger.warn({ issueId: issue.id, err: String(error) }, "[Workspace] Failed to safely clean dry-merge state");
-      }
-    }
-  }
-  let changedFiles = 0;
-  try {
-    const diffOut = execSync(
-      `git diff --name-only "${issue.baseBranch}"..."${issue.branchName}"`,
-      { cwd: TARGET_ROOT, encoding: "utf8" }
-    );
-    changedFiles = diffOut.trim().split("\n").filter(Boolean).length;
-  } catch {
-  }
-  return { willConflict, conflictFiles, canMerge: !willConflict, changedFiles };
-}
-function rebaseWorktree(issue) {
-  ensureGitRepoReadyForWorktrees(TARGET_ROOT, "rebase worktrees");
-  assertIssueHasGitWorktree(issue, "rebase");
-  ensureWorktreeCommitted(issue);
-  try {
-    execSync(
-      `git rebase "${issue.baseBranch}"`,
-      { cwd: issue.worktreePath, stdio: "pipe" }
-    );
-    return { success: true, conflictFiles: [] };
-  } catch {
-    let conflictFiles = [];
-    try {
-      const conflictOut = execSync(
-        "git diff --name-only --diff-filter=U",
-        { cwd: issue.worktreePath, encoding: "utf8" }
-      );
-      conflictFiles = conflictOut.trim().split("\n").filter(Boolean);
-    } catch {
-    }
-    try {
-      execSync("git rebase --abort", { cwd: issue.worktreePath, stdio: "pipe" });
-    } catch {
-    }
-    return { success: false, conflictFiles };
-  }
-}
-function hydrateIssuePathsFromWorkspace(issue) {
-  const inferredPaths = inferChangedWorkspacePaths(issue.workspacePath ?? "", 32, issue);
-  if (inferredPaths.length === 0) return [];
-  issue.paths = [.../* @__PURE__ */ new Set([...issue.paths ?? [], ...inferredPaths])];
-  return inferredPaths;
-}
-function writeVersionedArtifacts(workspacePath, prefix, planVersion, attempt, sources) {
-  const { writeFileSync: _wfs, readFileSync: _rfs, existsSync: _es } = { writeFileSync: writeFileSync2, readFileSync: readFileSync4, existsSync: existsSync7 };
-  for (const { srcFile, destSuffix } of sources) {
-    const src = join7(workspacePath, srcFile);
-    if (_es(src)) {
-      _wfs(join7(workspacePath, `${prefix}.v${planVersion}a${attempt}.${destSuffix}`), _rfs(src, "utf8"), "utf8");
-    }
-  }
+function getSessionProvidersForIssue(state, issue, workflowConfig) {
+  return [
+    ...getExecutionProviders(state, issue, workflowConfig ?? null),
+    getReviewProvider(state, issue, workflowConfig ?? null)
+  ];
 }
 
 export {
+  markIssueDirty,
+  markMilestoneDirty,
+  markIssuePlanDirty,
+  markEventDirty,
+  hasDirtyState,
+  getDirtyIssueIds,
+  getDirtyMilestoneIds,
+  getDirtyEventIds,
+  snapshotAndClearDirtyIssueIds,
+  snapshotAndClearDirtyMilestoneIds,
+  snapshotAndClearDirtyIssuePlanIds,
+  snapshotAndClearDirtyEventIds,
+  markAllIssuesDirty,
+  markAllMilestonesDirty,
+  markAllIssuePlansDirty,
+  markAllEventsDirty,
+  deriveReviewProfile,
+  serializeReviewRouteSnapshot,
+  applyHarnessModeToPlan,
+  applyCheckpointPolicyToPlan,
+  recommendCheckpointPolicyForIssue,
+  recommendHarnessModeForIssue,
+  normalizeAcceptanceCriteria,
+  deriveExecutionContract,
   buildFullPlanPrompt,
   buildExecutionPayload,
   collectClaudeUsageFromCli,
@@ -2452,40 +2401,14 @@ export {
   ADAPTERS,
   discoverModels,
   normalizeAgentProvider,
+  resolveProviderCapabilities,
+  getProviderCapabilityWarnings,
   getProviderDefaultCommand,
   detectAvailableProviders,
   readCodexConfig,
   resolveDefaultProvider,
-  getEffectiveAgentProviders,
-  runCommandWithTimeout,
-  runHook,
-  buildRetryContext,
-  buildPrompt,
-  buildTurnPrompt,
-  buildProviderBasePrompt,
-  bootstrapSource,
-  setSkipSource,
-  ensureSourceReady,
-  getGitRepoStatus,
-  ensureGitRepoReadyForWorktrees,
-  initializeGitRepoForWorktrees,
-  assertIssueHasGitWorktree,
-  detectDefaultBranch,
-  createTestWorkspace,
-  removeTestWorkspace,
-  createGitWorktree,
-  prepareWorkspace,
-  cleanWorkspace,
-  inferChangedWorkspacePaths,
-  computeDiffStats,
-  parseDiffStats,
-  syncIssueDiffStatsToStore,
-  ensureWorktreeCommitted,
-  shouldSkipMergePath,
-  mergeWorkspace,
-  dryMerge,
-  rebaseWorktree,
-  hydrateIssuePathsFromWorkspace,
-  writeVersionedArtifacts
+  getExecutionProviders,
+  getReviewProvider,
+  getSessionProvidersForIssue
 };
-//# sourceMappingURL=chunk-NB44PCD2.js.map
+//# sourceMappingURL=chunk-FJNH3G2Z.js.map