fifony 0.1.36 → 0.1.38

package/dist/{chunk-A7BVAGPW.js → chunk-YBMQIQ2X.js}

@@ -14,14 +14,13 @@ import {
   markAllIssuesDirty,
   markEventDirty,
   markIssueDirty,
-  markIssuePlanDirty,
   setFsmEventEmitter,
   setIssueResourceStateApi,
   setIssueStateMachinePlugin,
   snapshotAndClearDirtyEventIds,
   snapshotAndClearDirtyIssueIds,
   snapshotAndClearDirtyIssuePlanIds
-} from "./chunk-QBAR5JLY.js";
+} from "./chunk-FDR47R6J.js";
 import {
   ADAPTERS,
   assertIssueHasGitWorktree,
@@ -49,10 +48,9 @@ import {
   parseDiffStats,
   prepareWorkspace,
   readCodexConfig,
-  resolveAgentCommand,
   runCommandWithTimeout,
   runHook
-} from "./chunk-LUIPCPRO.js";
+} from "./chunk-VOA5UMXD.js";
 import {
   appendFileTail,
   clamp,
@@ -74,15 +72,14 @@ import {
   toStringArray,
   toStringValue,
   withRetryBackoff
-} from "./chunk-O5AEQXUV.js";
+} from "./chunk-T2YJOZ6N.js";
 import {
   enqueue
-} from "./chunk-GYVLPWYB.js";
+} from "./chunk-DYOLZYEC.js";
 import {
   logger
 } from "./chunk-DVU3CXWA.js";
 import {
-  ALLOWED_STATES,
   ATTACHMENTS_ROOT,
   COMPLETED_STATES,
   EXECUTING_STATES,
@@ -94,6 +91,7 @@ import {
   FRONTEND_OFFLINE_HTML,
   FRONTEND_SERVICE_WORKER_JS,
   PERSIST_EVENTS_MAX,
+  QUIET_MODE,
   S3DB_AGENT_PIPELINE_RESOURCE,
   S3DB_AGENT_SESSION_RESOURCE,
   S3DB_DATABASE_PATH,
@@ -109,7 +107,7 @@ import {
   TARGET_ROOT,
   TERMINAL_STATES,
   WORKSPACE_ROOT
-} from "./chunk-OONOOWNC.js";
+} from "./chunk-37N5OFHM.js";
 
 // src/agents/issue-runner.ts
 import {
@@ -293,20 +291,17 @@ function getAnalytics(topN = 20) {
 }
 
 // src/domains/project.ts
-import { execFileSync as execFileSync2, spawn as spawn3 } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
 import { createHash } from "crypto";
 import {
   existsSync as existsSync13,
   mkdirSync as mkdirSync7,
-  mkdtempSync as mkdtempSync4,
   readdirSync as readdirSync4,
   readFileSync as readFileSync10,
-  rmSync as rmSync5,
   writeFileSync as writeFileSync11
 } from "fs";
-import { homedir as homedir3, tmpdir as tmpdir4 } from "os";
+import { homedir as homedir3 } from "os";
 import { basename as basename4, dirname as dirname2, join as join16, relative as relativePath, resolve as resolve2 } from "path";
-import { env as env3 } from "process";
 
 // src/persistence/plugins/api-runtime-context.ts
 var context = null;
@@ -1726,9 +1721,279 @@ async function cancelIssueCommand(input, deps) {
     { issue, target: "Cancelled", note: "Manual cancel requested." },
     deps
   );
+  if (deps.state) {
+    try {
+      await cleanWorkspace(issue.id, issue, deps.state);
+      issue.workspacePath = void 0;
+      issue.worktreePath = void 0;
+    } catch (error) {
+      logger.warn({ issueId: issue.id, err: String(error) }, "[Command] Failed to clean workspace during cancel");
+    }
+  }
   deps.eventStore.addEvent(issue.id, "manual", `Manual cancel requested for ${issue.id}.`);
 }
 
+// src/commands/merge-workspace.command.ts
+import { existsSync as existsSync6 } from "fs";
+import { execSync } from "child_process";
+
+// src/domains/validation.ts
+import { execFile } from "child_process";
+async function runValidationGate(issue, config) {
+  if (!config.testCommand) return null;
+  const cwd = issue.worktreePath ?? issue.workspacePath;
+  if (!cwd) {
+    logger.warn({ issueId: issue.id }, "[Validation] No workspace path \u2014 skipping gate");
+    return null;
+  }
+  const command = config.testCommand;
+  logger.info({ issueId: issue.id, command, cwd }, "[Validation] Running validation gate");
+  return new Promise((resolve3) => {
+    const child = execFile("sh", ["-c", command], {
+      cwd,
+      encoding: "utf8",
+      timeout: 3e5,
+      maxBuffer: 2 * 1024 * 1024
+    }, (err, stdout, stderr) => {
+      const combined = (stdout || "") + (stderr || "");
+      if (!err) {
+        logger.info({ issueId: issue.id }, "[Validation] Gate passed");
+        resolve3({
+          passed: true,
+          output: combined.slice(-2048),
+          command,
+          ranAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return;
+      }
+      logger.warn({ issueId: issue.id, exitCode: err.code }, "[Validation] Gate failed");
+      resolve3({
+        passed: false,
+        output: combined.slice(-2048) || String(err).slice(0, 2048),
+        command,
+        ranAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    });
+  });
+}
+
+// src/commands/merge-workspace.command.ts
+async function mergeWorkspaceCommand(input, deps) {
+  const { issue, state, squashAlreadyApplied } = input;
+  if (!["Approved", "Reviewing", "PendingDecision"].includes(issue.state)) {
+    throw new Error(`Issue ${issue.identifier} is in state ${issue.state}. Merge is only allowed in Reviewing, PendingDecision, or Approved state.`);
+  }
+  ensureGitRepoReadyForWorktrees(TARGET_ROOT, "merge issues");
+  if (issue.state === "Reviewing" || issue.state === "PendingDecision") {
+    await transitionIssueCommand(
+      { issue, target: "Approved", note: "Approved and merged by user." },
+      deps
+    );
+  }
+  const wp = issue.worktreePath ?? issue.workspacePath;
+  if (!wp || !existsSync6(wp)) {
+    throw new Error(`No mergeable workspace found for ${issue.identifier}. This issue likely ran before git was initialized for the project. Re-run the issue after git setup.`);
+  }
+  if (issue.branchName && issue.baseBranch) {
+    try {
+      const stat = execSync(
+        `git diff --stat "${issue.baseBranch}"..."${issue.branchName}"`,
+        { encoding: "utf8", cwd: TARGET_ROOT, stdio: "pipe", maxBuffer: 512e3, timeout: 1e4 }
+      );
+      parseDiffStats(issue, stat);
+      logger.info({ issueId: issue.id, linesAdded: issue.linesAdded, linesRemoved: issue.linesRemoved, filesChanged: issue.filesChanged }, "[Merge] Diff stats computed");
+    } catch (err) {
+      logger.warn({ err: String(err), issueId: issue.id }, "[Merge] Failed to compute diff stats");
+    }
+  }
+  const validation = await runValidationGate(issue, state.config);
+  if (validation) {
+    issue.validationResult = validation;
+    if (!validation.passed) {
+      throw new Error(`Validation gate failed (${validation.command}): ${validation.output.slice(0, 500)}`);
+    }
+  }
+  let result;
+  if (squashAlreadyApplied) {
+    try {
+      execSync("git add -A", { cwd: TARGET_ROOT, stdio: "pipe", timeout: 1e4 });
+      execSync(
+        `git commit -m "fifony: merge ${issue.identifier}"`,
+        { cwd: TARGET_ROOT, stdio: "pipe", timeout: 1e4 }
+      );
+      logger.info({ issueId: issue.id }, "[Merge] Committed existing test squash");
+    } catch (err) {
+      throw new Error(`Failed to commit test squash: ${err.stderr || err.stdout || String(err)}`);
+    }
+    issue.testApplied = false;
+    result = { copied: [], deleted: [], skipped: [], conflicts: [] };
+  } else {
+    try {
+      const indexStatus = execSync("git diff --cached --name-only", { cwd: TARGET_ROOT, encoding: "utf8", stdio: "pipe" }).trim();
+      const wtStatus = execSync("git diff --name-only", { cwd: TARGET_ROOT, encoding: "utf8", stdio: "pipe" }).trim();
+      if (indexStatus && !wtStatus) {
+        execSync("git reset --hard HEAD", { cwd: TARGET_ROOT, stdio: "pipe" });
+        logger.info({ issueId: issue.id }, "[Command] Cleared residual squash from index before merge");
+      }
+    } catch {
+    }
+    const mergeResult = mergeWorkspace(issue);
+    result = mergeResult;
+  }
+  issue.mergeResult = {
+    copied: result.copied.length,
+    deleted: result.deleted.length,
+    skipped: result.skipped.length,
+    conflicts: result.conflicts.length,
+    conflictFiles: result.conflicts.length > 0 ? result.conflicts : void 0
+  };
+  if (result.conflicts.length > 0) {
+    deps.eventStore.addEvent(issue.id, "error", `Merge conflicts: ${result.conflicts.join(", ")}`);
+    await deps.persistencePort.persistState(state);
+    return result;
+  }
+  if (!issue.mergedReason) issue.mergedReason = squashAlreadyApplied ? "Approved and shipped after testing." : "Merged by user.";
+  await transitionIssueCommand(
+    { issue, target: "Merged", note: `Workspace merged for ${issue.identifier}.` },
+    deps
+  );
+  if (issue.workspacePath) {
+    try {
+      await cleanWorkspace(issue.id, issue, state);
+      issue.workspacePath = void 0;
+      issue.worktreePath = void 0;
+    } catch {
+    }
+  }
+  await deps.persistencePort.persistState(state);
+  return result;
+}
+
+// src/commands/push-workspace.command.ts
+import { execFileSync, execSync as execSync2 } from "child_process";
+function isGhAvailable() {
+  try {
+    execFileSync("gh", ["--version"], { stdio: "pipe", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getCompareUrl(branchName, baseBranch) {
+  try {
+    const remote = execSync2("git remote get-url origin", { cwd: TARGET_ROOT, encoding: "utf8", stdio: "pipe" }).trim();
+    const cleanRemote = remote.replace(/\.git$/, "");
+    return `${cleanRemote}/compare/${baseBranch}...${branchName}`;
+  } catch {
+    return `(branch pushed: ${branchName})`;
+  }
+}
+function findExistingPr(branchName) {
+  try {
+    const result = execFileSync(
+      "gh",
+      ["pr", "view", branchName, "--json", "url,state", "--jq", 'select(.state == "OPEN") | .url'],
+      { cwd: TARGET_ROOT, encoding: "utf8", stdio: "pipe", timeout: 15e3 }
+    ).trim();
+    return result || null;
+  } catch {
+    return null;
+  }
+}
+function createPr(branchName, baseBranch, title, body) {
+  return execFileSync(
+    "gh",
+    ["pr", "create", "--head", branchName, "--base", baseBranch, "--title", title, "--body", body],
+    { cwd: TARGET_ROOT, encoding: "utf8", stdio: "pipe", timeout: 3e4 }
+  ).trim();
+}
+async function pushWorkspaceCommand(input, deps) {
+  const { issue, state } = input;
+  if (!["Approved", "Reviewing", "PendingDecision"].includes(issue.state)) {
+    throw new Error(`Issue ${issue.identifier} is in state ${issue.state}. Push is only allowed in Reviewing, PendingDecision, or Approved state.`);
+  }
+  ensureGitRepoReadyForWorktrees(TARGET_ROOT, "push issue branches");
+  assertIssueHasGitWorktree(issue, "push");
+  if (issue.testApplied) {
+    try {
+      execSync2("git reset --hard HEAD", { cwd: TARGET_ROOT, stdio: "pipe", timeout: 15e3 });
+      execSync2("git clean -fd", { cwd: TARGET_ROOT, stdio: "pipe", timeout: 15e3 });
+      issue.testApplied = false;
+      deps.eventStore.addEvent(issue.id, "info", "Auto-reverted test squash before push.");
+      logger.info({ issueId: issue.id }, "[Push] Auto-reverted test squash before push");
+    } catch (err) {
+      const msg = err.stderr || err.stdout || String(err);
+      throw new Error(`Failed to revert test squash before push: ${msg}`);
+    }
+  }
+  if (issue.state === "Reviewing" || issue.state === "PendingDecision") {
+    await transitionIssueCommand(
+      { issue, target: "Approved", note: "Approved and pushed by user." },
+      deps
+    );
+  }
+  ensureWorktreeCommitted(issue);
+  const validation = await runValidationGate(issue, state.config);
+  if (validation) {
+    issue.validationResult = validation;
+    if (!validation.passed) {
+      throw new Error(`Validation gate failed (${validation.command}): ${validation.output.slice(0, 500)}`);
+    }
+  }
+  computeDiffStats(issue);
+  const planSummary = issue.plan?.summary ?? issue.title;
+  let diffStat = "";
+  try {
+    diffStat = execSync2(
+      `git diff --stat "${issue.baseBranch}"..."${issue.branchName}"`,
+      { cwd: TARGET_ROOT, encoding: "utf8", maxBuffer: 512e3, timeout: 1e4, stdio: "pipe" }
+    ).trim();
+  } catch {
+  }
+  const body = `## Summary
+${planSummary}
+
+## Diff Stats
+\`\`\`
+${diffStat || "No diff stats available"}
+\`\`\`
+
+*Automated by fifony*`;
+  execSync2(`git push -u origin "${issue.branchName}"`, { cwd: TARGET_ROOT, stdio: "pipe" });
+  const prBase = state.config.prBaseBranch || issue.baseBranch;
+  const ghAvailable = isGhAvailable();
+  let prUrl;
+  if (!ghAvailable) {
+    prUrl = getCompareUrl(issue.branchName, prBase);
+    logger.info({ issueId: issue.id, prUrl }, "[Push] gh CLI not available \u2014 using compare URL");
+  } else {
+    const existingUrl = findExistingPr(issue.branchName);
+    if (existingUrl) {
+      prUrl = existingUrl;
+      logger.info({ issueId: issue.id, prUrl }, "[Push] Existing open PR found");
+    } else {
+      try {
+        prUrl = createPr(issue.branchName, prBase, issue.title, body);
+        logger.info({ issueId: issue.id, prUrl }, "[Push] PR created");
+      } catch (err) {
+        const ghError = (err.stderr || err.stdout || String(err)).toString().slice(0, 500);
+        logger.error({ issueId: issue.id, ghError }, "[Push] gh pr create failed");
+        prUrl = getCompareUrl(issue.branchName, prBase);
+        deps.eventStore.addEvent(issue.id, "error", `gh pr create failed: ${ghError}. Branch was pushed \u2014 use the compare URL to create the PR manually.`);
+      }
+    }
+  }
+  issue.prUrl = prUrl;
+  if (!issue.mergedReason) issue.mergedReason = "Pushed to origin and PR created.";
+  await transitionIssueCommand(
+    { issue, target: "Merged", note: `Branch ${issue.branchName} pushed. PR: ${prUrl}` },
+    deps
+  );
+  deps.eventStore.addEvent(issue.id, "merge", `PR created: ${prUrl}`);
+  await deps.persistencePort.persistState(state);
+  return { prUrl, ghAvailable };
+}
+
 // src/persistence/resources/issues.resource.ts
 function getIssueId(c) {
   if (!c || typeof c !== "object" || !("req" in c) || !c.req || typeof c.req !== "object") {
@@ -1781,7 +2046,18 @@ async function patchIssueState(c) {
   }
   try {
     const payload = await c.req.json();
-    await handleStatePatch(context2.state, issue, payload);
+    const nextState = parseIssueState(payload.state);
+    if (!nextState) {
+      throw new Error(`Unsupported state: ${String(payload.state)}`);
+    }
+    const container = getContainer();
+    const reason = payload.reason ? toStringValue(payload.reason) : void 0;
+    logger.info({ issueId, identifier: issue.identifier, targetState: nextState }, "[API] POST /api/issues/:id/state");
+    await transitionIssueCommand({
+      issue,
+      target: nextState,
+      note: reason || `Manual state update: ${nextState}`
+    }, container);
     await persistState(context2.state);
     return { body: { ok: true, issue } };
   } catch (error) {
@@ -1798,17 +2074,41 @@ async function retryIssue(c) {
   if (!issue) {
     return { status: 404, body: { ok: false, error: "Issue not found" } };
   }
+  let feedback;
+  try {
+    const body = await c.req.json();
+    if (body?.feedback) feedback = toStringValue(body.feedback);
+  } catch {
+  }
   const container = getContainer();
+  logger.info({ issueId, state: issue.state, lastFailedPhase: issue.lastFailedPhase, attempts: issue.attempts }, "[API] Retry \u2014 dispatching");
+  const note = feedback ? `Rework requested for ${issue.identifier}: ${feedback.slice(0, 200)}` : `Manual retry for ${issue.identifier}.`;
   if (TERMINAL_STATES.has(issue.state)) {
+    await transitionIssueCommand({ issue, target: "Planning", note }, container);
+    if (issue.plan?.steps?.length) {
+      await transitionIssueCommand({ issue, target: "PendingApproval", note: "Existing plan found." }, container);
+      await transitionIssueCommand({ issue, target: "Queued", note: "Auto-queued after plan approval." }, container);
+    }
+  } else if (issue.state === "Blocked" && issue.lastFailedPhase === "review") {
     issue.lastError = void 0;
-    issue.nextRetryAt = void 0;
-    await transitionIssueCommand(
-      { issue, target: "Queued", note: "Manual retry requested." },
-      container
-    );
+    issue.lastFailedPhase = void 0;
+    await transitionIssueCommand({ issue, target: "Reviewing", note }, container);
+  } else if (issue.state === "Blocked") {
+    await transitionIssueCommand({ issue, target: "Queued", note }, container);
+  } else if (issue.state === "Approved") {
+    await transitionIssueCommand({ issue, target: "Planning", note }, container);
+    if (issue.plan?.steps?.length) {
+      await transitionIssueCommand({ issue, target: "PendingApproval", note: "Existing plan found." }, container);
+      await transitionIssueCommand({ issue, target: "Queued", note: "Auto-queued for rework." }, container);
+    }
+  } else if (issue.state === "Reviewing" || issue.state === "PendingDecision") {
+    const reworkNote = feedback || issue.lastError || "Manual rework request.";
+    await transitionIssueCommand({ issue, target: "Queued", note: reworkNote }, container);
+  } else if (issue.state === "PendingApproval") {
+    await transitionIssueCommand({ issue, target: "Queued", note }, container);
   } else {
-    issue.nextRetryAt = void 0;
     issue.lastError = void 0;
+    issue.nextRetryAt = void 0;
     issue.updatedAt = now();
   }
   addEvent(context2.state, issue.id, "manual", `Manual retry requested for ${issue.id}.`);
@@ -1841,19 +2141,57 @@ async function cancelIssue(c) {
   }
   await cancelIssueCommand(
     { issue },
-    getContainer()
+    { ...getContainer(), state: context2.state }
   );
   addEvent(context2.state, issue.id, "manual", `Manual cancel requested for ${issue.id}.`);
   await persistState(context2.state);
   return { body: { ok: true, issue } };
 }
-var issues_resource_default = {
-  name: S3DB_ISSUE_RESOURCE,
-  attributes: {
-    id: "string|required",
-    identifier: "string|required",
-    title: "string|required",
-    description: "string|optional",
+async function approveAndMerge(c) {
+  const context2 = getApiRuntimeContextOrThrow();
+  const issueId = getIssueId(c);
+  if (!issueId) {
+    return { status: 400, body: { ok: false, error: "Issue id is required." } };
+  }
+  const issue = findIssue(context2.state, issueId);
+  if (!issue) {
+    return { status: 404, body: { ok: false, error: "Issue not found" } };
+  }
+  if (issue.state !== "PendingDecision" && issue.state !== "Reviewing" && issue.state !== "Approved") {
+    return { status: 400, body: { ok: false, error: `Cannot approve-and-merge from state ${issue.state}. Expected PendingDecision, Reviewing, or Approved.` } };
+  }
+  try {
+    const container = getContainer();
+    const mergeMode = context2.state.config.mergeMode;
+    logger.info({ issueId, state: issue.state, testApplied: issue.testApplied, mergeMode }, "[API] POST /api/issues/:id/approve-and-merge");
+    if (mergeMode === "push-pr") {
+      if (issue.state !== "Approved") {
+        await transitionIssueCommand(
+          { issue, target: "Approved", note: "Approved for push-pr." },
+          container
+        );
+      }
+      await pushWorkspaceCommand({ issue }, { ...container, state: context2.state });
+    } else {
+      await mergeWorkspaceCommand(
+        { issue, squashAlreadyApplied: issue.testApplied ?? false },
+        { ...container, state: context2.state }
+      );
+    }
+    addEvent(context2.state, issue.id, "manual", `Approved and ${mergeMode === "push-pr" ? "pushed PR for" : "merged"} ${issue.identifier}.`);
+    await persistState(context2.state);
+    return { body: { ok: true, issue } };
+  } catch (error) {
+    return { status: 409, body: { ok: false, error: error instanceof Error ? error.message : String(error) } };
+  }
+}
+var issues_resource_default = {
+  name: S3DB_ISSUE_RESOURCE,
+  attributes: {
+    id: "string|required",
+    identifier: "string|required",
+    title: "string|required",
+    description: "string|optional",
     state: "string|required",
     branchName: "string|optional",
     url: "string|optional",
@@ -1886,11 +2224,10 @@ var issues_resource_default = {
     commandOutputTail: "string|optional",
     terminalWeek: "string|optional",
     usage: "json|optional",
+    testApplied: "boolean|optional",
     tokenUsage: "json|optional",
     tokensByPhase: "json|optional",
     tokensByModel: "json|optional",
-    plan: "json|optional",
-    planHistory: "json|optional",
     planVersion: "number|optional",
     planningStatus: "string|optional",
     planningStartedAt: "datetime|optional",
@@ -1965,6 +2302,13 @@ var issues_resource_default = {
         return c.json(result.body, result.status);
       }
       return result.body;
+    },
+    "POST /:id/approve-and-merge": async (c) => {
+      const result = await approveAndMerge(c);
+      if (result.status) {
+        return c.json(result.body, result.status);
+      }
+      return result.body;
     }
   }
 };
@@ -1974,9 +2318,14 @@ var issue_plans_resource_default = {
   name: S3DB_ISSUE_PLAN_RESOURCE,
   attributes: {
     id: "string|required",
-    plan: "json|optional",
-    planHistory: "json|optional",
-    planVersion: "number|required"
+    issueId: "string|required",
+    version: "number|required",
+    current: "boolean|required",
+    plan: "json|required"
+  },
+  partitions: {
+    byIssue: { fields: { issueId: "string" } },
+    byIssueCurrent: { fields: { issueId: "string", current: "boolean" } }
   },
   behavior: "body-overflow",
   paranoid: false,
@@ -2353,13 +2702,13 @@ function hasTerminalQueue(state) {
 }
 
 // src/agents/providers-usage.ts
-import { execFile } from "child_process";
+import { execFile as execFile2 } from "child_process";
 import { promisify } from "util";
-import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync2, realpathSync } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync5, readdirSync as readdirSync2, realpathSync } from "fs";
 import { join as join8, dirname } from "path";
 import { homedir as homedir2 } from "os";
 import { env } from "process";
-var execFileAsync = promisify(execFile);
+var execFileAsync = promisify(execFile2);
 async function whichExists(cmd) {
   try {
     await execFileAsync("which", [cmd], { encoding: "utf8", timeout: 3e3 });
@@ -2394,7 +2743,7 @@ function resolveCodexHomeCandidates() {
 }
 function resolveCodexDir() {
   for (const candidate of resolveCodexHomeCandidates()) {
-    if (existsSync6(candidate)) {
+    if (existsSync7(candidate)) {
       return candidate;
     }
   }
@@ -2402,7 +2751,7 @@ function resolveCodexDir() {
 }
 function findLatestCodexDb(codexDir) {
   const explicit = join8(codexDir, "state_5.sqlite");
-  if (existsSync6(explicit)) return explicit;
+  if (existsSync7(explicit)) return explicit;
   const candidates = readdirSync2(codexDir).filter((name) => name.startsWith("state_") && name.endsWith(".sqlite")).sort().reverse();
   if (candidates.length === 0) return null;
   return join8(codexDir, candidates[0]);
@@ -2467,7 +2816,7 @@ function resolveClaudePlanKey(displayName) {
 async function collectClaudeUsage() {
   const home = homedir2();
   const claudeDir = join8(home, ".claude");
-  if (!existsSync6(claudeDir)) return null;
+  if (!existsSync7(claudeDir)) return null;
   const available = await whichExists("claude");
   const projectsDir = join8(claudeDir, "projects");
   let totalInputTokens = 0;
@@ -2488,7 +2837,7 @@ async function collectClaudeUsage() {
   const weekMs = weekStart.getTime();
   const last5hStart = computeLastHoursStart(5);
   const last5hMs = last5hStart.getTime();
-  if (existsSync6(projectsDir)) {
+  if (existsSync7(projectsDir)) {
     try {
       const projectDirs = readdirSync2(projectsDir, { withFileTypes: true });
       for (const dir of projectDirs) {
@@ -2570,7 +2919,7 @@ async function collectClaudeUsage() {
   let resetInfo = "Weekly reset (every Monday 00:00 UTC)";
   let currentModel = "";
   const settingsPath = join8(claudeDir, "settings.json");
-  if (existsSync6(settingsPath)) {
+  if (existsSync7(settingsPath)) {
     try {
       const settings = JSON.parse(readFileSync5(settingsPath, "utf8"));
       if (settings.plan === "max" || settings.plan === "max5x") {
@@ -2694,7 +3043,7 @@ function aggregateCodexSessionUsageFromJsonl(lines) {
 }
 function collectCodexSessionUsagesFromJsonl(codexDir) {
   const sessionsDir = join8(codexDir, "sessions");
-  if (!existsSync6(sessionsDir)) return [];
+  if (!existsSync7(sessionsDir)) return [];
   const stack = [sessionsDir];
   const usageByFile = [];
   const seen = /* @__PURE__ */ new Set();
@@ -2734,7 +3083,7 @@ async function collectCodexUsage() {
   const models = [];
   const modelsCachePath = join8(codexDir, "models_cache.json");
   let currentModel = "";
-  if (existsSync6(modelsCachePath)) {
+  if (existsSync7(modelsCachePath)) {
     try {
       const cache = JSON.parse(readFileSync5(modelsCachePath, "utf8"));
       for (const m of cache.models || []) {
@@ -2748,7 +3097,7 @@ async function collectCodexUsage() {
     }
   }
   const configPath = join8(codexDir, "config.toml");
-  if (existsSync6(configPath)) {
+  if (existsSync7(configPath)) {
     try {
       const configContent = readFileSync5(configPath, "utf8");
       const modelMatch = configContent.match(/^model\s*=\s*"([^"]+)"/m);
@@ -3011,7 +3360,7 @@ function aggregateGeminiSessionUsageFromJson(content) {
 }
 function collectGeminiSessionUsages() {
   const geminiTmp = join8(homedir2(), ".gemini", "tmp");
-  if (!existsSync6(geminiTmp)) return [];
+  if (!existsSync7(geminiTmp)) return [];
   const usages = [];
   let entries = [];
   try {
@@ -3022,7 +3371,7 @@ function collectGeminiSessionUsages() {
   for (const profile of entries) {
     if (!profile.isDirectory()) continue;
     const chatsDir = join8(geminiTmp, profile.name, "chats");
-    if (!existsSync6(chatsDir)) continue;
+    if (!existsSync7(chatsDir)) continue;
     let sessions = [];
     try {
       sessions = readdirSync2(chatsDir).filter((name) => name.startsWith("session-") && (name.endsWith(".json") || name.endsWith(".jsonl")));
@@ -3052,7 +3401,7 @@ async function collectGeminiUsage() {
   }
   let account = null;
   const accountsPath = join8(homedir2(), ".gemini", "google_accounts.json");
-  if (existsSync6(accountsPath)) {
+  if (existsSync7(accountsPath)) {
     try {
       const data = JSON.parse(readFileSync5(accountsPath, "utf8"));
       if (typeof data.active === "string" && data.active.includes("@")) {
@@ -3070,7 +3419,7 @@ async function collectGeminiUsage() {
     const { stdout: binPath } = await execFileAsync("which", ["gemini"], { encoding: "utf8", timeout: 3e3 });
     const realBin = realpathSync(binPath.trim());
     const modelsPath = join8(dirname(dirname(realBin)), "node_modules", "@google", "gemini-cli-core", "dist", "src", "config", "models.js");
-    if (existsSync6(modelsPath)) {
+    if (existsSync7(modelsPath)) {
       const content = readFileSync5(modelsPath, "utf8");
       const regex = /export const ([A-Z0-9_]+)\s*=\s*'(gemini-[^']+)';/g;
       const seen = /* @__PURE__ */ new Set();
@@ -3090,7 +3439,7 @@ async function collectGeminiUsage() {
   }
   let currentModel = "";
   const settingsPath = join8(homedir2(), ".gemini", "settings.json");
-  if (existsSync6(settingsPath)) {
+  if (existsSync7(settingsPath)) {
     try {
       const settings = JSON.parse(readFileSync5(settingsPath, "utf8"));
       if (typeof settings.model === "string" && settings.model.trim()) {
@@ -3270,12 +3619,7 @@ async function replanIssueCommand(input, deps) {
   if (issue.state === "Running" || issue.state === "Reviewing" || issue.state === "Queued") {
     throw new Error(`Cannot replan issue in ${issue.state} state \u2014 wait for it to finish or cancel it first.`);
   }
-  if (issue.plan) {
-    if (!Array.isArray(issue.planHistory)) issue.planHistory = [];
-    issue.planHistory.push(issue.plan);
-    issue.plan = void 0;
-    markIssuePlanDirty(issue.id);
-  }
+  issue.plan = void 0;
   issue.planVersion = (issue.planVersion ?? 0) + 1;
   issue.executeAttempt = 0;
   issue.reviewAttempt = 0;
@@ -3289,286 +3633,6 @@ async function replanIssueCommand(input, deps) {
   deps.eventStore.addEvent(issue.id, "manual", `Replan requested for ${issue.identifier} \u2014 now at plan v${issue.planVersion}.`);
 }
 
-// src/commands/request-rework.command.ts
-async function requestReworkCommand(input, deps) {
-  const { issue, reviewerFeedback, note } = input;
-  if (issue.state !== "Reviewing" && issue.state !== "PendingDecision") {
-    throw new Error(
-      `requestReworkCommand requires Reviewing or PendingDecision state, got ${issue.state}.`
-    );
-  }
-  issue.lastError = reviewerFeedback;
-  issue.lastFailedPhase = "review";
-  issue.attempts += 1;
-  if (issue.state === "Reviewing") {
-    await transitionIssueCommand(
-      { issue, target: "PendingDecision", note: `Reviewer completed for ${issue.identifier}.` },
-      deps
-    );
-  }
-  await transitionIssueCommand(
-    { issue, target: "Queued", note: note ?? `Reviewer requested rework for ${issue.identifier}.` },
-    deps
-  );
-  deps.eventStore.addEvent(
-    issue.id,
-    "runner",
-    `Issue ${issue.identifier} sent back for rework by reviewer.`
-  );
-}
-
-// src/commands/merge-workspace.command.ts
-import { existsSync as existsSync7 } from "fs";
-import { execSync } from "child_process";
-
-// src/domains/validation.ts
-import { execFile as execFile2 } from "child_process";
-async function runValidationGate(issue, config) {
-  if (!config.testCommand) return null;
-  const cwd = issue.worktreePath ?? issue.workspacePath;
-  if (!cwd) {
-    logger.warn({ issueId: issue.id }, "[Validation] No workspace path \u2014 skipping gate");
-    return null;
-  }
-  const command = config.testCommand;
-  logger.info({ issueId: issue.id, command, cwd }, "[Validation] Running validation gate");
-  return new Promise((resolve3) => {
-    const child = execFile2("sh", ["-c", command], {
-      cwd,
-      encoding: "utf8",
-      timeout: 3e5,
-      maxBuffer: 2 * 1024 * 1024
-    }, (err, stdout, stderr) => {
-      const combined = (stdout || "") + (stderr || "");
-      if (!err) {
-        logger.info({ issueId: issue.id }, "[Validation] Gate passed");
-        resolve3({
-          passed: true,
-          output: combined.slice(-2048),
-          command,
-          ranAt: (/* @__PURE__ */ new Date()).toISOString()
-        });
-        return;
-      }
-      logger.warn({ issueId: issue.id, exitCode: err.code }, "[Validation] Gate failed");
-      resolve3({
-        passed: false,
-        output: combined.slice(-2048) || String(err).slice(0, 2048),
-        command,
-        ranAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    });
-  });
-}
-
-// src/commands/merge-workspace.command.ts
-async function mergeWorkspaceCommand(input, deps) {
-  const { issue, state } = input;
-  if (!["Approved", "Reviewing", "PendingDecision"].includes(issue.state)) {
-    throw new Error(`Issue ${issue.identifier} is in state ${issue.state}. Merge is only allowed in Reviewing, PendingDecision, or Approved state.`);
-  }
-  ensureGitRepoReadyForWorktrees(TARGET_ROOT, "merge issues");
-  if (issue.state === "Reviewing" || issue.state === "PendingDecision") {
-    await transitionIssueCommand(
-      { issue, target: "Approved", note: "Approved and merged by user." },
-      deps
-    );
-  }
-  const wp = issue.worktreePath ?? issue.workspacePath;
-  if (!wp || !existsSync7(wp)) {
-    throw new Error(`No mergeable workspace found for ${issue.identifier}. This issue likely ran before git was initialized for the project. Re-run the issue after git setup.`);
-  }
-  if (issue.branchName && issue.baseBranch) {
-    try {
-      const stat = execSync(
-        `git diff --stat "${issue.baseBranch}"..."${issue.branchName}"`,
-        { encoding: "utf8", cwd: TARGET_ROOT, stdio: "pipe", maxBuffer: 512e3, timeout: 1e4 }
-      );
-      parseDiffStats(issue, stat);
-      logger.info({ issueId: issue.id, linesAdded: issue.linesAdded, linesRemoved: issue.linesRemoved, filesChanged: issue.filesChanged }, "[Merge] Diff stats computed");
-    } catch (err) {
-      logger.warn({ err: String(err), issueId: issue.id }, "[Merge] Failed to compute diff stats");
-    }
-  }
-  try {
-    const indexStatus = execSync("git diff --cached --name-only", { cwd: TARGET_ROOT, encoding: "utf8", stdio: "pipe" }).trim();
-    const wtStatus = execSync("git diff --name-only", { cwd: TARGET_ROOT, encoding: "utf8", stdio: "pipe" }).trim();
-    if (indexStatus && !wtStatus) {
-      execSync("git reset --hard HEAD", { cwd: TARGET_ROOT, stdio: "pipe" });
-      logger.info({ issueId: issue.id }, "[Command] Cleared residual squash from index before merge");
-    }
-  } catch {
-  }
-  const validation = await runValidationGate(issue, state.config);
-  if (validation) {
-    issue.validationResult = validation;
-    if (!validation.passed) {
-      throw new Error(`Validation gate failed (${validation.command}): ${validation.output.slice(0, 500)}`);
-    }
-  }
-  const result = mergeWorkspace(issue);
-  issue.mergeResult = {
-    copied: result.copied.length,
-    deleted: result.deleted.length,
-    skipped: result.skipped.length,
-    conflicts: result.conflicts.length,
-    conflictFiles: result.conflicts.length > 0 ? result.conflicts : void 0
-  };
-  if (result.conflicts.length > 0) {
-    deps.eventStore.addEvent(issue.id, "error", `Merge conflicts: ${result.conflicts.join(", ")}`);
-    await deps.persistencePort.persistState(state);
-    return result;
-  }
-  if (!issue.mergedReason) issue.mergedReason = "Merged by user via PreviewModal.";
-  await transitionIssueCommand(
-    { issue, target: "Merged", note: `Workspace merged: ${result.copied.length} file(s) copied, ${result.deleted.length} deleted.` },
-    deps
-  );
-  if (issue.workspacePath) {
-    try {
-      await cleanWorkspace(issue.id, issue, state);
-      issue.workspacePath = void 0;
-      issue.worktreePath = void 0;
-    } catch {
-    }
-  }
-  await deps.persistencePort.persistState(state);
-  return result;
-}
-
-// src/commands/push-workspace.command.ts
-import { execFileSync, execSync as execSync2 } from "child_process";
-function isGhAvailable() {
-  try {
-    execFileSync("gh", ["--version"], { stdio: "pipe", timeout: 5e3 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getCompareUrl(branchName, baseBranch) {
-  try {
-    const remote = execSync2("git remote get-url origin", { cwd: TARGET_ROOT, encoding: "utf8", stdio: "pipe" }).trim();
-    const cleanRemote = remote.replace(/\.git$/, "");
-    return `${cleanRemote}/compare/${baseBranch}...${branchName}`;
-  } catch {
-    return `(branch pushed: ${branchName})`;
-  }
-}
-function findExistingPr(branchName) {
-  try {
-    const result = execFileSync(
-      "gh",
-      ["pr", "view", branchName, "--json", "url,state", "--jq", 'select(.state == "OPEN") | .url'],
-      { cwd: TARGET_ROOT, encoding: "utf8", stdio: "pipe", timeout: 15e3 }
-    ).trim();
-    return result || null;
-  } catch {
-    return null;
-  }
-}
-function createPr(branchName, baseBranch, title, body) {
-  return execFileSync(
-    "gh",
-    ["pr", "create", "--head", branchName, "--base", baseBranch, "--title", title, "--body", body],
-    { cwd: TARGET_ROOT, encoding: "utf8", stdio: "pipe", timeout: 3e4 }
-  ).trim();
-}
-async function pushWorkspaceCommand(input, deps) {
-  const { issue, state } = input;
-  if (!["Approved", "Reviewing", "PendingDecision"].includes(issue.state)) {
-    throw new Error(`Issue ${issue.identifier} is in state ${issue.state}. Push is only allowed in Reviewing, PendingDecision, or Approved state.`);
-  }
-  ensureGitRepoReadyForWorktrees(TARGET_ROOT, "push issue branches");
-  assertIssueHasGitWorktree(issue, "push");
-  if (issue.state === "Reviewing" || issue.state === "PendingDecision") {
-    await transitionIssueCommand(
-      { issue, target: "Approved", note: "Approved and pushed by user." },
-      deps
-    );
-  }
-  ensureWorktreeCommitted(issue);
-  const validation = await runValidationGate(issue, state.config);
-  if (validation) {
-    issue.validationResult = validation;
-    if (!validation.passed) {
-      throw new Error(`Validation gate failed (${validation.command}): ${validation.output.slice(0, 500)}`);
-    }
-  }
-  computeDiffStats(issue);
-  const planSummary = issue.plan?.summary ?? issue.title;
-  let diffStat = "";
-  try {
-    diffStat = execSync2(
-      `git diff --stat "${issue.baseBranch}"..."${issue.branchName}"`,
-      { cwd: TARGET_ROOT, encoding: "utf8", maxBuffer: 512e3, timeout: 1e4, stdio: "pipe" }
-    ).trim();
-  } catch {
-  }
-  const body = `## Summary
-${planSummary}
-
-## Diff Stats
-\`\`\`
-${diffStat || "No diff stats available"}
-\`\`\`
-
-*Automated by fifony*`;
-  execSync2(`git push -u origin "${issue.branchName}"`, { cwd: TARGET_ROOT, stdio: "pipe" });
-  const prBase = state.config.prBaseBranch || issue.baseBranch;
-  const ghAvailable = isGhAvailable();
-  let prUrl;
-  if (!ghAvailable) {
-    prUrl = getCompareUrl(issue.branchName, prBase);
-    logger.info({ issueId: issue.id, prUrl }, "[Push] gh CLI not available \u2014 using compare URL");
-  } else {
-    const existingUrl = findExistingPr(issue.branchName);
-    if (existingUrl) {
-      prUrl = existingUrl;
-      logger.info({ issueId: issue.id, prUrl }, "[Push] Existing open PR found");
-    } else {
-      try {
-        prUrl = createPr(issue.branchName, prBase, issue.title, body);
-        logger.info({ issueId: issue.id, prUrl }, "[Push] PR created");
-      } catch (err) {
-        const ghError = (err.stderr || err.stdout || String(err)).toString().slice(0, 500);
-        logger.error({ issueId: issue.id, ghError }, "[Push] gh pr create failed");
-        prUrl = getCompareUrl(issue.branchName, prBase);
-        deps.eventStore.addEvent(issue.id, "error", `gh pr create failed: ${ghError}. Branch was pushed \u2014 use the compare URL to create the PR manually.`);
-      }
-    }
-  }
-  issue.prUrl = prUrl;
-  if (!issue.mergedReason) issue.mergedReason = "Pushed to origin and PR created.";
-  await transitionIssueCommand(
-    { issue, target: "Merged", note: `Branch ${issue.branchName} pushed. PR: ${prUrl}` },
-    deps
-  );
-  deps.eventStore.addEvent(issue.id, "merge", `PR created: ${prUrl}`);
-  await deps.persistencePort.persistState(state);
-  return { prUrl, ghAvailable };
-}
-
-// src/commands/retry-execution.command.ts
-async function retryExecutionCommand(input, deps) {
-  const { issue, note } = input;
-  if (issue.state !== "Blocked") {
-    throw new Error(
-      `retryExecutionCommand requires Blocked state, got ${issue.state}. Use replanIssueCommand for re-planning or the generic /retry endpoint for other states.`
-    );
-  }
-  issue.attempts += 1;
-  await transitionIssueCommand(
-    { issue, target: "Queued", note: note ?? `Retry execution for ${issue.identifier} (attempt ${issue.attempts}).` },
-    deps
-  );
-  deps.eventStore.addEvent(
-    issue.id,
-    "manual",
-    `Execution retry requested for ${issue.identifier} \u2014 re-queued from Blocked.`
-  );
-}
-
 // src/routes/state.ts
 function getStateQuery(state, showAll = false) {
   let issues = state.issues;
@@ -3606,168 +3670,40 @@ function registerStateRoutes(app, state) {
   app.get(
     "/api/status",
     async (c) => c.json({
-      status: "ok",
-      updatedAt: state.updatedAt,
-      config: state.config,
-      trackerKind: state.trackerKind
-    })
-  );
-  app.get("/api/providers", async (c) => {
-    const providers = detectAvailableProviders();
-    return c.json({ providers });
-  });
-  app.get("/api/parallelism", async (c) => {
-    return c.json(analyzeParallelizability(state.issues));
-  });
-  app.get("/api/providers/:slug/usage", async (c) => {
-    const provider = c.req.param("slug") || "";
-    try {
-      const usage = await collectProviderUsage(provider);
-      return c.json({
-        providers: usage ? [usage] : [],
-        collectedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    } catch (error) {
-      logger.error({ err: error, provider }, "Failed to collect provider usage");
-      return c.json({ providers: [] }, 500);
-    }
-  });
-  app.get("/api/providers/usage", async (c) => {
-    try {
-      const usage = await collectProvidersUsage();
-      return c.json(usage);
-    } catch (error) {
-      logger.error({ err: error }, "Failed to collect providers usage");
-      return c.json({ providers: [] }, 500);
-    }
-  });
-  app.post("/api/issues/create", async (c) => {
-    try {
-      const payload = await c.req.json();
-      logger.info({ title: (payload.title ?? "").toString().slice(0, 80) }, "[API] POST /api/issues/create");
-      const container = getContainer();
-      const result = await createIssueCommand({ payload, state }, container);
-      return c.json({ ok: true, issue: result.issue }, 201);
-    } catch (error) {
-      return c.json({ ok: false, error: error instanceof Error ? error.message : String(error) }, 400);
-    }
-  });
-  app.post("/api/issues/:id/state", async (c) => {
-    const issueId = parseIssue(c);
-    if (!issueId) {
-      return c.json({ ok: false, error: "Issue id is required." }, 400);
-    }
-    const issue = findIssue(state, issueId);
-    if (!issue) {
-      return c.json({ ok: false, error: "Issue not found" }, 404);
-    }
-    try {
-      const payload = await c.req.json();
-      logger.info({ issueId, identifier: issue.identifier, targetState: payload.state }, "[API] POST /api/issues/:id/state");
-      const nextState = parseIssueState(payload.state);
-      if (!nextState) {
-        throw new Error(`Unsupported state: ${String(payload.state)}`);
-      }
-      if (nextState === "Running" && issue.state !== "Queued") {
-        return c.json({ ok: false, error: "Manual transition to Running is only supported from Queued." }, 400);
-      }
-      const container = getContainer();
-      await transitionIssueCommand({ issue, target: nextState, note: `Manual state update: ${nextState}` }, container);
-      if (nextState === "Running") {
-        await enqueue(issue, "execute");
-      }
-      if (nextState === "Cancelled" && payload.reason) {
-        issue.lastError = toStringValue(payload.reason);
-      }
-      await persistState(state);
-      return c.json({ ok: true, issue });
-    } catch (error) {
-      return c.json({ ok: false, error: error instanceof Error ? error.message : String(error) }, 400);
-    }
-  });
-  app.post("/api/issues/:id/retry", async (c) => {
-    logger.info({ issueId: parseIssue(c) }, "[API] POST /api/issues/:id/retry");
-    let feedback;
-    try {
-      const body = await c.req.json();
-      if (body?.feedback) feedback = toStringValue(body.feedback);
-    } catch {
-    }
-    return mutateIssueState(state, c, async (issue) => {
-      const container = getContainer();
-      if (TERMINAL_STATES.has(issue.state)) {
-        await transitionIssueCommand(
-          { issue, target: "Planning", note: "Manual retry \u2014 reopened." },
-          container
-        );
-        if (issue.plan?.steps?.length) {
-          await transitionIssueCommand(
-            { issue, target: "PendingApproval", note: "Existing plan found." },
-            container
-          );
-          await transitionIssueCommand(
-            { issue, target: "Queued", note: "Auto-queued after plan approval." },
-            container
-          );
-        }
-      } else if (issue.state === "Blocked") {
-        if (issue.lastFailedPhase === "review") {
-          issue.lastError = void 0;
-          issue.lastFailedPhase = void 0;
-          await transitionIssueCommand(
-            { issue, target: "Reviewing", note: "Retrying review (execution was already successful)." },
-            container
-          );
-        } else {
-          await retryExecutionCommand(
-            { issue, note: "Manual retry from Blocked." },
-            container
-          );
-        }
-      } else if (issue.state === "Approved") {
-        issue.attempts += 1;
-        await transitionIssueCommand(
-          { issue, target: "Planning", note: "Requeued for rework after merge conflicts." },
-          container
-        );
-        if (issue.plan?.steps?.length) {
-          await transitionIssueCommand(
-            { issue, target: "PendingApproval", note: "Existing plan found." },
-            container
-          );
-          await transitionIssueCommand(
-            { issue, target: "Queued", note: "Auto-queued for rework." },
-            container
-          );
-        }
-      } else if (issue.state === "Reviewing" || issue.state === "PendingDecision") {
-        await requestReworkCommand(
-          {
-            issue,
-            reviewerFeedback: feedback || issue.lastError || "Manual rework request.",
-            note: feedback ? `Rework requested for ${issue.identifier}: ${feedback.slice(0, 200)}` : `Manual rework requested for ${issue.identifier}.`
-          },
-          container
-        );
-      } else if (issue.state === "PendingApproval") {
-        await transitionIssueCommand(
-          { issue, target: "Queued", note: "Manual retry \u2014 queued for execution." },
-          container
-        );
-      } else {
-        issue.lastError = void 0;
-        issue.nextRetryAt = void 0;
-        issue.updatedAt = now();
-      }
-      addEvent(state, issue.id, "manual", `Manual retry requested for ${issue.id}.`);
-    });
+      status: "ok",
+      updatedAt: state.updatedAt,
+      config: state.config,
+      trackerKind: state.trackerKind
+    })
+  );
+  app.get("/api/providers", async (c) => {
+    const providers = detectAvailableProviders();
+    return c.json({ providers });
   });
-  app.post("/api/issues/:id/cancel", async (c) => {
-    logger.info({ issueId: parseIssue(c) }, "[API] POST /api/issues/:id/cancel");
-    return mutateIssueState(state, c, async (issue) => {
-      const container = getContainer();
-      await cancelIssueCommand({ issue }, container);
-    });
+  app.get("/api/parallelism", async (c) => {
+    return c.json(analyzeParallelizability(state.issues));
+  });
+  app.get("/api/providers/:slug/usage", async (c) => {
+    const provider = c.req.param("slug") || "";
+    try {
+      const usage = await collectProviderUsage(provider);
+      return c.json({
+        providers: usage ? [usage] : [],
+        collectedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } catch (error) {
+      logger.error({ err: error, provider }, "Failed to collect provider usage");
+      return c.json({ providers: [] }, 500);
+    }
+  });
+  app.get("/api/providers/usage", async (c) => {
+    try {
+      const usage = await collectProvidersUsage();
+      return c.json(usage);
+    } catch (error) {
+      logger.error({ err: error }, "Failed to collect providers usage");
+      return c.json({ providers: [] }, 500);
+    }
   });
   app.post("/api/issues/:id/approve", async (c) => {
     logger.info({ issueId: parseIssue(c) }, "[API] POST /api/issues/:id/approve");
@@ -3802,7 +3738,7 @@ function registerStateRoutes(app, state) {
         const result2 = await pushWorkspaceCommand({ issue, state }, container);
         return c.json({ ok: true, prUrl: result2.prUrl, ghAvailable: result2.ghAvailable });
       }
-      const result = await mergeWorkspaceCommand({ issue, state }, container);
+      const result = await mergeWorkspaceCommand({ issue, state, squashAlreadyApplied: issue.testApplied ?? false }, container);
       return c.json({ ok: true, ...result });
     } catch (error) {
       const issueId = parseIssue(c);
@@ -3817,7 +3753,7 @@ function registerStateRoutes(app, state) {
       if (!issueId) return c.json({ ok: false, error: "Issue id is required." }, 400);
       const issue = findIssue(state, issueId);
       if (!issue) return c.json({ ok: false, error: "Issue not found." }, 404);
-      const { dryMerge } = await import("./workspace-U43FRPEB.js");
+      const { dryMerge } = await import("./workspace-E26GGQES.js");
       const result = dryMerge(issue);
       return c.json({ ok: true, ...result });
     } catch (error) {
@@ -3832,7 +3768,7 @@ function registerStateRoutes(app, state) {
       if (!issueId) return c.json({ ok: false, error: "Issue id is required." }, 400);
       const issue = findIssue(state, issueId);
       if (!issue) return c.json({ ok: false, error: "Issue not found." }, 404);
-      const { rebaseWorktree } = await import("./workspace-U43FRPEB.js");
+      const { rebaseWorktree } = await import("./workspace-E26GGQES.js");
       const result = rebaseWorktree(issue);
       if (result.success) {
         addEvent(state, issue.id, "info", `Branch ${issue.branchName} rebased onto ${issue.baseBranch}.`);
@@ -3862,6 +3798,8 @@ function registerStateRoutes(app, state) {
         const msg = err.stderr || err.stdout || String(err);
         throw new Error(`git merge --squash failed: ${msg}`);
       }
+      issue.testApplied = true;
+      markIssueDirty(issue.id);
       addEvent(state, issue.id, "manual", `Test squash applied to workspace: git merge --squash ${issue.branchName}`);
     });
   });
@@ -3875,6 +3813,8 @@ function registerStateRoutes(app, state) {
         const msg = err.stderr || err.stdout || String(err);
         throw new Error(`git reset/clean failed: ${msg}`);
       }
+      issue.testApplied = false;
+      markIssueDirty(issue.id);
       addEvent(state, issue.id, "manual", `Test reverted: git reset --hard HEAD && git clean -fd`);
     });
   });
@@ -3964,7 +3904,7 @@ function registerStateRoutes(app, state) {
     const issue = findIssue(state, issueId);
     if (!issue) return c.json({ ok: false, error: "Issue not found." }, 404);
     try {
-      const { getIssueTransitionHistory } = await import("./issue-state-machine-JCGSR5QP.js");
+      const { getIssueTransitionHistory } = await import("./issue-state-machine-A6NMZG5W.js");
       const limit = parseInt(c.req.query("limit") ?? "50", 10);
       const offset = parseInt(c.req.query("offset") ?? "0", 10);
       const transitions = await getIssueTransitionHistory(issue.id, { limit, offset });
@@ -3975,7 +3915,7 @@ function registerStateRoutes(app, state) {
   });
   app.get("/api/state-machine/transitions", async (c) => {
     try {
-      const { getStateMachineTransitions } = await import("./issue-state-machine-JCGSR5QP.js");
+      const { getStateMachineTransitions } = await import("./issue-state-machine-A6NMZG5W.js");
       return c.json({ ok: true, transitions: getStateMachineTransitions() });
     } catch (error) {
       return c.json({ ok: false, error: error instanceof Error ? error.message : String(error) }, 500);
@@ -3983,7 +3923,7 @@ function registerStateRoutes(app, state) {
   });
   app.get("/api/state-machine/visualize", async (c) => {
     try {
-      const { visualizeStateMachine } = await import("./issue-state-machine-JCGSR5QP.js");
+      const { visualizeStateMachine } = await import("./issue-state-machine-A6NMZG5W.js");
       const dot = visualizeStateMachine();
       if (!dot) return c.json({ ok: false, error: "Visualization not available." }, 404);
       return c.json({ ok: true, dot });
@@ -4956,13 +4896,18 @@ function generatePlanInBackground(issue, config, _workflowDefinition, callbacks,
   addEvent2(issue.id, "info", `${fast ? "Fast plan" : "Plan"} generation starting for ${issue.identifier} (provider detection in progress).`);
   generatePlan(issue.title, issue.description, config, null, { fast }).then(async ({ plan, usage }) => {
     issue.plan = plan;
-    markIssuePlanDirty(issue.id);
+    issue.planVersion = Math.max(issue.planVersion ?? 0, 1);
     issue.planningStatus = "idle";
     issue.planningStartedAt = void 0;
     issue.planningError = void 0;
     issue.updatedAt = now();
     applyUsage(issue, usage);
     applySuggestions(issue, plan);
+    try {
+      const { savePlanForIssue: savePlanForIssue2 } = await import("./store-O3UNJU26.js");
+      await savePlanForIssue2(issue.id, plan, issue.planVersion);
+    } catch {
+    }
     addEvent2(issue.id, "progress", `${fast ? "Fast plan" : "Plan"} generated for ${issue.identifier}: ${plan.steps.length} steps, complexity: ${plan.estimatedComplexity}.`);
     if (usage.totalTokens > 0) {
       addEvent2(issue.id, "info", `Plan tokens (${issue.identifier}): ${usage.totalTokens.toLocaleString()} (in: ${usage.inputTokens.toLocaleString()}, out: ${usage.outputTokens.toLocaleString()}) [${usage.model}]`);
@@ -4988,13 +4933,18 @@ function refinePlanInBackground(issue, feedback, config, _workflowDefinition, ca
   addEvent2(issue.id, "info", `Plan refinement starting for ${issue.identifier}: "${feedbackSnippet}".`);
   refinePlan(issue, feedback, config, null).then(async ({ plan, usage }) => {
     issue.plan = plan;
-    markIssuePlanDirty(issue.id);
+    issue.planVersion = Math.max(issue.planVersion ?? 0, 1);
     issue.planningStatus = "idle";
     issue.planningStartedAt = void 0;
     issue.planningError = void 0;
     issue.updatedAt = now();
     applyUsage(issue, usage);
     applySuggestions(issue, plan);
+    try {
+      const { savePlanForIssue: savePlanForIssue2 } = await import("./store-O3UNJU26.js");
+      await savePlanForIssue2(issue.id, plan, issue.planVersion);
+    } catch {
+    }
     const feedbackPreview = feedback.length > 80 ? `${feedback.slice(0, 77)}...` : feedback;
     addEvent2(issue.id, "progress", `Plan refined for ${issue.identifier}: "${feedbackPreview}" \u2192 ${plan.steps.length} steps, complexity: ${plan.estimatedComplexity}.`);
     if (usage.totalTokens > 0) {
@@ -5018,10 +4968,6 @@ import { existsSync as existsSync9, mkdtempSync as mkdtempSync3, readFileSync as
 import { spawn as spawn2 } from "child_process";
 import { tmpdir as tmpdir3 } from "os";
 import { join as join13 } from "path";
-function getProviderCommand(provider, config) {
-  const explicit = provider === config.agentProvider ? config.agentCommand || "" : "";
-  return resolveAgentCommand(provider, explicit, "", "");
-}
 async function buildPrompt2(field, title, description, issueType, images) {
   const context2 = {
     title: title || "(empty)",
@@ -5072,8 +5018,9 @@ function parseCandidate(raw, expectedField) {
     if (value && !isPlaceholder && (!field || field === expectedField)) {
       return value;
     }
-    if (typeof parsed.result === "string") {
-      const nested = parsed.result.trim();
+    const nestedSource = typeof parsed.result === "string" ? parsed.result : typeof parsed.response === "string" ? parsed.response : void 0;
+    if (nestedSource) {
+      const nested = nestedSource.trim();
       if (nested) {
         const nestedClean = nested.replace(/^```(?:json)?\s*|\s*```$/g, "").trim();
         for (const nestedCandidate of extractJsonObjects(nestedClean)) {
@@ -5169,65 +5116,51 @@ async function enhanceIssueField(payload, config, _workflowDefinition) {
   const title = typeof payload.title === "string" ? payload.title.trim() : "";
   const description = typeof payload.description === "string" ? payload.description.trim() : "";
   const issueType = typeof payload.issueType === "string" ? payload.issueType.trim() : void 0;
-  const requestedProvider = normalizeAgentProvider(
-    typeof payload.preferredProvider === "string" ? payload.preferredProvider : payload.provider ?? config.agentProvider
-  );
+  const images = Array.isArray(payload.images) ? payload.images.filter((p) => typeof p === "string") : void 0;
+  const { provider: selectedProvider, model: planModel } = await resolvePlanStageConfig(config);
   const providers = detectAvailableProviders();
-  const availableSet = new Set(providers.filter((entry) => entry.available).map((entry) => entry.name));
-  const orderedProviders = [];
-  const addProvider = (candidate) => {
-    if (availableSet.has(candidate) && !orderedProviders.includes(candidate)) {
-      orderedProviders.push(candidate);
-    }
-  };
-  addProvider(requestedProvider);
-  for (const entry of providers) {
-    if (entry.available) addProvider(entry.name);
-  }
-  if (!orderedProviders.length) {
+  const isAvailable = providers.some((p) => p.name === selectedProvider && p.available);
+  if (!isAvailable) {
     const known = providers.map((entry) => `${entry.name}:${entry.available ? "available" : "missing"}`).join(", ");
-    throw new Error(`No AI provider available (codex/claude). Detected: ${known}`);
+    throw new Error(`Configured plan provider "${selectedProvider}" is not available. Detected: ${known}`);
   }
-  const images = Array.isArray(payload.images) ? payload.images.filter((p) => typeof p === "string") : void 0;
-  const prompt = await buildPrompt2(field, title, description, issueType, images);
-  const errors = [];
-  const enhanceSchema = {
+  const adapter = ADAPTERS[selectedProvider];
+  if (!adapter) {
+    throw new Error(`No adapter configured for plan provider "${selectedProvider}".`);
+  }
+  const ENHANCE_JSON_SCHEMA = JSON.stringify({
     type: "object",
     properties: {
-      field: { type: "string" },
+      field: { type: "string", enum: ["title", "description"] },
       value: { type: "string" }
     },
     required: ["field", "value"],
     additionalProperties: false
-  };
-  for (const selectedProvider of orderedProviders) {
-    const command = getProviderCommand(selectedProvider, config);
-    if (!command) {
-      errors.push(`Provider "${selectedProvider}" has no command.`);
-      continue;
-    }
-    try {
-      const output = await runProviderCommand(
-        command,
-        selectedProvider,
-        prompt,
-        title,
-        description,
-        field,
-        config.commandTimeoutMs,
-        images
-      );
-      logger.info({ provider: selectedProvider, field, rawOutput: output.slice(0, 2e3) }, "Enhance raw output");
-      const value = parseEnhancerOutput(output, field);
-      logger.info({ provider: selectedProvider, field, parsedValue: value }, "Enhance parsed value");
-      return { field, value, provider: selectedProvider };
-    } catch (error) {
-      errors.push(
-        `Provider "${selectedProvider}" failed: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
+  });
+  const command = adapter.buildCommand({
+    model: planModel,
+    imagePaths: images,
+    jsonSchema: selectedProvider === "claude" ? ENHANCE_JSON_SCHEMA : void 0,
+    noToolAccess: selectedProvider === "claude"
+  });
+  if (!command) {
+    throw new Error(`Adapter returned empty command for provider "${selectedProvider}".`);
   }
-  throw new Error(`Could not enhance issue field. ${errors.join(" | ")}`);
+  const prompt = await buildPrompt2(field, title, description, issueType, images);
+  const output = await runProviderCommand(
+    command,
+    selectedProvider,
+    prompt,
+    title,
+    description,
+    field,
+    config.commandTimeoutMs,
+    images
+  );
+  logger.info({ provider: selectedProvider, model: planModel, field, rawOutput: output.slice(0, 2e3) }, "Enhance raw output");
+  const value = parseEnhancerOutput(output, field);
+  logger.info({ provider: selectedProvider, field, parsedValue: value.slice(0, 500) }, "Enhance parsed value");
+  return { field, value, provider: selectedProvider };
 }
 
 // src/routes/plan.ts
@@ -5540,17 +5473,6 @@ function registerScanningRoutes(app, state) {
       return c.json({ ok: false, error: "Failed to scan project." }, 500);
     }
   });
-  app.post("/api/scan/analyze", async (c) => {
-    try {
-      const payload = await c.req.json();
-      const provider = typeof payload.provider === "string" ? payload.provider : state.config.agentProvider;
-      const result = await analyzeProjectWithCli(provider, TARGET_ROOT);
-      return c.json(result);
-    } catch (error) {
-      logger.error({ err: error }, "Failed to analyze project with CLI");
-      return c.json({ ok: false, error: "Failed to analyze project." }, 500);
-    }
-  });
   app.post("/api/boot/skip-scan", async (c) => {
     broadcastToWebSocketClients({ type: "boot:scan:skipped" });
     return c.json({ ok: true, message: "Scan skipped." });
@@ -6252,7 +6174,7 @@ async function startApiServer(state, port, options) {
     docs: { enabled: true, title: "Fifony API", version: "1.0.0", description: "Local orchestration API for Fifony" },
     cors: { enabled: true, origin: "*" },
     security: { enabled: false },
-    logging: { enabled: true, excludePaths: ["/health", "/status", "/**/*.js", "/**/*.css", "/**/*.svg"] },
+    logging: { enabled: !QUIET_MODE, excludePaths: ["/health", "/status", "/**/*.js", "/**/*.css", "/**/*.svg"] },
     compression: { enabled: true, threshold: 1024 },
     health: { enabled: true },
     resources: {
@@ -6290,6 +6212,7 @@ async function startApiServer(state, port, options) {
 }
 
 // src/persistence/store.ts
+import { randomUUID as randomUUID3 } from "crypto";
 var loadedS3dbModule = null;
 var stateDb = null;
 var runtimeStateResource = null;
@@ -6323,6 +6246,58 @@ function getAgentSessionResource() {
 function getAgentPipelineResource() {
   return agentPipelineResource;
 }
+async function savePlanForIssue(issueId, plan, version) {
+  if (!issuePlanResource) throw new Error("Issue plan resource not initialized");
+  try {
+    const existing = await issuePlanResource.list({
+      partition: "byIssueCurrent",
+      partitionValues: { issueId, current: true }
+    });
+    if (Array.isArray(existing)) {
+      for (const old of existing) {
+        if (old?.id) await issuePlanResource.patch(old.id, { current: false });
+      }
+    }
+  } catch {
+  }
+  const planId = `plan-${randomUUID3()}`;
+  await issuePlanResource.insert({
+    id: planId,
+    issueId,
+    version,
+    current: true,
+    plan
+  });
+  return planId;
+}
+async function getCurrentPlanForIssue(issueId) {
+  if (!issuePlanResource) return null;
+  try {
+    const results = await issuePlanResource.list({
+      partition: "byIssueCurrent",
+      partitionValues: { issueId, current: true },
+      limit: 1
+    });
+    if (Array.isArray(results) && results.length > 0 && results[0]?.plan) {
+      return { id: results[0].id, plan: results[0].plan, version: results[0].version ?? 1 };
+    }
+  } catch {
+  }
+  return null;
+}
+async function getPlansForIssue(issueId) {
+  if (!issuePlanResource) return [];
+  try {
+    const results = await issuePlanResource.list({
+      partition: "byIssue",
+      partitionValues: { issueId }
+    });
+    if (!Array.isArray(results)) return [];
+    return results.filter((r) => r?.id && r?.plan).map((r) => ({ id: r.id, plan: r.plan, version: r.version ?? 1, current: !!r.current })).sort((a, b) => a.version - b.version);
+  } catch {
+    return [];
+  }
+}
 function setActiveApiPlugin(plugin) {
   activeApiPlugin = plugin;
 }
@@ -6486,14 +6461,15 @@ async function recoverStateFromIssueResource() {
     const issues = records.filter((r) => r?.id && r?.identifier && r?.state).map((r) => r);
     if (issues.length === 0) return null;
     logger.info(`Recovered ${issues.length} issue(s) from s3db issue resource.`);
-    if (issuePlanResource) {
-      for (const issue of issues) {
-        try {
-          const planRecord = await issuePlanResource.get(issue.id);
-          if (planRecord?.plan) issue.plan = planRecord.plan;
-          if (planRecord?.planHistory) issue.planHistory = planRecord.planHistory;
-        } catch {
+    for (const issue of issues) {
+      try {
+        const current = await getCurrentPlanForIssue(issue.id);
+        if (current) {
+          issue.plan = current.plan;
+          logger.debug({ issueId: issue.id, version: current.version }, "[Recovery] Hydrated current plan");
         }
+      } catch (err) {
+        logger.warn({ issueId: issue.id, err: String(err) }, "[Recovery] Failed to load plan");
       }
     }
     return {
@@ -6555,22 +6531,7 @@ async function persistState(state) {
       }
     }
   }
-  const dirtyIssuePlans = issuePlanResource ? snapshotAndClearDirtyIssuePlanIds() : /* @__PURE__ */ new Set();
-  if (issuePlanResource && dirtyIssuePlans.size > 0) {
-    for (const issue of state.issues) {
-      if (!dirtyIssuePlans.has(issue.id)) continue;
-      try {
-        await issuePlanResource.replace(issue.id, {
-          id: issue.id,
-          plan: issue.plan,
-          planHistory: issue.planHistory,
-          planVersion: issue.planVersion ?? 0
-        });
-      } catch (error) {
-        logger.warn(`Failed to persist issue plan ${issue.id}: ${String(error)}`);
-      }
-    }
-  }
+  snapshotAndClearDirtyIssuePlanIds();
   const dirtyEvents = eventStateResource ? snapshotAndClearDirtyEventIds() : /* @__PURE__ */ new Set();
   if (eventStateResource && dirtyEvents.size > 0) {
     for (const event of state.events) {
@@ -6829,314 +6790,7 @@ function scanProjectFiles(targetRoot) {
     packageDescription
   };
 }
-var BUILD_FILE_SIGNALS = {
-  "package.json": { language: "javascript", stack: ["node"] },
-  "Cargo.toml": { language: "rust", stack: ["cargo"] },
-  "pyproject.toml": { language: "python", stack: ["python"] },
-  "setup.py": { language: "python", stack: ["python"] },
-  "requirements.txt": { language: "python", stack: ["pip"] },
-  "Pipfile": { language: "python", stack: ["pipenv"] },
-  "go.mod": { language: "go", stack: ["go"] },
-  "build.gradle": { language: "java", stack: ["gradle"] },
-  "build.gradle.kts": { language: "kotlin", stack: ["gradle"] },
-  "pom.xml": { language: "java", stack: ["maven"] },
-  "Gemfile": { language: "ruby", stack: ["bundler"] },
-  "mix.exs": { language: "elixir", stack: ["mix"] },
-  "pubspec.yaml": { language: "dart", stack: ["flutter"] },
-  "CMakeLists.txt": { language: "c++", stack: ["cmake"] },
-  "Makefile": { language: "unknown", stack: ["make"] },
-  "Dockerfile": { language: "unknown", stack: ["docker"] },
-  "composer.json": { language: "php", stack: ["composer"] },
-  "Package.swift": { language: "swift", stack: ["spm"] },
-  "deno.json": { language: "typescript", stack: ["deno"] },
-  "bun.lockb": { language: "typescript", stack: ["bun"] }
-};
-function buildFallbackAnalysis(targetRoot) {
-  let description = "";
-  let readmeExcerpt = "";
-  for (const readmeFile of ["README.md", "README.rst", "README.txt", "README"]) {
-    const p = join16(targetRoot, readmeFile);
-    if (existsSync13(p)) {
-      try {
-        readmeExcerpt = readFileSync10(p, "utf8").slice(0, 300).trim();
-        break;
-      } catch {
-      }
-    }
-  }
-  const pkgPath = join16(targetRoot, "package.json");
-  if (existsSync13(pkgPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync10(pkgPath, "utf8"));
-      const name = typeof pkg.name === "string" ? pkg.name : "";
-      const desc = typeof pkg.description === "string" ? pkg.description : "";
-      if (desc) description = name ? `${name}: ${desc}` : desc;
-    } catch {
-    }
-  }
-  const cargoPath = join16(targetRoot, "Cargo.toml");
-  if (!description && existsSync13(cargoPath)) {
-    try {
-      const content = readFileSync10(cargoPath, "utf8");
-      const descMatch = content.match(/^description\s*=\s*"([^"]+)"/m);
-      const nameMatch = content.match(/^name\s*=\s*"([^"]+)"/m);
-      if (descMatch) description = nameMatch ? `${nameMatch[1]}: ${descMatch[1]}` : descMatch[1];
-    } catch {
-    }
-  }
-  const pyprojectPath = join16(targetRoot, "pyproject.toml");
-  if (!description && existsSync13(pyprojectPath)) {
-    try {
-      const content = readFileSync10(pyprojectPath, "utf8");
-      const descMatch = content.match(/^description\s*=\s*"([^"]+)"/m);
-      const nameMatch = content.match(/^name\s*=\s*"([^"]+)"/m);
-      if (descMatch) description = nameMatch ? `${nameMatch[1]}: ${descMatch[1]}` : descMatch[1];
-    } catch {
-    }
-  }
-  if (!description) {
-    description = readmeExcerpt ? readmeExcerpt.split("\n").filter(Boolean).slice(0, 2).join(". ") : "A software project.";
-  }
-  let language = "unknown";
-  const stack = [];
-  for (const [file, signal] of Object.entries(BUILD_FILE_SIGNALS)) {
-    if (existsSync13(join16(targetRoot, file))) {
-      if (language === "unknown" && signal.language !== "unknown") {
-        language = signal.language;
-      }
-      for (const s of signal.stack) {
-        if (!stack.includes(s)) stack.push(s);
-      }
-    }
-  }
-  return {
-    description,
-    language,
-    domains: [],
-    stack: stack.length ? stack : [language],
-    suggestedAgents: ["code-reviewer", "software-architect"],
-    source: "fallback"
-  };
-}
-function parseAnalysisOutput(raw) {
-  const text = raw.trim();
-  if (!text) return null;
-  let jsonText = text;
-  try {
-    const envelope = JSON.parse(text);
-    if (typeof envelope.result === "string") {
-      jsonText = envelope.result.trim();
-    } else if (envelope.description || envelope.domains) {
-      return validateAnalysis(envelope);
-    }
-  } catch {
-  }
-  const fenced = jsonText.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
-  if (fenced) {
-    jsonText = fenced[1].trim();
-  }
-  try {
-    const parsed = JSON.parse(jsonText);
-    return validateAnalysis(parsed);
-  } catch {
-    const match = jsonText.match(/\{[\s\S]*\}/);
-    if (match) {
-      try {
-        const parsed = JSON.parse(match[0]);
-        return validateAnalysis(parsed);
-      } catch {
-        return null;
-      }
-    }
-    return null;
-  }
-}
-function validateAnalysis(parsed) {
-  if (!parsed || typeof parsed !== "object") return null;
-  const description = typeof parsed.description === "string" ? parsed.description.trim() : "";
-  const language = typeof parsed.language === "string" ? parsed.language.trim().toLowerCase() : "";
-  const domains = Array.isArray(parsed.domains) ? parsed.domains.filter((d) => typeof d === "string") : [];
-  const stack = Array.isArray(parsed.stack) ? parsed.stack.filter((s) => typeof s === "string") : [];
-  const suggestedAgents = Array.isArray(parsed.suggestedAgents) ? parsed.suggestedAgents.filter((a) => typeof a === "string") : [];
-  if (!description && domains.length === 0 && stack.length === 0) return null;
-  return {
-    description: description || "A software project.",
-    language,
-    domains,
-    stack,
-    suggestedAgents,
-    source: "cli"
-  };
-}
-function isBlockedProjectAnalysisResponse(analysis) {
-  const normalized = `${analysis.description || ""}`.toLowerCase();
-  const indicators = [
-    "could not inspect the repository files",
-    "local command execution is blocked",
-    "please provide access",
-    "paste the key files",
-    "failed to inspect",
-    "unable to access the repository"
-  ];
-  return indicators.some((indicator) => normalized.includes(indicator));
-}
 var ANALYSIS_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
-function computeProjectHash(targetRoot) {
-  const buildFiles = Object.keys(BUILD_FILE_SIGNALS);
-  const found = buildFiles.filter((f) => existsSync13(join16(targetRoot, f))).sort();
-  return createHash("sha256").update(found.join(",")).digest("hex").slice(0, 16);
-}
-async function loadCachedAnalysis(targetRoot) {
-  const resource = getSettingStateResource();
-  if (!resource) return null;
-  const hash = computeProjectHash(targetRoot);
-  const key = `project-analysis:${hash}`;
-  try {
-    const record2 = await resource.get(key);
-    if (!record2?.value) return null;
-    const cached = record2.value;
-    if (!cached.analysis || !cached.updatedAt) return null;
-    if (Date.now() - Date.parse(cached.updatedAt) > ANALYSIS_CACHE_TTL_MS) return null;
-    return cached.analysis;
-  } catch {
-    return null;
-  }
-}
-async function saveCachedAnalysis(targetRoot, analysis) {
-  const resource = getSettingStateResource();
-  if (!resource) return;
-  const hash = computeProjectHash(targetRoot);
-  const key = `project-analysis:${hash}`;
-  try {
-    await resource.replace(key, {
-      id: key,
-      scope: "system",
-      source: "detected",
-      value: { analysis, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }
-    });
-  } catch {
-  }
-}
-async function analyzeProjectWithCli(provider, targetRoot, options) {
-  if (!options?.forceRefresh) {
-    const cached = await loadCachedAnalysis(targetRoot);
-    if (cached) {
-      logger.info("Using cached project analysis.");
-      return cached;
-    }
-  }
-  const normalizedProvider = provider.trim().toLowerCase();
-  const providers = detectAvailableProviders();
-  const providerInfo = providers.find((p) => p.name === normalizedProvider && p.available);
-  if (!providerInfo) {
-    logger.warn(
-      { provider: normalizedProvider },
-      "Requested CLI provider not available, using fallback analysis"
-    );
-    return buildFallbackAnalysis(targetRoot);
-  }
-  const tempDir = mkdtempSync4(join16(tmpdir4(), "fifony-scan-"));
-  const promptFile = join16(tempDir, "fifony-scan-prompt.txt");
-  const analysisPrompt = await renderPrompt("project-analysis");
-  writeFileSync11(promptFile, analysisPrompt, "utf8");
-  const processEnv = {};
-  for (const [key, value] of Object.entries(env3)) {
-    if (typeof value === "string") processEnv[key] = value;
-  }
-  processEnv.FIFONY_PROMPT_FILE = promptFile;
-  try {
-    const output = await new Promise((resolve3, reject) => {
-      let stdout = "";
-      let stderr = "";
-      let timedOut = false;
-      let args;
-      let command;
-      if (normalizedProvider === "claude") {
-        command = "claude";
-        args = [
-          "--print",
-          "--no-session-persistence",
-          "--output-format",
-          "json",
-          "-p",
-          analysisPrompt
-        ];
-      } else if (normalizedProvider === "codex") {
-        command = "sh";
-        args = ["-c", `codex exec --skip-git-repo-check < "${promptFile}"`];
-      } else {
-        reject(new Error(`Unsupported provider: ${normalizedProvider}`));
-        return;
-      }
-      const child = spawn3(command, args, {
-        cwd: targetRoot,
-        env: processEnv,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-      if (child.stdin) child.stdin.end();
-      child.stdout?.on("data", (chunk) => {
-        stdout = appendFileTail(stdout, chunk.toString("utf8"), 64e3);
-      });
-      child.stderr?.on("data", (chunk) => {
-        stderr = appendFileTail(stderr, chunk.toString("utf8"), 16e3);
-      });
-      const timer = setTimeout(() => {
-        timedOut = true;
-        child.kill("SIGTERM");
-      }, 12e4);
-      child.on("error", (err) => {
-        clearTimeout(timer);
-        reject(new Error(`Failed to spawn ${normalizedProvider}: ${err.message}`));
-      });
-      child.on("close", (code) => {
-        clearTimeout(timer);
-        if (timedOut) {
-          reject(new Error(`CLI analysis timed out after 120s`));
-          return;
-        }
-        if (code !== 0) {
-          logger.debug(
-            { provider: normalizedProvider, code, stderr: stderr.slice(0, 500) },
-            "CLI analysis command exited with non-zero code"
-          );
-        }
-        resolve3(stdout);
-      });
-    });
-    const analysis = parseAnalysisOutput(output);
-    if (analysis && !isBlockedProjectAnalysisResponse(analysis)) {
-      logger.info(
-        { provider: normalizedProvider, domains: analysis.domains, stack: analysis.stack },
-        "CLI project analysis completed"
-      );
-      await saveCachedAnalysis(targetRoot, analysis);
-      return analysis;
-    }
-    if (!analysis) {
-      logger.warn(
-        { provider: normalizedProvider, rawOutput: output.slice(0, 500) },
-        "CLI returned unparseable output, using fallback"
-      );
-    } else {
-      logger.warn(
-        { provider: normalizedProvider, blockedAnalysis: analysis.description },
-        "CLI analysis returned blocked/insufficient context response, using fallback"
-      );
-    }
-    return buildFallbackAnalysis(targetRoot);
-  } catch (error) {
-    logger.warn(
-      { err: error, provider: normalizedProvider },
-      "CLI analysis failed, using fallback"
-    );
-    return buildFallbackAnalysis(targetRoot);
-  } finally {
-    try {
-      rmSync5(tempDir, { recursive: true, force: true });
-    } catch {
-    }
-  }
-}
 var DEFAULT_REFERENCE_REPOSITORIES = [
   {
     id: "ring",
@@ -7575,7 +7229,7 @@ function importReferenceArtifacts(repositoryId, workspaceRoot, options) {
 }
 
 // src/domains/config.ts
-import { env as env4 } from "process";
+import { env as env3 } from "process";
 var VALID_EFFORTS = /* @__PURE__ */ new Set(["low", "medium", "high", "extra-high"]);
 function parseEffortValue(value) {
   const str = typeof value === "string" ? value.trim().toLowerCase() : "";
@@ -7637,21 +7291,21 @@ function deriveConfig(args) {
     staleInProgressTimeoutMs: parseEnvNumber("FIFONY_STALE_IN_PROGRESS_MS", 24e5),
     logLinesTail: parseEnvNumber("FIFONY_LOG_TAIL_CHARS", 12e3),
     maxPreviousOutputChars: parseEnvNumber("FIFONY_PREVIOUS_OUTPUT_CHARS", 2e4),
-    agentProvider: normalizeAgentProvider(env4.FIFONY_AGENT_PROVIDER ?? "codex"),
-    agentCommand: toStringValue(env4.FIFONY_AGENT_COMMAND, ""),
+    agentProvider: normalizeAgentProvider(env3.FIFONY_AGENT_PROVIDER ?? "codex"),
+    agentCommand: toStringValue(env3.FIFONY_AGENT_COMMAND, ""),
     defaultEffort: {
-      default: parseEffortValue(env4.FIFONY_REASONING_EFFORT),
-      planner: parseEffortValue(env4.FIFONY_PLANNER_EFFORT),
-      executor: parseEffortValue(env4.FIFONY_EXECUTOR_EFFORT),
-      reviewer: parseEffortValue(env4.FIFONY_REVIEWER_EFFORT)
+      default: parseEffortValue(env3.FIFONY_REASONING_EFFORT),
+      planner: parseEffortValue(env3.FIFONY_PLANNER_EFFORT),
+      executor: parseEffortValue(env3.FIFONY_EXECUTOR_EFFORT),
+      reviewer: parseEffortValue(env3.FIFONY_REVIEWER_EFFORT)
     },
     maxConcurrentByState: {},
     runMode: "filesystem",
     autoReviewApproval: true,
-    afterCreateHook: env4.FIFONY_AFTER_CREATE_HOOK ?? "",
-    beforeRunHook: env4.FIFONY_BEFORE_RUN_HOOK ?? "",
-    afterRunHook: env4.FIFONY_AFTER_RUN_HOOK ?? "",
-    beforeRemoveHook: env4.FIFONY_BEFORE_REMOVE_HOOK ?? ""
+    afterCreateHook: env3.FIFONY_AFTER_CREATE_HOOK ?? "",
+    beforeRunHook: env3.FIFONY_BEFORE_RUN_HOOK ?? "",
+    afterRunHook: env3.FIFONY_AFTER_RUN_HOOK ?? "",
+    beforeRemoveHook: env3.FIFONY_BEFORE_REMOVE_HOOK ?? ""
   };
 }
 function applyWorkflowConfig(config, port) {
@@ -7873,35 +7527,33 @@ function getNextRetryAt(issue, baseMs) {
   const nextDelay = withRetryBackoff(nextAttempt, baseMs);
   return new Date(Date.now() + nextDelay).toISOString();
 }
-async function handleStatePatch(state, issue, payload) {
-  const nextState = parseIssueState(payload.state);
-  if (!nextState || !ALLOWED_STATES.includes(nextState)) {
-    throw new Error(`Unsupported state: ${String(payload.state)}`);
-  }
-  const sourceState = issue.state;
-  const path = findIssueStateMachineTransitionPath(null, issue.state, nextState);
-  if (!path || path.length === 0) {
-    throw new Error(`No valid transition from '${issue.state}' to '${nextState}' for issue ${issue.id}.`);
-  }
-  for (const event of path) {
-    await transitionIssue(issue, event, { note: `Manual state update: ${nextState}`, reason: toStringValue(payload.reason) });
-  }
-  if (nextState === "Running" && sourceState === "Queued") {
-    try {
-      const { enqueue: enqueue2 } = await import("./queue-workers-BQLDNMFQ.js");
-      await enqueue2(issue, "execute");
-    } catch (error) {
-      logger.warn({ issueId: issue.id, err: error }, "[Issues] Failed to enqueue after manual Running transition");
-    }
-  }
-  if (nextState === "PendingApproval") {
-    issue.nextRetryAt = void 0;
-    issue.lastError = void 0;
+
+// src/commands/request-rework.command.ts
+async function requestReworkCommand(input, deps) {
+  const { issue, reviewerFeedback, note } = input;
+  if (issue.state !== "Reviewing" && issue.state !== "PendingDecision") {
+    throw new Error(
+      `requestReworkCommand requires Reviewing or PendingDecision state, got ${issue.state}.`
+    );
   }
-  if (nextState === "Cancelled") {
-    issue.lastError = toStringValue(payload.reason);
+  issue.lastError = reviewerFeedback;
+  issue.lastFailedPhase = "review";
+  issue.attempts += 1;
+  if (issue.state === "Reviewing") {
+    await transitionIssueCommand(
+      { issue, target: "PendingDecision", note: `Reviewer completed for ${issue.identifier}.` },
+      deps
+    );
   }
-  addEvent(state, issue.id, "manual", `Manual state transition to ${nextState}`);
+  await transitionIssueCommand(
+    { issue, target: "Queued", note: note ?? `Reviewer requested rework for ${issue.identifier}.` },
+    deps
+  );
+  deps.eventStore.addEvent(
+    issue.id,
+    "runner",
+    `Issue ${issue.identifier} sent back for rework by reviewer.`
+  );
 }
 
 // src/agents/issue-runner.ts
@@ -7924,8 +7576,14 @@ async function runPlanningJob(state, issue) {
       { persistSession: false }
     );
     issue.plan = plan;
-    markIssuePlanDirty(issue.id);
     issue.planVersion = Math.max(issue.planVersion ?? 0, 1);
+    try {
+      const { savePlanForIssue: savePlanForIssue2 } = await import("./store-O3UNJU26.js");
+      await savePlanForIssue2(issue.id, plan, issue.planVersion);
+      logger.debug({ issueId: issue.id, planVersion: issue.planVersion }, "[Agent] Plan saved to issue_plans resource");
+    } catch (err) {
+      logger.warn({ err: String(err), issueId: issue.id }, "[Agent] Failed to save plan");
+    }
     if (plan.suggestedPaths?.length && !issue.paths?.length) issue.paths = plan.suggestedPaths;
     if (plan.suggestedEffort && !issue.effort) issue.effort = plan.suggestedEffort;
     if (usage.totalTokens > 0) {
@@ -8156,7 +7814,7 @@ async function runIssueOnce(state, issue, running) {
     const { workspacePath, promptText, promptFile } = await prepareWorkspace(issue, state, state.config.defaultBranch);
     container.issueRepository.markDirty(issue.id);
     try {
-      const { getIssueStateResource: getIssueStateResource2 } = await import("./store-44KLJAXC.js");
+      const { getIssueStateResource: getIssueStateResource2 } = await import("./store-O3UNJU26.js");
       const res = getIssueStateResource2();
       if (res) {
         await res.patch(issue.id, {
@@ -8197,7 +7855,7 @@ async function runIssueOnce(state, issue, running) {
     await container.persistencePort.persistState(state);
     if (issue.state === "Reviewing") {
       try {
-        const { enqueue: enqueue2 } = await import("./queue-workers-BQLDNMFQ.js");
+        const { enqueue: enqueue2 } = await import("./queue-workers-6MZWSPBW.js");
         await enqueue2(issue, "review");
       } catch {
       }
@@ -8243,7 +7901,6 @@ export {
   transitionIssue,
   issueDependenciesResolved,
   getNextRetryAt,
-  handleStatePatch,
   runAgentSession,
   runAgentPipeline,
   issueHasResumableSession,
@@ -8255,6 +7912,9 @@ export {
   getSettingStateResource,
   getAgentSessionResource,
   getAgentPipelineResource,
+  savePlanForIssue,
+  getCurrentPlanForIssue,
+  getPlansForIssue,
   setActiveApiPlugin,
   loadS3dbModule,
   initStateStore,
@@ -8275,4 +7935,4 @@ export {
   syncReferenceRepositories,
   importReferenceArtifacts
 };
-//# sourceMappingURL=chunk-A7BVAGPW.js.map
+//# sourceMappingURL=chunk-YBMQIQ2X.js.map