fifony 0.1.27 → 0.1.28

package/dist/{chunk-XN2QKKMY.js → chunk-XVF6GOVS.js}

@@ -1,36 +1,31 @@
 import {
-  S3DB_ISSUE_RESOURCE,
-  SOURCE_MARKER,
-  SOURCE_ROOT,
-  TARGET_ROOT,
-  TERMINAL_STATES,
-  WORKSPACE_ROOT,
   appendFileTail,
   idToSafePath,
-  inferCapabilityPaths,
-  isoWeek,
-  mergeCapabilityProviders,
   now,
-  renderPrompt,
-  resolveTaskCapabilities
-} from "./chunk-AMOGDOM7.js";
+  renderPrompt
+} from "./chunk-O5AEQXUV.js";
 import {
   logger
 } from "./chunk-DVU3CXWA.js";
+import {
+  SOURCE_MARKER,
+  SOURCE_ROOT,
+  TARGET_ROOT,
+  WORKSPACE_ROOT
+} from "./chunk-OONOOWNC.js";
 
 // src/domains/workspace.ts
 import {
-  cpSync,
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   mkdirSync,
   readdirSync,
-  readFileSync as readFileSync3,
+  readFileSync as readFileSync4,
   rmSync as rmSync2,
   statSync,
   writeFileSync as writeFileSync2
 } from "fs";
 import { copyFile, mkdir, readdir, stat, writeFile } from "fs/promises";
-import { extname, join as join7, resolve } from "path";
+import { extname as extname2, join as join7, resolve } from "path";
 import { execSync } from "child_process";
 
 // src/agents/command-executor.ts
@@ -45,15 +40,17 @@ import { spawn } from "child_process";
 
 // src/agents/providers.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
 import { join as join5 } from "path";
 import { homedir as homedir2 } from "os";
 
 // src/agents/adapters/claude.ts
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import { join } from "path";
 
 // src/agents/adapters/shared.ts
+import { existsSync, readFileSync } from "fs";
+import { basename, extname } from "path";
 function buildPlanContextSection(plan) {
   const parts = ["## Plan Context", "", `**Summary:** ${plan.summary}`];
   if (plan.assumptions?.length) {
@@ -126,17 +123,17 @@ function buildValidationSection(plan) {
   return parts.join("\n");
 }
 function buildToolingSection(plan) {
-  const td = plan.toolingDecision;
-  if (!td) return "";
-  const parts = ["## Tooling & Delegation Strategy"];
-  if (td.decisionSummary) parts.push("", td.decisionSummary);
-  if (td.shouldUseSkills && td.skillsToUse?.length) {
+  const skills = plan.suggestedSkills ?? [];
+  const agents = plan.suggestedAgents ?? [];
+  if (skills.length === 0 && agents.length === 0) return "";
+  const parts = ["## Recommended Skills & Agents"];
+  if (skills.length > 0) {
     parts.push("", "**Skills to activate:**");
-    td.skillsToUse.forEach((s) => parts.push(`- **${s.name}**: ${s.why}`));
+    skills.forEach((s) => parts.push(`- ${s}`));
   }
-  if (td.shouldUseSubagents && td.subagentsToUse?.length) {
-    parts.push("", "**Subagents to use:**");
-    td.subagentsToUse.forEach((a) => parts.push(`- **${a.name}** (${a.role}): ${a.why}`));
+  if (agents.length > 0) {
+    parts.push("", "**Agents to use:**");
+    agents.forEach((a) => parts.push(`- ${a}`));
   }
   return parts.join("\n");
 }
@@ -181,6 +178,32 @@ function extractValidationCommands(plan) {
   }
   return { pre: [...new Set(pre)], post: [...new Set(post)] };
 }
+var MIME_MAP = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml"
+};
+function buildImagePromptSection(imagePaths) {
+  const validPaths = imagePaths.filter((p) => existsSync(p));
+  if (validPaths.length === 0) return "";
+  const parts = ["## Attached Images", ""];
+  for (const imgPath of validPaths) {
+    const ext = extname(imgPath).toLowerCase();
+    const mime = MIME_MAP[ext] || "image/png";
+    const name = basename(imgPath);
+    try {
+      const data = readFileSync(imgPath).toString("base64");
+      parts.push(`### ${name}`);
+      parts.push(`![${name}](data:${mime};base64,${data})`);
+      parts.push("");
+    } catch {
+    }
+  }
+  return parts.length > 2 ? parts.join("\n") : "";
+}
 function buildExecutionPayload(issue, provider, plan, workspacePath) {
   const strategy = plan.executionStrategy;
   const hasPhases = Boolean(plan.phases?.length);
@@ -191,7 +214,6 @@ function buildExecutionPayload(issue, provider, plan, workspacePath) {
       identifier: issue.identifier,
       title: issue.title,
       description: issue.description || "",
-      priority: issue.priority,
       labels: issue.labels || [],
       paths: issue.paths || []
     },
@@ -200,14 +222,13 @@ function buildExecutionPayload(issue, provider, plan, workspacePath) {
       role: provider.role,
       model: provider.model || "default",
       effort: provider.reasoningEffort || "medium",
-      capabilityCategory: provider.capabilityCategory || "",
       overlays: provider.overlays || []
     },
     executionIntent: {
       complexity: plan.estimatedComplexity,
       approach: strategy?.approach || "",
       rationale: strategy?.whyThisApproach || "",
-      workPattern: hasPhases ? "phased" : plan.toolingDecision?.shouldUseSubagents ? "parallel_subtasks" : "sequential"
+      workPattern: hasPhases ? "phased" : "sequential"
     },
     plan: {
       summary: plan.summary,
@@ -242,8 +263,8 @@ function buildExecutionPayload(issue, provider, plan, workspacePath) {
       mitigation: r.mitigation || ""
     })),
     tooling: {
-      skills: plan.toolingDecision?.skillsToUse || [],
-      subagents: plan.toolingDecision?.subagentsToUse || []
+      skills: plan.suggestedSkills || [],
+      agents: plan.suggestedAgents || []
     },
     targetPaths: plan.suggestedPaths || [],
     workspacePath,
@@ -291,13 +312,18 @@ function extractPlanDirs(plan) {
 // src/agents/adapters/claude.ts
 function buildClaudeCommand(options) {
   const parts = ["claude", "--print"];
-  if (!options.noToolAccess) {
+  if (options.readOnly) {
+    parts.push("--permission-mode plan");
+  } else if (!options.noToolAccess) {
     parts.push("--dangerously-skip-permissions");
   }
   parts.push("--no-session-persistence", "--output-format json");
   if (options.effort) {
     parts.push(`--effort ${options.effort}`);
   }
+  if (options.maxBudgetUsd && options.maxBudgetUsd > 0) {
+    parts.push(`--max-budget-usd ${options.maxBudgetUsd}`);
+  }
   if (options.jsonSchema) {
     parts.push(`--json-schema '${options.jsonSchema}'`);
   }
@@ -312,16 +338,17 @@ function buildClaudeCommand(options) {
   parts.push('< "$FIFONY_PROMPT_FILE"');
   return parts.join(" ");
 }
-async function compile(issue, provider, plan, config, workspacePath, skillContext) {
+async function compile(issue, provider, plan, config, workspacePath, skillContext, capabilitiesManifest) {
   const effort = resolveEffortForProvider(plan, provider.role, config.defaultEffort);
-  const prompt = await renderPrompt("compile-execution-claude", {
+  let prompt = await renderPrompt("compile-execution-claude", {
     isPlanner: provider.role === "planner",
     isReviewer: provider.role === "reviewer",
     profileInstructions: provider.profileInstructions || "",
     skillContext,
+    capabilitiesManifest: capabilitiesManifest || "",
     planPrompt: buildFullPlanPrompt(plan),
-    subagentsToUse: plan.toolingDecision?.shouldUseSubagents ? plan.toolingDecision.subagentsToUse ?? [] : [],
-    skillsToUse: plan.toolingDecision?.shouldUseSkills ? plan.toolingDecision.skillsToUse ?? [] : [],
+    suggestedSkills: plan.suggestedSkills ?? [],
+    suggestedAgents: plan.suggestedAgents ?? [],
     suggestedPaths: plan.suggestedPaths ?? [],
     workspacePath,
     issueIdentifier: issue.identifier,
@@ -330,13 +357,20 @@ async function compile(issue, provider, plan, config, workspacePath, skillContex
     validationItems: (plan.validation ?? []).map((value) => ({ value }))
   });
   const relativeDirs = extractPlanDirs(plan);
-  const codePath = existsSync(join(workspacePath, "worktree")) ? join(workspacePath, "worktree") : workspacePath;
+  const codePath = existsSync2(join(workspacePath, "worktree")) ? join(workspacePath, "worktree") : workspacePath;
   const absoluteDirs = relativeDirs.map((d) => join(codePath, d));
+  if (issue.images?.length) {
+    const imageSection = buildImagePromptSection(issue.images);
+    if (imageSection) prompt = prompt + "\n\n" + imageSection;
+  }
+  const isReadOnlyRole = provider.role === "planner" || provider.role === "reviewer";
   const command = buildClaudeCommand({
     model: provider.model,
     effort,
     addDirs: absoluteDirs,
-    jsonSchema: CLAUDE_RESULT_SCHEMA
+    jsonSchema: CLAUDE_RESULT_SCHEMA,
+    readOnly: isReadOnlyRole,
+    maxBudgetUsd: config.maxBudgetUsd
   });
   const env2 = {
     FIFONY_PLAN_COMPLEXITY: plan.estimatedComplexity,
@@ -344,8 +378,8 @@ async function compile(issue, provider, plan, config, workspacePath, skillContex
     FIFONY_EXECUTION_PAYLOAD_FILE: "fifony-execution-payload.json"
   };
   if (plan.suggestedPaths?.length) env2.FIFONY_PLAN_PATHS = plan.suggestedPaths.join(",");
-  if (plan.toolingDecision?.skillsToUse?.length) {
-    env2.FIFONY_PLAN_SKILLS = plan.toolingDecision.skillsToUse.map((s) => s.name).join(",");
+  if (plan.suggestedSkills?.length) {
+    env2.FIFONY_PLAN_SKILLS = plan.suggestedSkills.join(",");
   }
   const { pre, post } = extractValidationCommands(plan);
   return {
@@ -360,24 +394,26 @@ async function compile(issue, provider, plan, config, workspacePath, skillContex
       adapter: "claude",
       reasoningEffort: effort || "default",
       model: provider.model || "default",
-      skillsActivated: plan.toolingDecision?.skillsToUse?.map((s) => s.name) || [],
-      subagentsRequested: plan.toolingDecision?.subagentsToUse?.map((a) => a.name) || [],
+      skillsActivated: plan.suggestedSkills || [],
+      subagentsRequested: plan.suggestedAgents || [],
       phasesCount: plan.phases?.length || 0
     }
   };
 }
 var claudeAdapter = {
   buildCommand: buildClaudeCommand,
-  buildReviewCommand: (reviewer) => buildClaudeCommand({
+  buildReviewCommand: (reviewer, config) => buildClaudeCommand({
     model: reviewer.model,
     effort: reviewer.reasoningEffort,
-    jsonSchema: REVIEW_RESULT_SCHEMA
+    jsonSchema: REVIEW_RESULT_SCHEMA,
+    readOnly: true,
+    maxBudgetUsd: config?.maxBudgetUsd
   }),
   compile
 };
 
 // src/agents/adapters/codex.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { join as join2 } from "path";
 var CODEX_RESULT_CONTRACT = `
 Return a JSON object with this exact schema when finished:
@@ -393,7 +429,7 @@ Return a JSON object with this exact schema when finished:
 }
 `.trim();
 function buildCodexCommand(options) {
-  const parts = ["codex", "exec", "--dangerously-bypass-approvals-and-sandbox"];
+  const parts = ["codex", "exec", "--skip-git-repo-check", "--dangerously-bypass-approvals-and-sandbox"];
   if (options.model && options.model !== "codex") {
     parts.push(`--model ${options.model}`);
   }
@@ -410,16 +446,20 @@ function buildCodexCommand(options) {
       parts.push(`--image "${img}"`);
     }
   }
+  if (options.search) {
+    parts.push("--search");
+  }
   parts.push('< "$FIFONY_PROMPT_FILE"');
   return parts.join(" ");
 }
-async function compile2(issue, provider, plan, config, workspacePath, skillContext) {
+async function compile2(issue, provider, plan, config, workspacePath, skillContext, capabilitiesManifest) {
   const effort = resolveEffortForProvider(plan, provider.role, config.defaultEffort) || provider.reasoningEffort;
   const prompt = await renderPrompt("compile-execution-codex", {
     isPlanner: provider.role === "planner",
     isReviewer: provider.role === "reviewer",
     profileInstructions: provider.profileInstructions || "",
     skillContext,
+    capabilitiesManifest: capabilitiesManifest || "",
     issueIdentifier: issue.identifier,
     title: issue.title,
     description: issue.description || "(none)",
@@ -431,17 +471,18 @@ async function compile2(issue, provider, plan, config, workspacePath, skillConte
       outputs: phase.outputs ?? []
     })),
     suggestedPaths: plan.suggestedPaths ?? [],
-    skillsToUse: plan.toolingDecision?.shouldUseSkills ? plan.toolingDecision.skillsToUse ?? [] : [],
+    suggestedSkills: plan.suggestedSkills ?? [],
     validationItems: (plan.validation ?? []).map((value) => ({ value })),
     outputContract: CODEX_RESULT_CONTRACT
   });
   const relativeDirs = extractPlanDirs(plan);
-  const codePath = existsSync2(join2(workspacePath, "worktree")) ? join2(workspacePath, "worktree") : workspacePath;
+  const codePath = existsSync3(join2(workspacePath, "worktree")) ? join2(workspacePath, "worktree") : workspacePath;
   const absoluteDirs = relativeDirs.map((d) => join2(codePath, d));
   const command = buildCodexCommand({
     model: provider.model,
     addDirs: absoluteDirs,
-    effort
+    effort,
+    imagePaths: issue.images?.filter((p) => existsSync3(p))
   });
   const env2 = {
     FIFONY_PLAN_COMPLEXITY: plan.estimatedComplexity,
@@ -463,7 +504,7 @@ async function compile2(issue, provider, plan, config, workspacePath, skillConte
       adapter: "codex",
       reasoningEffort: effort || "default",
       model: provider.model || "default",
-      skillsActivated: plan.toolingDecision?.skillsToUse?.map((s) => s.name) || [],
+      skillsActivated: plan.suggestedSkills || [],
       subagentsRequested: [],
       phasesCount: plan.phases?.length || 0
     }
@@ -471,15 +512,16 @@ async function compile2(issue, provider, plan, config, workspacePath, skillConte
 }
 var codexAdapter = {
   buildCommand: buildCodexCommand,
-  buildReviewCommand: (reviewer) => buildCodexCommand({
+  buildReviewCommand: (reviewer, _config) => buildCodexCommand({
     model: reviewer.model,
     effort: reviewer.reasoningEffort
+    // Codex has no --permission-mode or --approval-mode equivalent for read-only review
   }),
   compile: compile2
 };
 
 // src/agents/adapters/gemini.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { join as join3 } from "path";
 var GEMINI_RESULT_CONTRACT = `
 Return a JSON object with this exact schema when finished:
@@ -495,23 +537,30 @@ Return a JSON object with this exact schema when finished:
 }
 `.trim();
 function buildGeminiCommand(options) {
-  const parts = ["gemini", "--yolo"];
+  const parts = ["gemini"];
+  if (options.readOnly) {
+    parts.push("--approval-mode plan");
+  } else {
+    parts.push("--yolo");
+  }
   if (options.model) {
     parts.push(`--model ${options.model}`);
   }
+  parts.push("--output-format json");
   if (options.addDirs?.length) {
     parts.push(`--include-directories ${options.addDirs.map((d) => `"${d}"`).join(",")}`);
   }
   parts.push('-p "" < "$FIFONY_PROMPT_FILE"');
   return parts.join(" ");
 }
-async function compile3(issue, provider, plan, config, workspacePath, skillContext) {
+async function compile3(issue, provider, plan, config, workspacePath, skillContext, capabilitiesManifest) {
   const effort = resolveEffortForProvider(plan, provider.role, config.defaultEffort) || provider.reasoningEffort;
-  const prompt = await renderPrompt("compile-execution-codex", {
+  let prompt = await renderPrompt("compile-execution-codex", {
     isPlanner: provider.role === "planner",
     isReviewer: provider.role === "reviewer",
     profileInstructions: provider.profileInstructions || "",
     skillContext,
+    capabilitiesManifest: capabilitiesManifest || "",
     issueIdentifier: issue.identifier,
     title: issue.title,
     description: issue.description || "(none)",
@@ -523,16 +572,22 @@ async function compile3(issue, provider, plan, config, workspacePath, skillConte
       outputs: phase.outputs ?? []
     })),
     suggestedPaths: plan.suggestedPaths ?? [],
-    skillsToUse: plan.toolingDecision?.shouldUseSkills ? plan.toolingDecision.skillsToUse ?? [] : [],
+    suggestedSkills: plan.suggestedSkills ?? [],
     validationItems: (plan.validation ?? []).map((value) => ({ value })),
     outputContract: GEMINI_RESULT_CONTRACT
   });
+  if (issue.images?.length) {
+    const imageSection = buildImagePromptSection(issue.images);
+    if (imageSection) prompt = prompt + "\n\n" + imageSection;
+  }
   const relativeDirs = extractPlanDirs(plan);
-  const codePath = existsSync3(join3(workspacePath, "worktree")) ? join3(workspacePath, "worktree") : workspacePath;
+  const codePath = existsSync4(join3(workspacePath, "worktree")) ? join3(workspacePath, "worktree") : workspacePath;
   const absoluteDirs = relativeDirs.map((d) => join3(codePath, d));
+  const isReadOnlyRole = provider.role === "planner" || provider.role === "reviewer";
   const command = buildGeminiCommand({
     model: provider.model,
-    addDirs: absoluteDirs
+    addDirs: absoluteDirs,
+    readOnly: isReadOnlyRole
   });
   const env2 = {
     FIFONY_PLAN_COMPLEXITY: plan.estimatedComplexity,
@@ -554,7 +609,7 @@ async function compile3(issue, provider, plan, config, workspacePath, skillConte
       adapter: "gemini",
       reasoningEffort: effort || "default",
       model: provider.model || "default",
-      skillsActivated: plan.toolingDecision?.skillsToUse?.map((s) => s.name) || [],
+      skillsActivated: plan.suggestedSkills || [],
       subagentsRequested: [],
       phasesCount: plan.phases?.length || 0
     }
@@ -563,7 +618,8 @@ async function compile3(issue, provider, plan, config, workspacePath, skillConte
 var geminiAdapter = {
   buildCommand: buildGeminiCommand,
   buildReviewCommand: (reviewer) => buildGeminiCommand({
-    model: reviewer.model
+    model: reviewer.model,
+    readOnly: true
   }),
   compile: compile3
 };
@@ -577,7 +633,7 @@ var ADAPTERS = {
 
 // src/agents/model-discovery.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync4, readFileSync, realpathSync } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync2, realpathSync } from "fs";
 import { join as join4, dirname } from "path";
 import { homedir } from "os";
 var modelCache = /* @__PURE__ */ new Map();
@@ -585,8 +641,8 @@ var MODEL_CACHE_TTL_MS = 5 * 60 * 1e3;
 function readClaudeConfig() {
   try {
     const settingsPath = join4(homedir(), ".claude", "settings.json");
-    if (!existsSync4(settingsPath)) return {};
-    const raw = readFileSync(settingsPath, "utf8");
+    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 {
@@ -600,7 +656,7 @@ function resolveGeminiModelsFile() {
     const realBin = realpathSync(binPath);
     const cliRoot = dirname(dirname(realBin));
     const modelsPath = join4(cliRoot, "node_modules", "@google", "gemini-cli-core", "dist", "src", "config", "models.js");
-    return existsSync4(modelsPath) ? modelsPath : null;
+    return existsSync5(modelsPath) ? modelsPath : null;
   } catch {
     return null;
   }
@@ -609,7 +665,7 @@ async function fetchGeminiModels() {
   const modelsPath = resolveGeminiModelsFile();
   if (!modelsPath) return [];
   try {
-    const content = readFileSync(modelsPath, "utf8");
+    const content = readFileSync2(modelsPath, "utf8");
     const regex = /export const ([A-Z0-9_]+)\s*=\s*'(gemini-[^']+)';/g;
     const seen = /* @__PURE__ */ new Set();
     const stable = [];
@@ -634,8 +690,8 @@ async function fetchGeminiModels() {
 async function fetchCodexModels() {
   const cachePath = join4(homedir(), ".codex", "models_cache.json");
   try {
-    if (existsSync4(cachePath)) {
-      const raw = readFileSync(cachePath, "utf8");
+    if (existsSync5(cachePath)) {
+      const raw = readFileSync2(cachePath, "utf8");
       const cache = JSON.parse(raw);
       if (Array.isArray(cache.models) && cache.models.length > 0) {
         return cache.models.sort((a, b) => {
@@ -728,28 +784,6 @@ async function discoverModels(providers) {
 }
 
 // src/agents/providers.ts
-function resolveAgentProfile(name) {
-  const normalized = name.trim();
-  if (!normalized) return { profilePath: "", instructions: "" };
-  const candidates = [
-    join5(TARGET_ROOT, ".codex", "agents", `${normalized}.md`),
-    join5(TARGET_ROOT, ".codex", "agents", normalized, "AGENT.md"),
-    join5(TARGET_ROOT, "agents", `${normalized}.md`),
-    join5(TARGET_ROOT, "agents", normalized, "AGENT.md"),
-    join5(homedir2(), ".codex", "agents", `${normalized}.md`),
-    join5(homedir2(), ".codex", "agents", normalized, "AGENT.md"),
-    join5(homedir2(), ".claude", "agents", `${normalized}.md`),
-    join5(homedir2(), ".claude", "agents", normalized, "AGENT.md")
-  ];
-  for (const candidate of candidates) {
-    if (!existsSync5(candidate)) continue;
-    return {
-      profilePath: candidate,
-      instructions: readFileSync2(candidate, "utf8").trim()
-    };
-  }
-  return { profilePath: "", instructions: "" };
-}
 function normalizeAgentProvider(value) {
   const normalized = value.trim().toLowerCase();
   if (normalized === "claude" || normalized === "codex" || normalized === "gemini") return normalized;
@@ -798,8 +832,8 @@ function detectAvailableProviders() {
 function readCodexConfig() {
   try {
     const configPath = join5(homedir2(), ".codex", "config.toml");
-    if (!existsSync5(configPath)) return {};
-    const raw = readFileSync2(configPath, "utf8");
+    if (!existsSync6(configPath)) return {};
+    const raw = readFileSync3(configPath, "utf8");
     const model = raw.match(/^model\s*=\s*"([^"]+)"/m)?.[1];
     const reasoningEffort = raw.match(/^model_reasoning_effort\s*=\s*"([^"]+)"/m)?.[1];
     return { model, reasoningEffort };
@@ -810,8 +844,8 @@ function readCodexConfig() {
 function readGeminiConfig() {
   try {
     const settingsPath = join5(homedir2(), ".gemini", "settings.json");
-    if (!existsSync5(settingsPath)) return {};
-    const raw = readFileSync2(settingsPath, "utf8");
+    if (!existsSync6(settingsPath)) return {};
+    const raw = readFileSync3(settingsPath, "utf8");
     const settings = JSON.parse(raw);
     return {
       model: typeof settings.model === "string" ? settings.model : void 0,
@@ -839,20 +873,6 @@ function getBaseAgentProviders(state) {
     }
   ];
 }
-function getCapabilityRoutingOptions() {
-  return { enabled: true, overrides: [] };
-}
-function applyCapabilityMetadata(issue, resolution) {
-  issue.capabilityCategory = resolution.category;
-  issue.capabilityOverlays = [...resolution.overlays];
-  issue.capabilityRationale = [...resolution.rationale];
-  const baseLabels = (issue.labels ?? []).filter((label) => !label.startsWith("capability:") && !label.startsWith("overlay:"));
-  const derivedLabels = [
-    resolution.category ? `capability:${resolution.category}` : "",
-    ...resolution.overlays.map((overlay) => `overlay:${overlay}`)
-  ].filter(Boolean);
-  issue.labels = [.../* @__PURE__ */ new Set([...baseLabels, ...derivedLabels])];
-}
 function roleToStageKey(role) {
   switch (role) {
     case "planner":
@@ -884,41 +904,18 @@ function applyWorkflowConfigToProviders(providers, workflowConfig) {
 }
 function getEffectiveAgentProviders(state, issue, _workflowDefinition, workflowConfig) {
   const baseProviders = getBaseAgentProviders(state);
-  const resolution = resolveTaskCapabilities(
-    {
-      id: issue.id,
-      identifier: issue.identifier,
-      title: issue.title,
-      description: issue.description,
-      labels: issue.labels,
-      paths: issue.paths
-    },
-    getCapabilityRoutingOptions()
-  );
-  applyCapabilityMetadata(issue, resolution);
-  const merged = mergeCapabilityProviders(baseProviders, resolution).map((provider) => {
-    const resolvedProfile = resolveAgentProfile(provider.profile ?? "");
-    const suggestion = resolution.providers.find(
-      (entry) => entry.provider === provider.provider && entry.role === provider.role
-    );
+  const providers = baseProviders.map((provider) => {
     const effort = resolveEffort(provider.role, issue.effort, state.config.defaultEffort);
-    const command = provider.command;
     return {
       ...provider,
-      command,
-      profilePath: resolvedProfile.profilePath,
-      profileInstructions: resolvedProfile.instructions,
-      selectionReason: suggestion?.reason ?? resolution.rationale.join(" "),
-      overlays: resolution.overlays,
-      capabilityCategory: resolution.category,
       reasoningEffort: effort
     };
   });
-  return applyWorkflowConfigToProviders(merged, workflowConfig ?? null);
+  return applyWorkflowConfigToProviders(providers, workflowConfig ?? null);
 }
 
 // src/agents/command-executor.ts
-async function runCommandWithTimeout(command, workspacePath, issue, config, promptText, promptFile, extraEnv = {}) {
+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;
@@ -929,7 +926,6 @@ async function runCommandWithTimeout(command, workspacePath, issue, config, prom
       FIFONY_ISSUE_ID: issue.id,
       FIFONY_ISSUE_IDENTIFIER: issue.identifier,
       FIFONY_ISSUE_TITLE: issue.title,
-      FIFONY_ISSUE_PRIORITY: String(issue.priority),
       FIFONY_WORKSPACE_PATH: issue.worktreePath ?? workspacePath,
       FIFONY_PROMPT_FILE: promptFile
     };
@@ -974,6 +970,19 @@ async function runCommandWithTimeout(command, workspacePath, issue, config, prom
     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);
@@ -983,6 +992,12 @@ async function runCommandWithTimeout(command, workspacePath, issue, config, prom
         appendFileSync(liveLogFile, text);
       } catch {
       }
+      if (outputFile) {
+        try {
+          appendFileSync(outputFile, text);
+        } catch {
+        }
+      }
       issue.commandOutputTail = output;
     };
     child.stdout?.on("data", onChunk);
@@ -1103,6 +1118,48 @@ async function runHook(command, workspacePath, issue, hookName, extraEnv = {}) {
 }
 
 // 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) {
@@ -1133,7 +1190,7 @@ async function buildTurnPrompt(issue, basePrompt, previousOutput, turnIndex, max
     outputTail: previousOutput.trim() || "No previous output captured."
   });
 }
-async function buildProviderBasePrompt(provider, issue, basePrompt, workspacePath, skillContext) {
+async function buildProviderBasePrompt(provider, issue, basePrompt, workspacePath, skillContext, capabilitiesManifest) {
   return renderPrompt("agent-provider-base", {
     isPlanner: provider.role === "planner",
     isReviewer: provider.role === "reviewer",
@@ -1141,8 +1198,9 @@ async function buildProviderBasePrompt(provider, issue, basePrompt, workspacePat
     hasFrontendDesignOverlay: provider.overlays?.includes("frontend-design") ?? false,
     profileInstructions: provider.profileInstructions || "",
     skillContext,
-    capabilityCategory: provider.capabilityCategory || "",
-    selectionReason: provider.selectionReason ?? "No additional routing reason.",
+    capabilitiesManifest: capabilitiesManifest || "",
+    capabilityCategory: "",
+    selectionReason: provider.selectionReason ?? "",
     overlays: provider.overlays ?? [],
     targetPaths: issue.paths ?? [],
     workspacePath,
@@ -1173,10 +1231,46 @@ 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_") && extname(base) === ".json") return true;
-  if (extname(base) === ".xlsx") return true;
+  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) {
@@ -1187,7 +1281,7 @@ async function ensureSourceReady(onProgress) {
     onProgress?.("ready");
     return;
   }
-  if (existsSync6(SOURCE_MARKER)) {
+  if (existsSync7(SOURCE_MARKER)) {
     onProgress?.("ready");
     return;
   }
@@ -1231,12 +1325,76 @@ async function ensureSourceReady(onProgress) {
   })();
   return sourceReadyPromise;
 }
-function isGitRepo(dir) {
-  try {
-    execSync("git rev-parse --git-dir", { cwd: dir, stdio: "pipe" });
-    return true;
-  } catch {
-    return false;
+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;
+    }
+  })();
+  return { isGit: true, hasCommits, branch };
+}
+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) {
@@ -1262,7 +1420,7 @@ async function createGitWorktree(issue, worktreePath, baseBranch) {
     stdio: "pipe"
   });
   try {
-    const gitFileContent = readFileSync3(join7(worktreePath, ".git"), "utf8").trim();
+    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 });
@@ -1280,23 +1438,16 @@ async function prepareWorkspace(issue, state, defaultBranch) {
   const safeId = idToSafePath(issue.id);
   const workspaceRoot = join7(WORKSPACE_ROOT, safeId);
   const worktreePath = join7(workspaceRoot, "worktree");
-  const createdNow = !existsSync6(worktreePath);
+  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 if (isGitRepo(TARGET_ROOT)) {
-      await createGitWorktree(issue, worktreePath, defaultBranch);
     } else {
-      await ensureSourceReady();
-      mkdirSync(worktreePath, { recursive: true });
-      cpSync(SOURCE_ROOT, worktreePath, {
-        recursive: true,
-        force: true,
-        filter: (sourcePath) => !sourcePath.startsWith(WORKSPACE_ROOT)
-      });
+      await createGitWorktree(issue, worktreePath, defaultBranch);
     }
     logger.debug({ issueId: issue.id, workspacePath: workspaceRoot, worktreePath }, "[Agent] Workspace created");
   } else {
@@ -1316,7 +1467,7 @@ async function prepareWorkspace(issue, state, defaultBranch) {
 async function cleanWorkspace(issueId, issue, state) {
   const safeId = idToSafePath(issueId);
   const workspacePath = issue?.workspacePath ?? join7(WORKSPACE_ROOT, safeId);
-  if (!existsSync6(workspacePath)) return;
+  if (!existsSync7(workspacePath)) return;
   if (state.config.beforeRemoveHook) {
     try {
       const dummyIssue = issue ?? { id: issueId, identifier: issueId };
@@ -1397,6 +1548,58 @@ function parseDiffStats(issue, raw) {
   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-RVKQ6UEY.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;
@@ -1462,650 +1665,109 @@ function mergeWorktree(issue, worktreePath) {
   }
   return result;
 }
-function pushWorktreeBranch(issue) {
-  if (!issue.branchName || !issue.baseBranch || !issue.worktreePath) {
-    throw new Error(`Issue ${issue.identifier} has no git worktree \u2014 cannot push.`);
-  }
-  ensureWorktreeCommitted(issue);
-  execSync(`git push -u origin "${issue.branchName}"`, { cwd: TARGET_ROOT, stdio: "pipe" });
-  try {
-    const prUrl = execSync(
-      `gh pr create --head "${issue.branchName}" --base "${issue.baseBranch}" --title "${issue.title.replace(/"/g, '\\"')}" --body "Automated by fifony"`,
-      { cwd: TARGET_ROOT, encoding: "utf8" }
-    ).trim();
-    return prUrl;
-  } catch {
-    try {
-      const remote = execSync("git remote get-url origin", { cwd: TARGET_ROOT, encoding: "utf8" }).trim();
-      const cleanRemote = remote.replace(/\.git$/, "");
-      return `${cleanRemote}/compare/${issue.baseBranch}...${issue.branchName}`;
-    } catch {
-      return `(branch: ${issue.branchName})`;
-    }
+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) {
-  if (!issue.branchName || !issue.baseBranch || !issue.worktreePath) {
-    throw new Error(`Issue ${issue.identifier} has no git worktree \u2014 cannot merge.`);
-  }
+  ensureGitRepoReadyForWorktrees(TARGET_ROOT, "merge issues");
+  assertIssueHasGitWorktree(issue, "merge");
   return mergeWorktree(issue, issue.worktreePath);
 }
-function hydrateIssuePathsFromWorkspace(issue) {
-  const inferredPaths = inferChangedWorkspacePaths(issue.workspacePath ?? "", 32, issue);
-  if (inferredPaths.length === 0) return [];
-  issue.paths = [.../* @__PURE__ */ new Set([...issue.paths ?? [], ...inferredPaths])];
-  issue.inferredPaths = [.../* @__PURE__ */ new Set([...issue.inferredPaths ?? [], ...inferredPaths])];
-  return inferredPaths;
-}
-function describeRoutingSignals(issue, workspaceDerivedPaths) {
-  const explicitPaths = issue.paths ?? [];
-  const textDerivedPaths = inferCapabilityPaths({
-    id: issue.id,
-    identifier: issue.identifier,
-    title: issue.title,
-    description: issue.description,
-    labels: issue.labels
-  }).filter((path) => !explicitPaths.includes(path));
-  const parts = [];
-  if (explicitPaths.length > 0) parts.push(`payload paths=${explicitPaths.join(", ")}`);
-  if (textDerivedPaths.length > 0) parts.push(`text hints=${textDerivedPaths.join(", ")}`);
-  if (workspaceDerivedPaths.length > 0) parts.push(`workspace diff=${workspaceDerivedPaths.join(", ")}`);
-  return parts.join(" | ");
-}
-
-// src/domains/metrics.ts
-function computeMetrics(issues) {
-  let planning = 0;
-  let queued = 0;
-  let inProgress = 0;
-  let blocked = 0;
-  let done = 0;
-  let merged = 0;
-  let cancelled = 0;
-  const completionTimes = [];
-  for (const issue of issues) {
-    if (issue.state === "Merged") {
-      const duration = issue.durationMs;
-      const candidate = typeof duration === "number" && Number.isFinite(duration) ? duration : Number.isFinite(Date.parse(issue.startedAt ?? "")) && Number.isFinite(Date.parse(issue.completedAt ?? "")) ? Date.parse(issue.completedAt) - Date.parse(issue.startedAt) : NaN;
-      if (Number.isFinite(candidate) && candidate >= 0) {
-        completionTimes.push(candidate);
-      }
-    }
-    switch (issue.state) {
-      case "Planning":
-        planning += 1;
-        break;
-      case "Planned":
-        queued += 1;
-        break;
-      case "Queued":
-      case "Running":
-      case "Reviewing":
-      case "Reviewed":
-        inProgress += 1;
-        break;
-      case "Blocked":
-        blocked += 1;
-        break;
-      case "Done":
-        done += 1;
-        break;
-      case "Merged":
-        merged += 1;
-        break;
-      case "Cancelled":
-        cancelled += 1;
-        break;
-    }
+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}.`);
   }
-  if (completionTimes.length === 0) {
-    return {
-      total: issues.length,
-      planning,
-      queued,
-      inProgress,
-      blocked,
-      done,
-      merged,
-      cancelled,
-      activeWorkers: 0
-    };
+  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.`);
   }
-  const sortedCompletionTimes = completionTimes.slice().sort((a, b) => a - b);
-  const totalCompletionMs = sortedCompletionTimes.reduce((acc, value) => acc + value, 0);
-  const mid = Math.floor(sortedCompletionTimes.length / 2);
-  const medianCompletionMs = sortedCompletionTimes.length % 2 === 1 ? sortedCompletionTimes[mid] : Math.round((sortedCompletionTimes[mid - 1] + sortedCompletionTimes[mid]) / 2);
-  return {
-    total: issues.length,
-    planning,
-    queued,
-    inProgress,
-    blocked,
-    done,
-    merged,
-    cancelled,
-    activeWorkers: 0,
-    avgCompletionMs: Math.round(totalCompletionMs / completionTimes.length),
-    medianCompletionMs,
-    fastestCompletionMs: sortedCompletionTimes[0],
-    slowestCompletionMs: sortedCompletionTimes[sortedCompletionTimes.length - 1]
-  };
-}
-function computeCapabilityCounts(issues) {
-  return issues.reduce((accumulator, issue) => {
-    const key = issue.capabilityCategory?.trim() || "default";
-    accumulator[key] = (accumulator[key] ?? 0) + 1;
-    return accumulator;
-  }, {});
-}
-
-// src/persistence/metrics-cache.ts
-var cachedMetrics = null;
-var metricsStale = true;
-function invalidateMetrics() {
-  metricsStale = true;
-}
-function getMetrics(issues) {
-  if (!metricsStale && cachedMetrics) return cachedMetrics;
-  cachedMetrics = computeMetrics(issues);
-  metricsStale = false;
-  return cachedMetrics;
-}
-
-// src/persistence/dirty-tracker.ts
-var dirtyIssueIds = /* @__PURE__ */ new Set();
-var dirtyIssuePlanIds = /* @__PURE__ */ new Set();
-var dirtyEventIds = /* @__PURE__ */ new Set();
-function markIssueDirty(id) {
-  dirtyIssueIds.add(id);
-}
-function markIssuePlanDirty(id) {
-  dirtyIssuePlanIds.add(id);
-}
-function markEventDirty(id) {
-  dirtyEventIds.add(id);
-}
-function hasDirtyState() {
-  return dirtyIssueIds.size > 0 || dirtyEventIds.size > 0;
-}
-function getDirtyIssueIds() {
-  return dirtyIssueIds;
-}
-function getDirtyEventIds() {
-  return dirtyEventIds;
-}
-function snapshotAndClearDirtyIssueIds() {
-  const snapshot = new Set(dirtyIssueIds);
-  for (const id of snapshot) dirtyIssueIds.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 markAllIssuePlansDirty(ids) {
-  for (const id of ids) dirtyIssuePlanIds.add(id);
-}
-function markAllEventsDirty(ids) {
-  for (const id of ids) dirtyEventIds.add(id);
-}
-
-// src/persistence/plugins/issue-state-machine.ts
-var fsmEventEmitter = null;
-function setFsmEventEmitter(emitter) {
-  fsmEventEmitter = emitter;
-}
-function emitFsmEvent(issueId, kind, message) {
-  if (fsmEventEmitter) {
+  let conflictFiles = [];
+  let willConflict = false;
+  try {
+    execSync(
+      `git merge --no-commit --no-ff "${issue.branchName}"`,
+      { cwd: TARGET_ROOT, stdio: "pipe" }
+    );
+  } catch {
+    willConflict = true;
     try {
-      fsmEventEmitter(issueId, kind, message);
+      const conflictOut = execSync(
+        "git diff --name-only --diff-filter=U",
+        { cwd: TARGET_ROOT, encoding: "utf8" }
+      );
+      conflictFiles = conflictOut.trim().split("\n").filter(Boolean);
     } catch {
     }
   }
-}
-async function lazyEnqueueForPlanning(issue) {
-  const { enqueueForPlanning } = await import("./queue-workers-Q3IWRFLI.js");
-  return enqueueForPlanning(issue);
-}
-async function lazyEnqueueForExecution(issue) {
-  const { enqueueForExecution } = await import("./queue-workers-Q3IWRFLI.js");
-  return enqueueForExecution(issue);
-}
-async function lazyEnqueueForReview(issue) {
-  const { enqueueForReview } = await import("./queue-workers-Q3IWRFLI.js");
-  return enqueueForReview(issue);
-}
-var ISSUE_STATE_MACHINE_ID = "issue-lifecycle";
-function markDirtyAndInvalidate(issueId) {
-  markIssueDirty(issueId);
-  invalidateMetrics();
-}
-function resolveIssue(context) {
-  return context.issue ?? null;
-}
-function issueResource(machine) {
-  return machine.database?.resources?.[S3DB_ISSUE_RESOURCE];
-}
-var STALE_TIMEOUT_MS = 24e5;
-async function isStaleIssue(context, _entityId) {
-  const issue = resolveIssue(context);
-  if (!issue) return false;
-  return Date.now() - Date.parse(issue.updatedAt) > STALE_TIMEOUT_MS;
-}
-var issueStateMachineConfig = {
-  persistTransitions: true,
-  workerId: `fifony-${process.pid}`,
-  lockTimeout: 5e3,
-  lockTTL: 30,
-  stateMachines: {
-    [ISSUE_STATE_MACHINE_ID]: {
-      resource: S3DB_ISSUE_RESOURCE,
-      stateField: "state",
-      initialState: "Planning",
-      autoCleanup: false,
-      states: {
-        Planning: {
-          on: { PLANNED: "Planned", CANCEL: "Cancelled" },
-          entry: "onEnterPlanning"
-        },
-        Planned: {
-          on: { QUEUE: "Queued", REPLAN: "Planning", CANCEL: "Cancelled" },
-          entry: "onEnterPlanned"
-        },
-        Queued: {
-          on: { RUN: "Running" },
-          entry: "onEnterQueued"
-        },
-        Running: {
-          on: { REVIEW: "Reviewing", REQUEUE: "Queued", BLOCK: "Blocked" },
-          guards: { BLOCK: "requireBlockReason" },
-          triggers: [{
-            type: "cron",
-            cron: "*/10 * * * *",
-            sendEvent: "BLOCK",
-            condition: isStaleIssue
-          }]
-        },
-        Reviewing: {
-          on: { REVIEWED: "Reviewed", REQUEUE: "Queued", BLOCK: "Blocked" },
-          entry: "onEnterReviewing",
-          guards: { BLOCK: "requireBlockReason" },
-          triggers: [{
-            type: "cron",
-            cron: "*/10 * * * *",
-            sendEvent: "BLOCK",
-            condition: isStaleIssue
-          }]
-        },
-        Reviewed: {
-          on: { DONE: "Done", REQUEUE: "Queued", REPLAN: "Planning", CANCEL: "Cancelled" }
-        },
-        Blocked: {
-          on: { UNBLOCK: "Queued", REPLAN: "Planning", CANCEL: "Cancelled" },
-          entry: "onEnterBlocked"
-        },
-        Done: {
-          on: { MERGE: "Merged", REOPEN: "Planning" },
-          entry: "onEnterDone"
-        },
-        Merged: {
-          on: { REOPEN: "Planning" },
-          type: "final",
-          entry: "onEnterMerged"
-        },
-        Cancelled: {
-          on: { REOPEN: "Planning" },
-          type: "final",
-          entry: "onEnterCancelled"
-        }
-      }
-    }
-  },
-  // ── Actions: (context, event, machine) ──────────────────────────────────
-  // context = payload from send()
-  // event   = event name ("PLANNED", "BLOCK", etc.)
-  // machine = { database, machineId, entityId }
-  //
-  // Actions only mutate the in-memory issue + fire side effects (enqueue, s3db patch).
-  // Dirty tracking + metrics invalidation is done once in executeTransition() after send().
-  actions: {
-    onEnterPlanning: async (context, _event, _machine) => {
-      const issue = resolveIssue(context);
-      if (issue) {
-        issue.planningStatus = "idle";
-        issue.planningError = void 0;
-        issue.nextRetryAt = void 0;
-        issue.lastError = void 0;
-        emitFsmEvent(issue.id, "state", `${issue.identifier} entered Planning.`);
-        lazyEnqueueForPlanning(issue).catch(() => {
-        });
-      }
-    },
-    onEnterPlanned: async (context, _event, _machine) => {
-      const issue = resolveIssue(context);
-      if (issue) {
-        issue.nextRetryAt = void 0;
-        issue.lastError = void 0;
-        emitFsmEvent(issue.id, "state", `Plan approved \u2014 ${issue.identifier} moved to Planned.`);
-      }
-    },
-    onEnterQueued: async (context, _event, _machine) => {
-      const issue = resolveIssue(context);
-      if (issue) {
-        issue.nextRetryAt = void 0;
-        issue.lastError = void 0;
-        logger.info({ issueId: issue.id, identifier: issue.identifier }, "[FSM] onEnterQueued \u2014 enqueuing for execution");
-        emitFsmEvent(issue.id, "state", `${issue.identifier} queued for execution.`);
-        lazyEnqueueForExecution(issue).catch((err) => {
-          logger.error({ err, issueId: issue.id }, "[FSM] onEnterQueued \u2014 enqueue FAILED");
-        });
-      }
-    },
-    onEnterReviewing: async (context, _event, machine) => {
-      const issue = resolveIssue(context);
-      const ts = (/* @__PURE__ */ new Date()).toISOString();
-      if (issue) {
-        issue.reviewingAt = ts;
-        issue.lastError = void 0;
-        emitFsmEvent(issue.id, "state", `${issue.identifier} moved to Reviewing.`);
-        lazyEnqueueForReview(issue).catch(() => {
-        });
-      }
-      const res = issueResource(machine);
-      if (res) {
-        res.patch(machine.entityId, { reviewingAt: ts }).catch(() => {
-        });
-      }
-    },
-    onEnterBlocked: async (context, _event, _machine) => {
-      const issue = resolveIssue(context);
-      const note = typeof context.note === "string" ? context.note : "Blocked";
-      if (issue) {
-        issue.lastError = note;
-        emitFsmEvent(issue.id, "error", `${issue.identifier} blocked: ${note}`);
-      }
-    },
-    onEnterDone: async (context, _event, _machine) => {
-      const issue = resolveIssue(context);
-      if (issue) {
-        issue.nextRetryAt = void 0;
-        issue.lastError = void 0;
-        if (!issue.linesAdded && !issue.linesRemoved && issue.baseBranch && issue.branchName) {
-          computeDiffStats(issue);
-        }
-        emitFsmEvent(issue.id, "state", `${issue.identifier} approved \u2014 waiting for merge.`);
-      }
-    },
-    onEnterMerged: async (context, _event, machine) => {
-      const issue = resolveIssue(context);
-      const ts = (/* @__PURE__ */ new Date()).toISOString();
-      const week = isoWeek();
-      if (issue) {
-        if (!issue.linesAdded && !issue.linesRemoved && issue.baseBranch && issue.branchName) {
-          computeDiffStats(issue);
-        }
-        issue.completedAt = ts;
-        issue.terminalWeek = week;
-        if (!issue.mergedAt) issue.mergedAt = ts;
-        issue.nextRetryAt = void 0;
-        issue.lastError = void 0;
-        emitFsmEvent(issue.id, "state", `${issue.identifier} merged.`);
-      }
-      const res = issueResource(machine);
-      if (res) {
-        res.patch(machine.entityId, {
-          completedAt: ts,
-          terminalWeek: week,
-          mergedAt: issue?.mergedAt ?? ts,
-          nextRetryAt: void 0,
-          lastError: void 0,
-          linesAdded: issue?.linesAdded,
-          linesRemoved: issue?.linesRemoved,
-          filesChanged: issue?.filesChanged,
-          branchName: issue?.branchName,
-          workspacePath: issue?.workspacePath,
-          worktreePath: issue?.worktreePath
-        }).catch(() => {
-        });
-        const add = res.add;
-        if (typeof add === "function" && issue) {
-          try {
-            if (issue.linesAdded) await add.call(res, machine.entityId, "linesAdded", issue.linesAdded);
-            if (issue.linesRemoved) await add.call(res, machine.entityId, "linesRemoved", issue.linesRemoved);
-            if (issue.filesChanged) await add.call(res, machine.entityId, "filesChanged", issue.filesChanged);
-            logger.info({ issueId: issue.id, linesAdded: issue.linesAdded, linesRemoved: issue.linesRemoved, filesChanged: issue.filesChanged }, "[FSM] EC add() for diff stats on merge");
-          } catch (err) {
-            logger.warn({ err: String(err), issueId: issue?.id }, "[FSM] EC add() failed for diff stats");
-          }
-        }
-      }
-    },
-    onEnterCancelled: async (context, _event, machine) => {
-      const issue = resolveIssue(context);
-      const ts = (/* @__PURE__ */ new Date()).toISOString();
-      const week = isoWeek();
-      if (issue) {
-        issue.completedAt = ts;
-        issue.terminalWeek = week;
-        issue.nextRetryAt = void 0;
-        emitFsmEvent(issue.id, "state", `${issue.identifier} cancelled.`);
-      }
-      const res = issueResource(machine);
-      if (res) {
-        res.patch(machine.entityId, {
-          completedAt: ts,
-          terminalWeek: week,
-          nextRetryAt: void 0
-        }).catch(() => {
-        });
-      }
-    }
-  },
-  // ── Guards: (context, event, machine) ───────────────────────────────────
-  guards: {
-    requireBlockReason: async (context, _event, _machine) => {
-      return typeof context.note === "string" && context.note.trim().length > 0;
-    }
-  }
-};
-var EVENT_TO_STATE = {
-  PLANNED: "Planned",
-  QUEUE: "Queued",
-  RUN: "Running",
-  REVIEW: "Reviewing",
-  REVIEWED: "Reviewed",
-  DONE: "Done",
-  MERGE: "Merged",
-  CANCEL: "Cancelled",
-  BLOCK: "Blocked",
-  UNBLOCK: "Queued",
-  REPLAN: "Planning",
-  REQUEUE: "Queued",
-  REOPEN: "Planning"
-};
-function eventToTargetState(event) {
-  return EVENT_TO_STATE[event];
-}
-function getStatesFromConfig() {
-  const machine = issueStateMachineConfig.stateMachines[ISSUE_STATE_MACHINE_ID];
-  const result = {};
-  for (const [state, def] of Object.entries(machine.states)) {
-    result[state] = def.on ?? {};
-  }
-  return result;
-}
-function getStateMachineTransitions() {
-  const edges = getStatesFromConfig();
-  const result = {};
-  for (const [state, events] of Object.entries(edges)) {
-    const targets = [...new Set(Object.values(events))];
-    result[state] = targets;
-  }
-  return result;
-}
-function findIssueStateMachineTransitionPath(_machineDefinition, from, to) {
-  if (from === to) return [];
-  const edges = getStatesFromConfig();
-  if (!edges[from] || !edges[to]) return null;
-  const queue = [from];
-  const previousState = /* @__PURE__ */ new Map();
-  const previousEvent = /* @__PURE__ */ new Map();
-  previousState.set(from, "");
-  for (let i = 0; i < queue.length; i += 1) {
-    const current = queue[i];
-    const transitions = edges[current];
-    if (!transitions) continue;
-    for (const [evt, next] of Object.entries(transitions)) {
-      if (previousState.has(next)) continue;
-      previousState.set(next, current);
-      previousEvent.set(next, evt);
-      if (next === to) {
-        const events = [];
-        let cursor = next;
-        while (cursor !== from) {
-          const prev = previousState.get(cursor);
-          const e = previousEvent.get(cursor);
-          if (!prev || !e) return null;
-          events.unshift(e);
-          cursor = prev;
-        }
-        return events;
-      }
-      queue.push(next);
-    }
-  }
-  return null;
-}
-var issueResourceStateApi = null;
-function setIssueResourceStateApi(api) {
-  issueResourceStateApi = api;
-}
-function getIssueResourceStateApi() {
-  return issueResourceStateApi;
-}
-var issueStateMachinePlugin = null;
-function setIssueStateMachinePlugin(plugin) {
-  issueStateMachinePlugin = plugin;
-}
-function getIssueStateMachinePlugin() {
-  return issueStateMachinePlugin;
-}
-function getIssueStateMachineDefinition() {
-  return issueStateMachinePlugin?.getMachineDefinition?.(ISSUE_STATE_MACHINE_ID) ?? issueStateMachineConfig.stateMachines[ISSUE_STATE_MACHINE_ID];
-}
-function getIssueStateMachineInitialState() {
-  return issueStateMachineConfig.stateMachines[ISSUE_STATE_MACHINE_ID].initialState;
-}
-async function executeTransition(issue, event, context = {}) {
-  const ts = (/* @__PURE__ */ new Date()).toISOString();
-  const previous = issue.state;
-  const targetState = eventToTargetState(event);
-  if (!targetState) {
-    throw new Error(`Unknown FSM event '${event}' for issue ${issue.id}.`);
-  }
-  const resourceApi = getIssueResourceStateApi();
-  const plugin = getIssueStateMachinePlugin();
-  const sendContext = { ...context, issue };
-  if (resourceApi) {
-    try {
-      await resourceApi.send(issue.id, event, sendContext);
-    } catch (err) {
-      if (String(err).includes("not found") || String(err).includes("not initialized")) {
-        await resourceApi.initialize(issue.id, { issue, state: previous });
-        await resourceApi.send(issue.id, event, sendContext);
-      } else {
-        throw err;
-      }
-    }
-  } else if (plugin?.send) {
+  try {
+    execSync("git merge --abort", { cwd: TARGET_ROOT, stdio: "pipe" });
+  } catch {
     try {
-      await plugin.send(ISSUE_STATE_MACHINE_ID, issue.id, event, sendContext);
-    } catch (err) {
-      if (plugin.initializeEntity && String(err).includes("not found")) {
-        await plugin.initializeEntity(ISSUE_STATE_MACHINE_ID, issue.id, { issue, state: previous });
-        await plugin.send(ISSUE_STATE_MACHINE_ID, issue.id, event, sendContext);
-      } else {
-        throw err;
-      }
-    }
-  } else {
-    if (previous !== targetState) {
-      const edges = getStatesFromConfig();
-      const stateTransitions = edges[previous];
-      if (!stateTransitions || !stateTransitions[event]) {
-        throw new Error(`State machine does not allow event '${event}' from '${previous}' for issue ${issue.id}.`);
-      }
-    }
-    const stateDef = issueStateMachineConfig.stateMachines[ISSUE_STATE_MACHINE_ID].states[previous];
-    if (stateDef && "guards" in stateDef && stateDef.guards?.[event]) {
-      const guardName = stateDef.guards[event];
-      const guardFn = issueStateMachineConfig.guards[guardName];
-      if (guardFn) {
-        const allowed = await guardFn(sendContext, event, { database: null, machineId: ISSUE_STATE_MACHINE_ID, entityId: issue.id });
-        if (!allowed) {
-          throw new Error(`Guard '${guardName}' rejected event '${event}' for issue ${issue.id}.`);
-        }
-      }
-    }
-    const targetDef = issueStateMachineConfig.stateMachines[ISSUE_STATE_MACHINE_ID].states[targetState];
-    if (targetDef && "entry" in targetDef && typeof targetDef.entry === "string") {
-      const actionName = targetDef.entry;
-      const actionFn = issueStateMachineConfig.actions[actionName];
-      if (actionFn) {
-        await actionFn(sendContext, event, { database: null, machineId: ISSUE_STATE_MACHINE_ID, entityId: issue.id });
-      }
+      execSync("git reset --hard HEAD", { cwd: TARGET_ROOT, stdio: "pipe" });
+    } catch {
     }
   }
-  issue.state = targetState;
-  issue.updatedAt = ts;
-  const note = typeof context.note === "string" ? context.note : `${event}: ${previous} \u2192 ${targetState}`;
-  issue.history.push(`[${ts}] ${note}`);
-  if (TERMINAL_STATES.has(previous) && !TERMINAL_STATES.has(targetState)) {
-    issue.terminalWeek = "";
+  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 {
   }
-  markDirtyAndInvalidate(issue.id);
-  return { previousState: previous };
+  return { willConflict, conflictFiles, canMerge: !willConflict, changedFiles };
 }
-async function getIssueTransitionHistory(issueId, options) {
-  const resourceApi = getIssueResourceStateApi();
-  if (resourceApi?.history) {
+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 {
-      return await resourceApi.history(issueId, options);
+      const conflictOut = execSync(
+        "git diff --name-only --diff-filter=U",
+        { cwd: issue.worktreePath, encoding: "utf8" }
+      );
+      conflictFiles = conflictOut.trim().split("\n").filter(Boolean);
     } catch {
     }
-  }
-  const plugin = getIssueStateMachinePlugin();
-  if (plugin?.getTransitionHistory) {
     try {
-      return await plugin.getTransitionHistory(ISSUE_STATE_MACHINE_ID, issueId, options);
+      execSync("git rebase --abort", { cwd: issue.worktreePath, stdio: "pipe" });
     } catch {
     }
+    return { success: false, conflictFiles };
   }
-  return [];
 }
-async function canTransitionIssue(issueId, event) {
-  const resourceApi = getIssueResourceStateApi();
-  if (resourceApi?.canTransition) {
-    try {
-      return await resourceApi.canTransition(issueId, event);
-    } catch {
+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");
     }
   }
-  return false;
-}
-function visualizeStateMachine() {
-  const plugin = getIssueStateMachinePlugin();
-  if (!plugin?.visualize) return null;
-  return plugin.visualize(ISSUE_STATE_MACHINE_ID);
 }
 
 export {
@@ -2119,54 +1781,34 @@ export {
   detectAvailableProviders,
   readCodexConfig,
   resolveDefaultProvider,
-  getCapabilityRoutingOptions,
-  applyCapabilityMetadata,
   getEffectiveAgentProviders,
-  computeMetrics,
-  computeCapabilityCounts,
-  getMetrics,
   runCommandWithTimeout,
   runHook,
+  buildRetryContext,
+  buildPrompt,
   buildTurnPrompt,
   buildProviderBasePrompt,
+  bootstrapSource,
   setSkipSource,
+  ensureSourceReady,
+  getGitRepoStatus,
+  ensureGitRepoReadyForWorktrees,
+  initializeGitRepoForWorktrees,
+  assertIssueHasGitWorktree,
   detectDefaultBranch,
+  createGitWorktree,
   prepareWorkspace,
   cleanWorkspace,
+  inferChangedWorkspacePaths,
   computeDiffStats,
   parseDiffStats,
+  syncIssueDiffStatsToStore,
   ensureWorktreeCommitted,
-  pushWorktreeBranch,
+  shouldSkipMergePath,
   mergeWorkspace,
+  dryMerge,
+  rebaseWorktree,
   hydrateIssuePathsFromWorkspace,
-  describeRoutingSignals,
-  markIssueDirty,
-  markIssuePlanDirty,
-  markEventDirty,
-  hasDirtyState,
-  getDirtyIssueIds,
-  getDirtyEventIds,
-  snapshotAndClearDirtyIssueIds,
-  snapshotAndClearDirtyIssuePlanIds,
-  snapshotAndClearDirtyEventIds,
-  markAllIssuesDirty,
-  markAllIssuePlansDirty,
-  markAllEventsDirty,
-  setFsmEventEmitter,
-  ISSUE_STATE_MACHINE_ID,
-  issueStateMachineConfig,
-  eventToTargetState,
-  getStateMachineTransitions,
-  findIssueStateMachineTransitionPath,
-  setIssueResourceStateApi,
-  getIssueResourceStateApi,
-  setIssueStateMachinePlugin,
-  getIssueStateMachinePlugin,
-  getIssueStateMachineDefinition,
-  getIssueStateMachineInitialState,
-  executeTransition,
-  getIssueTransitionHistory,
-  canTransitionIssue,
-  visualizeStateMachine
+  writeVersionedArtifacts
 };
-//# sourceMappingURL=chunk-XN2QKKMY.js.map
+//# sourceMappingURL=chunk-XVF6GOVS.js.map