fifony 0.1.21 → 0.1.22-next.4ab1d2e

package/dist/chunk-3QSBGJMT.js

@@ -0,0 +1,2190 @@
+import {
+  S3DB_ISSUE_RESOURCE,
+  SOURCE_MARKER,
+  SOURCE_ROOT,
+  TARGET_ROOT,
+  TERMINAL_STATES,
+  WORKSPACE_ROOT,
+  appendFileTail,
+  idToSafePath,
+  inferCapabilityPaths,
+  isoWeek,
+  mergeCapabilityProviders,
+  now,
+  renderPrompt,
+  resolveTaskCapabilities
+} from "./chunk-DD5BE2W6.js";
+import {
+  logger
+} from "./chunk-DVU3CXWA.js";
+
+// src/domains/workspace.ts
+import {
+  cpSync,
+  existsSync as existsSync6,
+  mkdirSync,
+  readdirSync,
+  readFileSync as readFileSync3,
+  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 { execSync } from "child_process";
+
+// src/agents/command-executor.ts
+import {
+  appendFileSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { join as join6 } from "path";
+import { env } from "process";
+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 { join as join5 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/agents/adapters/claude.ts
+import { existsSync } from "fs";
+import { join } from "path";
+
+// src/agents/adapters/shared.ts
+function buildPlanContextSection(plan) {
+  const parts = ["## Plan Context", "", `**Summary:** ${plan.summary}`];
+  if (plan.assumptions?.length) {
+    parts.push("", "**Assumptions:**");
+    plan.assumptions.forEach((a) => parts.push(`- ${a}`));
+  }
+  if (plan.constraints?.length) {
+    parts.push("", "**Constraints:**");
+    plan.constraints.forEach((c) => parts.push(`- ${c}`));
+  }
+  if (plan.unknowns?.length) {
+    parts.push("", "**Unknowns to investigate:**");
+    plan.unknowns.forEach((u) => {
+      parts.push(`- **${u.question}**`);
+      if (u.whyItMatters) parts.push(`  Why it matters: ${u.whyItMatters}`);
+      if (u.howToResolve) parts.push(`  How to resolve: ${u.howToResolve}`);
+    });
+  }
+  return parts.join("\n");
+}
+function buildStepsSection(plan) {
+  const parts = ["## Execution Steps"];
+  if (plan.phases?.length) {
+    for (const phase of plan.phases) {
+      parts.push("", `### Phase: ${phase.phaseName}`, `Goal: ${phase.goal}`);
+      if (phase.dependencies?.length) parts.push(`Dependencies: ${phase.dependencies.join(", ")}`);
+      for (const task of phase.tasks) {
+        parts.push(`${task.step}. **${task.action}**${task.ownerType ? ` [${task.ownerType}]` : ""}`);
+        if (task.details) parts.push(`   ${task.details}`);
+        if (task.doneWhen) parts.push(`   Done when: ${task.doneWhen}`);
+        if (task.files?.length) parts.push(`   Files: ${task.files.join(", ")}`);
+      }
+      if (phase.outputs?.length) parts.push(`Outputs: ${phase.outputs.join(", ")}`);
+    }
+  } else {
+    parts.push("");
+    for (const step of plan.steps) {
+      parts.push(`${step.step}. **${step.action}**${step.ownerType ? ` [${step.ownerType}]` : ""}`);
+      if (step.details) parts.push(`   ${step.details}`);
+      if (step.doneWhen) parts.push(`   Done when: ${step.doneWhen}`);
+      if (step.files?.length) parts.push(`   Files: ${step.files.join(", ")}`);
+    }
+  }
+  parts.push("", "Follow this plan. Complete each step in order.");
+  return parts.join("\n");
+}
+function buildRiskSection(plan) {
+  if (!plan.risks?.length) return "";
+  const parts = ["## Risks"];
+  for (const r of plan.risks) {
+    parts.push(`- **${r.risk}** \u2014 Impact: ${r.impact}. Mitigation: ${r.mitigation}`);
+  }
+  return parts.join("\n");
+}
+function buildValidationSection(plan) {
+  const parts = [];
+  if (plan.successCriteria?.length) {
+    parts.push("## Success Criteria");
+    plan.successCriteria.forEach((c) => parts.push(`- ${c}`));
+  }
+  if (plan.validation?.length) {
+    parts.push("", "## Validation Checks");
+    parts.push("Run these before marking as done:");
+    plan.validation.forEach((v) => parts.push(`- ${v}`));
+  }
+  if (plan.deliverables?.length) {
+    parts.push("", "## Deliverables");
+    plan.deliverables.forEach((d) => parts.push(`- ${d}`));
+  }
+  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) {
+    parts.push("", "**Skills to activate:**");
+    td.skillsToUse.forEach((s) => parts.push(`- **${s.name}**: ${s.why}`));
+  }
+  if (td.shouldUseSubagents && td.subagentsToUse?.length) {
+    parts.push("", "**Subagents to use:**");
+    td.subagentsToUse.forEach((a) => parts.push(`- **${a.name}** (${a.role}): ${a.why}`));
+  }
+  return parts.join("\n");
+}
+function buildStrategySection(plan) {
+  const es = plan.executionStrategy;
+  if (!es) return "";
+  const parts = [
+    "## Execution Strategy",
+    "",
+    `**Approach:** ${es.approach}`,
+    `**Rationale:** ${es.whyThisApproach}`
+  ];
+  if (es.alternativesConsidered?.length) {
+    parts.push("", "Alternatives considered:");
+    es.alternativesConsidered.forEach((a) => parts.push(`- ${a}`));
+  }
+  return parts.join("\n");
+}
+function resolveEffortForProvider(plan, role, globalEffort) {
+  const planEffort = plan?.suggestedEffort;
+  const roleKey = role;
+  return planEffort?.[roleKey] || planEffort?.default || globalEffort?.[roleKey] || globalEffort?.default || void 0;
+}
+function buildFullPlanPrompt(plan) {
+  return [
+    buildPlanContextSection(plan),
+    buildStrategySection(plan),
+    buildToolingSection(plan),
+    buildStepsSection(plan),
+    buildRiskSection(plan),
+    buildValidationSection(plan)
+  ].filter(Boolean).join("\n\n");
+}
+function extractValidationCommands(plan) {
+  const pre = [];
+  const post = [];
+  for (const v of plan.validation || []) {
+    const lower = v.toLowerCase();
+    if (lower.includes("lint")) post.push("pnpm lint --quiet 2>/dev/null || true");
+    if (lower.includes("typecheck") || lower.includes("tsc")) post.push("pnpm tsc --noEmit 2>/dev/null || true");
+    if (lower.includes("test")) post.push("pnpm test 2>/dev/null || true");
+  }
+  return { pre: [...new Set(pre)], post: [...new Set(post)] };
+}
+function buildExecutionPayload(issue, provider, plan, workspacePath) {
+  const strategy = plan.executionStrategy;
+  const hasPhases = Boolean(plan.phases?.length);
+  return {
+    version: 1,
+    issue: {
+      id: issue.id,
+      identifier: issue.identifier,
+      title: issue.title,
+      description: issue.description || "",
+      priority: issue.priority,
+      labels: issue.labels || [],
+      paths: issue.paths || []
+    },
+    provider: {
+      name: provider.provider,
+      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"
+    },
+    plan: {
+      summary: plan.summary,
+      steps: plan.steps.map((s) => ({
+        step: s.step,
+        action: s.action,
+        files: s.files || [],
+        ownerType: s.ownerType || "agent",
+        doneWhen: s.doneWhen || ""
+      })),
+      phases: (plan.phases || []).map((p) => ({
+        name: p.phaseName,
+        goal: p.goal,
+        tasks: p.tasks.map((t) => t.step),
+        dependencies: p.dependencies || [],
+        outputs: p.outputs || []
+      }))
+    },
+    constraints: plan.constraints || [],
+    successCriteria: plan.successCriteria || [],
+    validation: plan.validation || [],
+    deliverables: plan.deliverables || [],
+    assumptions: plan.assumptions || [],
+    unknowns: (plan.unknowns || []).map((u) => ({
+      question: u.question,
+      whyItMatters: u.whyItMatters || "",
+      howToResolve: u.howToResolve || ""
+    })),
+    risks: (plan.risks || []).map((r) => ({
+      risk: r.risk,
+      impact: r.impact || "",
+      mitigation: r.mitigation || ""
+    })),
+    tooling: {
+      skills: plan.toolingDecision?.skillsToUse || [],
+      subagents: plan.toolingDecision?.subagentsToUse || []
+    },
+    targetPaths: plan.suggestedPaths || [],
+    workspacePath,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/agents/adapters/commands.ts
+var CLAUDE_RESULT_SCHEMA = JSON.stringify({
+  type: "object",
+  properties: {
+    status: { type: "string", enum: ["done", "continue", "blocked", "failed"] },
+    summary: { type: "string" },
+    nextPrompt: { type: "string" }
+  },
+  required: ["status"]
+});
+var REVIEW_RESULT_SCHEMA = JSON.stringify({
+  type: "object",
+  properties: {
+    status: { type: "string", enum: ["done", "continue", "blocked", "failed"] },
+    summary: { type: "string" },
+    nextPrompt: { type: "string" },
+    criteriaResults: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: { criterion: { type: "string" }, met: { type: "boolean" }, note: { type: "string" } }
+      }
+    }
+  },
+  required: ["status"]
+});
+function extractPlanDirs(plan) {
+  if (!plan.suggestedPaths?.length) return [];
+  const dirs = /* @__PURE__ */ new Set();
+  for (const p of plan.suggestedPaths) {
+    const lastSlash = p.lastIndexOf("/");
+    if (lastSlash > 0) dirs.add(p.slice(0, lastSlash));
+    else if (!p.includes(".")) dirs.add(p);
+  }
+  return [...dirs];
+}
+
+// src/agents/adapters/claude.ts
+function buildClaudeCommand(options) {
+  const parts = ["claude", "--print"];
+  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.jsonSchema) {
+    parts.push(`--json-schema '${options.jsonSchema}'`);
+  }
+  if (options.addDirs?.length) {
+    for (const dir of options.addDirs) {
+      parts.push(`--add-dir "${dir}"`);
+    }
+  }
+  if (options.model && options.model !== "claude") {
+    parts.splice(1, 0, `--model ${options.model}`);
+  }
+  parts.push('< "$FIFONY_PROMPT_FILE"');
+  return parts.join(" ");
+}
+async function compile(issue, provider, plan, config, workspacePath, skillContext) {
+  const effort = resolveEffortForProvider(plan, provider.role, config.defaultEffort);
+  const prompt = await renderPrompt("compile-execution-claude", {
+    isPlanner: provider.role === "planner",
+    isReviewer: provider.role === "reviewer",
+    profileInstructions: provider.profileInstructions || "",
+    skillContext,
+    planPrompt: buildFullPlanPrompt(plan),
+    subagentsToUse: plan.toolingDecision?.shouldUseSubagents ? plan.toolingDecision.subagentsToUse ?? [] : [],
+    skillsToUse: plan.toolingDecision?.shouldUseSkills ? plan.toolingDecision.skillsToUse ?? [] : [],
+    suggestedPaths: plan.suggestedPaths ?? [],
+    workspacePath,
+    issueIdentifier: issue.identifier,
+    title: issue.title,
+    description: issue.description || "(none)",
+    validationItems: (plan.validation ?? []).map((value) => ({ value }))
+  });
+  const relativeDirs = extractPlanDirs(plan);
+  const codePath = existsSync(join(workspacePath, "worktree")) ? join(workspacePath, "worktree") : workspacePath;
+  const absoluteDirs = relativeDirs.map((d) => join(codePath, d));
+  const command = buildClaudeCommand({
+    model: provider.model,
+    effort,
+    addDirs: absoluteDirs,
+    jsonSchema: CLAUDE_RESULT_SCHEMA
+  });
+  const env2 = {
+    FIFONY_PLAN_COMPLEXITY: plan.estimatedComplexity,
+    FIFONY_PLAN_STEPS: String(plan.steps.length),
+    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(",");
+  }
+  const { pre, post } = extractValidationCommands(plan);
+  return {
+    prompt,
+    command,
+    env: env2,
+    preHooks: pre,
+    postHooks: post,
+    outputSchema: CLAUDE_RESULT_SCHEMA,
+    payload: null,
+    meta: {
+      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) || [],
+      phasesCount: plan.phases?.length || 0
+    }
+  };
+}
+var claudeAdapter = {
+  buildCommand: buildClaudeCommand,
+  buildReviewCommand: (reviewer) => buildClaudeCommand({
+    model: reviewer.model,
+    effort: reviewer.reasoningEffort,
+    jsonSchema: REVIEW_RESULT_SCHEMA
+  }),
+  compile
+};
+
+// src/agents/adapters/codex.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+var CODEX_RESULT_CONTRACT = `
+Return a JSON object with this exact schema when finished:
+{
+  "status": "done" | "continue" | "blocked" | "failed",
+  "summary": "one paragraph summary of what was done",
+  "root_cause": ["list of root causes found"],
+  "changes_made": ["list of files/changes"],
+  "validation": { "commands_run": ["..."], "result": "pass" | "partial" | "fail" },
+  "open_questions": ["..."],
+  "followups": ["..."],
+  "nextPrompt": "guidance for next turn if status is continue"
+}
+`.trim();
+function buildCodexCommand(options) {
+  const parts = ["codex", "exec", "--dangerously-bypass-approvals-and-sandbox"];
+  if (options.model && options.model !== "codex") {
+    parts.push(`--model ${options.model}`);
+  }
+  if (options.effort) {
+    parts.push(`-c reasoning_effort="${options.effort}"`);
+  }
+  if (options.addDirs?.length) {
+    for (const dir of options.addDirs) {
+      parts.push(`--add-dir "${dir}"`);
+    }
+  }
+  if (options.imagePaths?.length) {
+    for (const img of options.imagePaths) {
+      parts.push(`--image "${img}"`);
+    }
+  }
+  parts.push('< "$FIFONY_PROMPT_FILE"');
+  return parts.join(" ");
+}
+async function compile2(issue, provider, plan, config, workspacePath, skillContext) {
+  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,
+    issueIdentifier: issue.identifier,
+    title: issue.title,
+    description: issue.description || "(none)",
+    workspacePath,
+    planPrompt: buildFullPlanPrompt(plan),
+    phases: (plan.phases ?? []).map((phase) => ({
+      phaseName: phase.phaseName,
+      goal: phase.goal,
+      outputs: phase.outputs ?? []
+    })),
+    suggestedPaths: plan.suggestedPaths ?? [],
+    skillsToUse: plan.toolingDecision?.shouldUseSkills ? plan.toolingDecision.skillsToUse ?? [] : [],
+    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 absoluteDirs = relativeDirs.map((d) => join2(codePath, d));
+  const command = buildCodexCommand({
+    model: provider.model,
+    addDirs: absoluteDirs,
+    effort
+  });
+  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) env2.FIFONY_PLAN_PATHS = plan.suggestedPaths.join(",");
+  const { pre, post } = extractValidationCommands(plan);
+  return {
+    prompt,
+    command,
+    env: env2,
+    preHooks: pre,
+    postHooks: post,
+    outputSchema: "",
+    payload: null,
+    meta: {
+      adapter: "codex",
+      reasoningEffort: effort || "default",
+      model: provider.model || "default",
+      skillsActivated: plan.toolingDecision?.skillsToUse?.map((s) => s.name) || [],
+      subagentsRequested: [],
+      phasesCount: plan.phases?.length || 0
+    }
+  };
+}
+var codexAdapter = {
+  buildCommand: buildCodexCommand,
+  buildReviewCommand: (reviewer) => buildCodexCommand({
+    model: reviewer.model,
+    effort: reviewer.reasoningEffort
+  }),
+  compile: compile2
+};
+
+// src/agents/adapters/gemini.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+var GEMINI_RESULT_CONTRACT = `
+Return a JSON object with this exact schema when finished:
+{
+  "status": "done" | "continue" | "blocked" | "failed",
+  "summary": "one paragraph summary of what was done",
+  "root_cause": ["list of root causes found"],
+  "changes_made": ["list of files/changes"],
+  "validation": { "commands_run": ["..."], "result": "pass" | "partial" | "fail" },
+  "open_questions": ["..."],
+  "followups": ["..."],
+  "nextPrompt": "guidance for next turn if status is continue"
+}
+`.trim();
+function buildGeminiCommand(options) {
+  const parts = ["gemini", "--yolo"];
+  if (options.model) {
+    parts.push(`--model ${options.model}`);
+  }
+  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) {
+  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,
+    issueIdentifier: issue.identifier,
+    title: issue.title,
+    description: issue.description || "(none)",
+    workspacePath,
+    planPrompt: buildFullPlanPrompt(plan),
+    phases: (plan.phases ?? []).map((phase) => ({
+      phaseName: phase.phaseName,
+      goal: phase.goal,
+      outputs: phase.outputs ?? []
+    })),
+    suggestedPaths: plan.suggestedPaths ?? [],
+    skillsToUse: plan.toolingDecision?.shouldUseSkills ? plan.toolingDecision.skillsToUse ?? [] : [],
+    validationItems: (plan.validation ?? []).map((value) => ({ value })),
+    outputContract: GEMINI_RESULT_CONTRACT
+  });
+  const relativeDirs = extractPlanDirs(plan);
+  const codePath = existsSync3(join3(workspacePath, "worktree")) ? join3(workspacePath, "worktree") : workspacePath;
+  const absoluteDirs = relativeDirs.map((d) => join3(codePath, d));
+  const command = buildGeminiCommand({
+    model: provider.model,
+    addDirs: absoluteDirs
+  });
+  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) env2.FIFONY_PLAN_PATHS = plan.suggestedPaths.join(",");
+  const { pre, post } = extractValidationCommands(plan);
+  return {
+    prompt,
+    command,
+    env: env2,
+    preHooks: pre,
+    postHooks: post,
+    outputSchema: "",
+    payload: null,
+    meta: {
+      adapter: "gemini",
+      reasoningEffort: effort || "default",
+      model: provider.model || "default",
+      skillsActivated: plan.toolingDecision?.skillsToUse?.map((s) => s.name) || [],
+      subagentsRequested: [],
+      phasesCount: plan.phases?.length || 0
+    }
+  };
+}
+var geminiAdapter = {
+  buildCommand: buildGeminiCommand,
+  buildReviewCommand: (reviewer) => buildGeminiCommand({
+    model: reviewer.model
+  }),
+  compile: compile3
+};
+
+// src/agents/adapters/registry.ts
+var ADAPTERS = {
+  claude: claudeAdapter,
+  codex: codexAdapter,
+  gemini: geminiAdapter
+};
+
+// src/agents/model-discovery.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync4, readFileSync, realpathSync } from "fs";
+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 (!existsSync4(settingsPath)) return {};
+    const raw = readFileSync(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();
+    if (!binPath) return null;
+    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;
+  } catch {
+    return null;
+  }
+}
+async function fetchGeminiModels() {
+  const modelsPath = resolveGeminiModelsFile();
+  if (!modelsPath) return [];
+  try {
+    const content = readFileSync(modelsPath, "utf8");
+    const regex = /export const ([A-Z0-9_]+)\s*=\s*'(gemini-[^']+)';/g;
+    const seen = /* @__PURE__ */ new Set();
+    const stable = [];
+    const preview = [];
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      const [, constName, modelId] = match;
+      if (seen.has(modelId)) continue;
+      if (modelId.includes("embedding")) continue;
+      seen.add(modelId);
+      const isPreview = constName.startsWith("PREVIEW_");
+      const tier = isPreview ? "Preview" : "Stable";
+      const model = { id: modelId, provider: "gemini", label: modelId, tier };
+      if (isPreview) preview.push(model);
+      else stable.push(model);
+    }
+    return [...stable, ...preview];
+  } catch {
+    return [];
+  }
+}
+async function fetchCodexModels() {
+  const cachePath = join4(homedir(), ".codex", "models_cache.json");
+  try {
+    if (existsSync4(cachePath)) {
+      const raw = readFileSync(cachePath, "utf8");
+      const cache = JSON.parse(raw);
+      if (Array.isArray(cache.models) && cache.models.length > 0) {
+        return cache.models.sort((a, b) => {
+          const visA = a.visibility === "list" ? 0 : 1;
+          const visB = b.visibility === "list" ? 0 : 1;
+          if (visA !== visB) return visA - visB;
+          return (a.priority ?? 99) - (b.priority ?? 99);
+        }).map((m) => ({
+          id: m.slug,
+          provider: "codex",
+          label: m.slug,
+          tier: m.description || (m.visibility === "list" ? "Supported" : "Legacy")
+        }));
+      }
+    }
+  } catch {
+  }
+  return [];
+}
+async function fetchAnthropicModels() {
+  try {
+    execFileSync("which", ["claude"], { encoding: "utf8", timeout: 3e3 });
+  } catch {
+    return [];
+  }
+  return [
+    { id: "opus", provider: "claude", label: "claude/opus (latest)", tier: "Most capable" },
+    { id: "sonnet", provider: "claude", label: "claude/sonnet (latest)", tier: "Balanced" },
+    { id: "haiku", provider: "claude", label: "claude/haiku (latest)", tier: "Fast" }
+  ];
+}
+async function discoverModels(providers) {
+  const result = {};
+  const tasks = [];
+  for (const p of providers) {
+    if (!p.available) continue;
+    const cached = modelCache.get(p.name);
+    if (cached && Date.now() - cached.fetchedAt < MODEL_CACHE_TTL_MS) {
+      result[p.name] = cached.models;
+      continue;
+    }
+    if (p.name === "codex") tasks.push({ name: "codex", fetch: fetchCodexModels });
+    if (p.name === "claude") tasks.push({ name: "claude", fetch: fetchAnthropicModels });
+    if (p.name === "gemini") tasks.push({ name: "gemini", fetch: fetchGeminiModels });
+  }
+  const settled = await Promise.allSettled(tasks.map((t) => t.fetch()));
+  for (let i = 0; i < tasks.length; i++) {
+    const res = settled[i];
+    let models = res.status === "fulfilled" ? res.value : [];
+    if (tasks[i].name === "codex") {
+      const { model: configuredModel } = readCodexConfig();
+      if (configuredModel) {
+        const idx = models.findIndex((m) => m.id === configuredModel);
+        if (idx > 0) {
+          models = [models[idx], ...models.slice(0, idx), ...models.slice(idx + 1)];
+        } else if (idx === -1) {
+          models = [{ id: configuredModel, provider: "codex", label: configuredModel, tier: "Configured default" }, ...models];
+        }
+      }
+    }
+    if (tasks[i].name === "claude") {
+      const { model: configuredModel } = readClaudeConfig();
+      if (configuredModel) {
+        const idx = models.findIndex((m) => m.id === configuredModel || m.id.includes(configuredModel));
+        if (idx > 0) {
+          models = [models[idx], ...models.slice(0, idx), ...models.slice(idx + 1)];
+        }
+      }
+    }
+    if (tasks[i].name === "gemini") {
+      const { model: configuredModel, previewFeatures } = readGeminiConfig();
+      if (configuredModel) {
+        const idx = models.findIndex((m) => m.id === configuredModel);
+        if (idx > 0) {
+          models = [models[idx], ...models.slice(0, idx), ...models.slice(idx + 1)];
+        } else if (idx === -1) {
+          models = [{ id: configuredModel, provider: "gemini", label: configuredModel, tier: "Configured default" }, ...models];
+        }
+      } else if (previewFeatures) {
+        const previewIdx = models.findIndex((m) => m.tier === "Preview");
+        if (previewIdx > 0) {
+          models = [models[previewIdx], ...models.slice(0, previewIdx), ...models.slice(previewIdx + 1)];
+        }
+      }
+    }
+    result[tasks[i].name] = models;
+    modelCache.set(tasks[i].name, { models, fetchedAt: Date.now() });
+  }
+  return result;
+}
+
+// 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;
+  if (!normalized) return "codex";
+  return normalized;
+}
+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];
+  if (issueEffort?.default) return issueEffort.default;
+  if (globalEffort?.[roleKey]) return globalEffort[roleKey];
+  return globalEffort?.default;
+}
+function getProviderDefaultCommand(provider, reasoningEffort, model) {
+  const adapter = ADAPTERS[provider];
+  if (!adapter) return "";
+  const jsonSchema = provider === "claude" ? CLAUDE_RESULT_SCHEMA : void 0;
+  return adapter.buildCommand({ model, effort: reasoningEffort, jsonSchema });
+}
+var cachedProviders = null;
+var providersCachedAt = 0;
+var PROVIDER_CACHE_TTL = 6e4;
+function detectAvailableProviders() {
+  if (cachedProviders && Date.now() - providersCachedAt < PROVIDER_CACHE_TTL) {
+    return cachedProviders;
+  }
+  const providers = [];
+  for (const name of ["claude", "codex", "gemini"]) {
+    try {
+      const path = execFileSync2("which", [name], { encoding: "utf8", timeout: 5e3 }).trim();
+      providers.push({ name, available: true, path });
+    } catch {
+      providers.push({ name, available: false, path: "" });
+    }
+  }
+  cachedProviders = providers;
+  providersCachedAt = Date.now();
+  return providers;
+}
+function readCodexConfig() {
+  try {
+    const configPath = join5(homedir2(), ".codex", "config.toml");
+    if (!existsSync5(configPath)) return {};
+    const raw = readFileSync2(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 };
+  } catch {
+    return {};
+  }
+}
+function readGeminiConfig() {
+  try {
+    const settingsPath = join5(homedir2(), ".gemini", "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,
+      previewFeatures: settings.general?.previewFeatures === true
+    };
+  } 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: ""
+    }
+  ];
+}
+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":
+      return "plan";
+    case "executor":
+      return "execute";
+    case "reviewer":
+      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 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 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);
+}
+
+// src/agents/command-executor.ts
+async function runCommandWithTimeout(command, workspacePath, issue, config, promptText, promptFile, extraEnv = {}) {
+  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_ISSUE_PRIORITY: String(issue.priority),
+      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");
+    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 {
+      }
+      issue.commandOutputTail = output;
+    };
+    child.stdout?.on("data", onChunk);
+    child.stderr?.on("data", onChunk);
+    const AGENT_STALE_OUTPUT_MS = 3e5;
+    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, {
+    pollIntervalMs: 0,
+    workerConcurrency: 1,
+    maxConcurrentByState: {},
+    commandTimeoutMs: 3e5,
+    maxAttemptsDefault: 1,
+    retryDelayMs: 0,
+    staleInProgressTimeoutMs: 0,
+    logLinesTail: 12e3,
+    agentProvider: normalizeAgentProvider(env.FIFONY_AGENT_PROVIDER ?? "codex"),
+    agentCommand: command,
+    maxTurns: 1,
+    runMode: "filesystem"
+  }, "", "", { FIFONY_HOOK_NAME: hookName, ...extraEnv });
+  if (!result.success) {
+    throw new Error(`${hookName} hook failed: ${result.output}`);
+  }
+}
+
+// src/agents/prompt-builder.ts
+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) {
+  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,
+    capabilityCategory: provider.capabilityCategory || "",
+    selectionReason: provider.selectionReason ?? "No additional routing reason.",
+    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_") && extname(base) === ".json") return true;
+  if (extname(base) === ".xlsx") return true;
+  return false;
+}
+var sourceReadyPromise = null;
+var skipSourceFlag = false;
+function setSkipSource(skip) {
+  skipSourceFlag = skip;
+}
+async function ensureSourceReady(onProgress) {
+  if (skipSourceFlag) {
+    onProgress?.("ready");
+    return;
+  }
+  if (existsSync6(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 isGitRepo(dir) {
+  try {
+    execSync("git rev-parse --git-dir", { cwd: dir, stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+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";
+  }
+}
+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 = readFileSync3(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;
+  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 = !existsSync6(worktreePath);
+  if (createdNow) {
+    mkdirSync(workspaceRoot, { recursive: true });
+    logger.debug({ issueId: issue.id, identifier: issue.identifier, workspacePath: workspaceRoot }, "[Agent] Creating workspace");
+    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)
+      });
+    }
+    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 (!existsSync6(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?.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-3JLC6EXY.js");
+  const issueResource2 = getIssueStateResource();
+  if (!issueResource2) 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 issueResource2.get?.(issue.id).catch(() => null);
+  const previousLinesAdded = toNumber(current?.linesAdded);
+  const previousLinesRemoved = toNumber(current?.linesRemoved);
+  const previousFilesChanged = toNumber(current?.filesChanged);
+  await issueResource2.patch(issue.id, {
+    linesAdded: nextLinesAdded,
+    linesRemoved: nextLinesRemoved,
+    filesChanged: nextFilesChanged,
+    branchName: issue.branchName
+  });
+  const add = issueResource2.add;
+  const sub = issueResource2.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(issueResource2, issue.id, field, delta);
+    } else if (delta < 0) {
+      await sub.call(issueResource2, 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) {
+  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 {
+    }
+    try {
+      execSync("git merge --abort", { cwd: TARGET_ROOT, stdio: "pipe" });
+    } catch {
+    }
+    logger.warn({ issueId: issue.id, err: String(err) }, "[Agent] Git merge failed, aborted");
+  }
+  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 mergeWorkspace(issue) {
+  if (!issue.branchName || !issue.baseBranch || !issue.worktreePath) {
+    throw new Error(`Issue ${issue.identifier} has no git worktree \u2014 cannot 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 cancelled = 0;
+  const completionTimes = [];
+  for (const issue of issues) {
+    const duration = issue.durationMs;
+    if (issue.state === "Done") {
+      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 "Cancelled":
+        cancelled += 1;
+        break;
+    }
+  }
+  if (completionTimes.length === 0) {
+    return {
+      total: issues.length,
+      planning,
+      queued,
+      inProgress,
+      blocked,
+      done,
+      cancelled,
+      activeWorkers: 0
+    };
+  }
+  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,
+    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) {
+    try {
+      fsmEventEmitter(issueId, kind, message);
+    } catch {
+    }
+  }
+}
+async function lazyEnqueueForPlanning(issue) {
+  const { enqueueForPlanning } = await import("./queue-workers-2I7VRZA7.js");
+  return enqueueForPlanning(issue);
+}
+async function lazyEnqueueForExecution(issue) {
+  const { enqueueForExecution } = await import("./queue-workers-2I7VRZA7.js");
+  return enqueueForExecution(issue);
+}
+async function lazyEnqueueForReview(issue) {
+  const { enqueueForReview } = await import("./queue-workers-2I7VRZA7.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: { REOPEN: "Planning" },
+          type: "final",
+          entry: "onEnterDone"
+        },
+        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);
+      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;
+        issue.nextRetryAt = void 0;
+        issue.lastError = void 0;
+        emitFsmEvent(issue.id, "state", `${issue.identifier} completed.`);
+      }
+      const res = issueResource(machine);
+      if (res) {
+        res.patch(machine.entityId, {
+          completedAt: ts,
+          terminalWeek: week,
+          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(() => {
+        });
+      }
+    },
+    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",
+  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 {
+      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 });
+      }
+    }
+  }
+  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 = "";
+  }
+  markDirtyAndInvalidate(issue.id);
+  return { previousState: previous };
+}
+async function getIssueTransitionHistory(issueId, options) {
+  const resourceApi = getIssueResourceStateApi();
+  if (resourceApi?.history) {
+    try {
+      return await resourceApi.history(issueId, options);
+    } catch {
+    }
+  }
+  const plugin = getIssueStateMachinePlugin();
+  if (plugin?.getTransitionHistory) {
+    try {
+      return await plugin.getTransitionHistory(ISSUE_STATE_MACHINE_ID, issueId, options);
+    } catch {
+    }
+  }
+  return [];
+}
+async function canTransitionIssue(issueId, event) {
+  const resourceApi = getIssueResourceStateApi();
+  if (resourceApi?.canTransition) {
+    try {
+      return await resourceApi.canTransition(issueId, event);
+    } catch {
+    }
+  }
+  return false;
+}
+function visualizeStateMachine() {
+  const plugin = getIssueStateMachinePlugin();
+  if (!plugin?.visualize) return null;
+  return plugin.visualize(ISSUE_STATE_MACHINE_ID);
+}
+
+export {
+  buildFullPlanPrompt,
+  buildExecutionPayload,
+  ADAPTERS,
+  discoverModels,
+  normalizeAgentProvider,
+  resolveAgentCommand,
+  getProviderDefaultCommand,
+  detectAvailableProviders,
+  readCodexConfig,
+  resolveDefaultProvider,
+  getCapabilityRoutingOptions,
+  applyCapabilityMetadata,
+  getEffectiveAgentProviders,
+  computeMetrics,
+  computeCapabilityCounts,
+  getMetrics,
+  runCommandWithTimeout,
+  runHook,
+  buildTurnPrompt,
+  buildProviderBasePrompt,
+  setSkipSource,
+  detectDefaultBranch,
+  prepareWorkspace,
+  cleanWorkspace,
+  computeDiffStats,
+  parseDiffStats,
+  syncIssueDiffStatsToStore,
+  ensureWorktreeCommitted,
+  pushWorktreeBranch,
+  mergeWorkspace,
+  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
+};
+//# sourceMappingURL=chunk-3QSBGJMT.js.map