fifony 0.1.43 → 0.1.47

package/dist/{chunk-YRSH2CLW.js → chunk-K36BWMUV.js}

@@ -1,26 +1,58 @@
+import {
+  requestReworkCommand,
+  retryIssueCommand
+} from "./chunk-PACI3T4I.js";
+import {
+  approvePlanCommand
+} from "./chunk-HOIOVUHI.js";
 import {
   SETTING_ID_PUSH_SUBSCRIPTIONS,
   addSubscription,
   getSubscriptionCount,
   getVapidPublicKey,
   removeSubscription
-} from "./chunk-BRSR26VK.js";
+} from "./chunk-FH7HUPZX.js";
+import {
+  broadcastToWebSocketClients,
+  makeWebSocketConfig,
+  sendToMeshRoom
+} from "./chunk-N4KFNX2G.js";
+import {
+  getAllServiceStatuses,
+  getServiceGraph,
+  getServiceStatus,
+  getTrafficBuffer,
+  getTrafficProxyPort,
+  getTrafficProxyStats,
+  isTrafficProxyRunning,
+  normalizeServiceEnvironment,
+  readServiceLogTail,
+  reconcileServiceStates,
+  sendServiceEvent,
+  serviceLogPath,
+  serviceStateMachineConfig,
+  setServiceResourceStateApi,
+  setServicesAccessor,
+  startTrafficProxy,
+  stopTrafficProxy
+} from "./chunk-AAVROEQC.js";
+import {
+  replanIssueCommand
+} from "./chunk-5AMWD66T.js";
 import {
   deleteIssueStateMachineResourceState,
   getIssueStateMachineTransitions,
   getIssueStateMachineVisualization,
   getIssueTransitionHistoryForIssue,
-  replanIssueCommand,
   syncIssueStateFromFsm,
   syncIssueStateInMemory,
   transitionIssueCommand
-} from "./chunk-QQQLP3PL.js";
+} from "./chunk-7TXZYZR5.js";
 import {
   assertPlanReadyForExecution,
   executeTransition,
   extractFailureInsights,
   getMetrics,
-  getPlanExecutionBlocker,
   issueStateMachineConfig,
   needsContractNegotiationWork,
   requiresContractNegotiation,
@@ -29,7 +61,7 @@ import {
   setIssueResourceStateApi,
   setIssueStateMachinePlugin,
   setPersistNowFn
-} from "./chunk-AILXZ2TD.js";
+} from "./chunk-JRLWLZOD.js";
 import {
   CONTAINER_PLANNING,
   assertIssueHasGitWorktree,
@@ -59,7 +91,7 @@ import {
   runCommandWithTimeout,
   runHook,
   writeToDaemon
-} from "./chunk-SOBLO4YZ.js";
+} from "./chunk-QH6VCTET.js";
 import {
   SETTING_ID_PROJECT_NAME,
   addEvent,
@@ -79,24 +111,18 @@ import {
   resolveProjectMetadata,
   scanProjectFiles,
   setIssueTransitionExecutor,
+  shouldUseFastMode,
   syncReferenceRepositories,
   transitionIssue
-} from "./chunk-E2EWEYA4.js";
-import {
-  computeMetrics,
-  computeQualityGateMetrics
-} from "./chunk-MVTGAKQK.js";
+} from "./chunk-2PRRKBG6.js";
 import {
   ADAPTERS,
-  applyCheckpointPolicyToPlan,
-  applyHarnessModeToPlan,
   buildExecutionPayload,
   buildFullPlanPrompt,
   collectClaudeUsageFromCli,
   collectCodexUsageFromCli,
   collectGeminiUsageFromCli,
   deriveExecutionContract,
-  deriveReviewProfile,
   detectAvailableProviders,
   discoverModels,
   getDirtyEventIds,
@@ -117,20 +143,26 @@ import {
   normalizeAcceptanceCriteria,
   normalizeAgentProvider,
   readCodexConfig,
-  recommendCheckpointPolicyForIssue,
-  recommendHarnessModeForIssue,
   resolveProviderCapabilities,
   snapshotAndClearDirtyEventIds,
   snapshotAndClearDirtyIssueIds,
   snapshotAndClearDirtyIssuePlanIds,
   snapshotAndClearDirtyMilestoneIds
-} from "./chunk-FJNH3G2Z.js";
+} from "./chunk-PI7Y77R3.js";
 import {
-  logger
-} from "./chunk-DVU3CXWA.js";
+  computeMetrics,
+  computeQualityGateMetrics
+} from "./chunk-QHISYRXJ.js";
+import {
+  applyCheckpointPolicyToPlan,
+  applyHarnessModeToPlan,
+  deriveReviewProfile,
+  recommendCheckpointPolicyForIssue,
+  recommendHarnessModeForIssue
+} from "./chunk-EBCSQFPR.js";
 import {
   renderPrompt
-} from "./chunk-ESWHDHH6.js";
+} from "./chunk-AAZKYWOY.js";
 import {
   ATTACHMENTS_ROOT,
   BLUEPRINT_ARTIFACTS_DIRNAME,
@@ -194,7 +226,10 @@ import {
   toNumberValue,
   toStringArray,
   toStringValue
-} from "./chunk-42AMQAJG.js";
+} from "./chunk-VM5QAYP5.js";
+import {
+  logger
+} from "./chunk-PXTIWKLQ.js";
 import {
   isAgentStillRunning,
   isDaemonAlive,
@@ -202,48 +237,6 @@ import {
   readAgentPid
 } from "./chunk-3NE23NYW.js";
 
-// src/domains/service-env.ts
-var ENV_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
-function isValidServiceEnvKey(key) {
-  return ENV_KEY_PATTERN.test(key);
-}
-function normalizeServiceEnvironment(value) {
-  if (value === void 0 || value === null) {
-    return { env: {}, errors: [] };
-  }
-  if (typeof value !== "object" || Array.isArray(value)) {
-    return { env: {}, errors: ["Environment must be an object map of KEY -> value."] };
-  }
-  const env3 = {};
-  const errors = [];
-  for (const [rawKey, rawValue] of Object.entries(value)) {
-    const key = rawKey.trim();
-    if (!key) continue;
-    if (!isValidServiceEnvKey(key)) {
-      errors.push(`Invalid environment variable name: ${rawKey}`);
-      continue;
-    }
-    env3[key] = rawValue === void 0 || rawValue === null ? "" : String(rawValue);
-  }
-  return { env: env3, errors };
-}
-function mergeServiceEnvironment(globalEnv, serviceEnv) {
-  return {
-    ...globalEnv ?? {},
-    ...serviceEnv ?? {}
-  };
-}
-function shellQuoteEnvValue(value) {
-  return `'${value.replace(/'/g, `'"'"'`)}'`;
-}
-function buildServiceCommand(command, globalEnv, serviceEnv) {
-  const baseCommand = command.trim();
-  if (!baseCommand) return "";
-  const env3 = mergeServiceEnvironment(globalEnv, serviceEnv);
-  const assignments = Object.entries(env3).map(([key, value]) => `${key}=${shellQuoteEnvValue(value)}`);
-  return assignments.length > 0 ? `${assignments.join(" ")} ${baseCommand}` : baseCommand;
-}
-
 // src/persistence/plugins/api-runtime-context.ts
 var context = null;
 function setApiRuntimeContext(state) {
@@ -261,8 +254,8 @@ function getApiRuntimeContextOrThrow() {
 
 // src/persistence/plugins/api-server.ts
 import {
-  existsSync as existsSync18,
-  readFileSync as readFileSync14
+  existsSync as existsSync19,
+  readFileSync as readFileSync17
 } from "fs";
 
 // src/concerns/app-shell-routes.ts
@@ -281,10 +274,11 @@ var APP_SHELL_ROUTES = [
   "/settings/notifications",
   "/settings/execution",
   "/settings/quality",
-  "/settings/pipeline",
+  "/settings/assets",
   "/settings/services",
   "/settings/appearance",
-  "/settings/providers"
+  "/settings/providers",
+  "/chat"
 ];
 
 // src/persistence/resources/runtime-state.resource.ts
@@ -349,6 +343,61 @@ function addTokenUsage(issue, usage, role) {
   if (!issue.usage) issue.usage = { tokens: {} };
   issue.usage.tokens[model] = (issue.usage.tokens[model] || 0) + usage.totalTokens;
 }
+function extractJsonEnvelopeResult(text) {
+  try {
+    const env4 = JSON.parse(text.trim());
+    if (env4 && typeof env4 === "object" && typeof env4.result === "string") return env4.result;
+  } catch {
+  }
+  const start = text.indexOf("{");
+  if (start < 0) return null;
+  const end = text.lastIndexOf("}");
+  if (end <= start) return null;
+  try {
+    const env4 = JSON.parse(text.slice(start, end + 1));
+    if (env4 && typeof env4 === "object" && typeof env4.result === "string") return env4.result;
+  } catch {
+  }
+  const m = text.match(/"result"\s*:\s*"([\s\S]+)/);
+  if (m) {
+    let raw = "";
+    let i = 0;
+    const src = m[1];
+    while (i < src.length) {
+      if (src[i] === "\\" && i + 1 < src.length) {
+        const next = src[i + 1];
+        if (next === "n") {
+          raw += "\n";
+          i += 2;
+          continue;
+        }
+        if (next === "t") {
+          raw += "	";
+          i += 2;
+          continue;
+        }
+        if (next === '"') {
+          raw += '"';
+          i += 2;
+          continue;
+        }
+        if (next === "\\") {
+          raw += "\\";
+          i += 2;
+          continue;
+        }
+        raw += next;
+        i += 2;
+        continue;
+      }
+      if (src[i] === '"') break;
+      raw += src[i];
+      i += 1;
+    }
+    if (raw.length > 100) return raw;
+  }
+  return null;
+}
 function extractOutputMarker(output, name) {
   const match = output.match(new RegExp(`^${name}=(.+)$`, "im"));
   return match?.[1]?.trim() ?? "";
@@ -770,7 +819,7 @@ import {
   mkdirSync as mkdirSync8,
   writeFileSync as writeFileSync11
 } from "fs";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 
 // src/agents/adapters/index.ts
 import { writeFileSync } from "fs";
@@ -831,6 +880,9 @@ async function compileReview(issue, reviewer, workspacePath, diffSummary, config
   const reviewProfile = deriveReviewProfile(issue);
   const scopeConfig = buildReviewScopeConfig(scope);
   const hasFrontendChanges2 = !!playwrightMcpConfigPath;
+  const complexity = issue.plan?.estimatedComplexity;
+  const harnessMode = issue.plan?.harnessMode ?? "standard";
+  const lightReview = (complexity === "trivial" || complexity === "low") && (harnessMode === "solo" || harnessMode === "standard");
   const prompt = await renderPrompt("compile-review", {
     issueIdentifier: issue.identifier,
     title: issue.title,
@@ -851,7 +903,8 @@ async function compileReview(issue, reviewer, workspacePath, diffSummary, config
     diffSummary,
     hasFrontendChanges: hasFrontendChanges2,
     images: issue.images?.length ? issue.images : void 0,
-    preReviewValidation: issue.preReviewValidation ?? null
+    preReviewValidation: issue.preReviewValidation ?? null,
+    lightReview
   });
   const adapter = ADAPTERS[reviewer.provider];
   let command = adapter ? adapter.buildReviewCommand(reviewer, config) : reviewer.command;
@@ -1332,13 +1385,13 @@ function buildCapabilitiesManifest(skills, agents, commands) {
 
 // src/persistence/plugins/fsm-agent.ts
 import {
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync5,
+  readFileSync as readFileSync6,
   rmSync as rmSync3,
   writeFileSync as writeFileSync9
 } from "fs";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 import { execSync } from "child_process";
 
 // src/agents/planning/planning-session.ts
@@ -1667,11 +1720,11 @@ async function getLocalFeatureExtractor(model) {
         "[Embeddings] Migrated local embedding cache into the shared Fifony cache"
       );
     }
-    const { pipeline, env: env3 } = await import("@huggingface/transformers");
+    const { pipeline, env: env4 } = await import("@huggingface/transformers");
     mkdirSync2(EMBEDDING_LOCAL_CACHE_DIR, { recursive: true });
-    env3.cacheDir = EMBEDDING_LOCAL_CACHE_DIR;
-    env3.allowLocalModels = true;
-    env3.allowRemoteModels = true;
+    env4.cacheDir = EMBEDDING_LOCAL_CACHE_DIR;
+    env4.allowLocalModels = true;
+    env4.allowRemoteModels = true;
     return await pipeline("feature-extraction", model);
   })();
   localExtractorPromises.set(model, promise);
@@ -2929,6 +2982,78 @@ async function resolvePlanStageConfig(config) {
   const model = provider === configuredProvider ? configuredModel : void 0;
   return { provider, model, effort: configuredEffort };
 }
+async function resolveEnhanceStageConfig(config) {
+  const providers = detectAvailableProviders();
+  const available = providers.filter((p) => p.available).map((p) => p.name);
+  let configuredProvider;
+  let configuredModel;
+  let configuredEffort;
+  try {
+    const settings = await loadRuntimeSettings();
+    const workflowConfig = getWorkflowConfig(settings);
+    if (workflowConfig?.enhance) {
+      configuredProvider = workflowConfig.enhance.provider;
+      configuredModel = workflowConfig.enhance.model;
+      configuredEffort = workflowConfig.enhance.effort;
+    }
+  } catch {
+  }
+  if (!configuredProvider) {
+    return resolvePlanStageConfig(config);
+  }
+  const provider = configuredProvider && available.includes(configuredProvider) ? configuredProvider : config.agentProvider && available.includes(config.agentProvider) ? config.agentProvider : available[0];
+  if (!provider) throw new Error("No AI provider available for enhance.");
+  const model = provider === configuredProvider ? configuredModel : void 0;
+  return { provider, model, effort: configuredEffort };
+}
+async function resolveServicesStageConfig(config) {
+  const providers = detectAvailableProviders();
+  const available = providers.filter((p) => p.available).map((p) => p.name);
+  let configuredProvider;
+  let configuredModel;
+  let configuredEffort;
+  try {
+    const settings = await loadRuntimeSettings();
+    const workflowConfig = getWorkflowConfig(settings);
+    if (workflowConfig?.services) {
+      configuredProvider = workflowConfig.services.provider;
+      configuredModel = workflowConfig.services.model;
+      configuredEffort = workflowConfig.services.effort;
+    }
+  } catch {
+  }
+  if (!configuredProvider) {
+    return resolvePlanStageConfig(config);
+  }
+  const provider = configuredProvider && available.includes(configuredProvider) ? configuredProvider : config.agentProvider && available.includes(config.agentProvider) ? config.agentProvider : available[0];
+  if (!provider) throw new Error("No AI provider available for services.");
+  const model = provider === configuredProvider ? configuredModel : void 0;
+  return { provider, model, effort: configuredEffort };
+}
+async function resolveChatStageConfig(config) {
+  const providers = detectAvailableProviders();
+  const available = providers.filter((p) => p.available).map((p) => p.name);
+  let configuredProvider;
+  let configuredModel;
+  let configuredEffort;
+  try {
+    const settings = await loadRuntimeSettings();
+    const workflowConfig = getWorkflowConfig(settings);
+    if (workflowConfig?.chat) {
+      configuredProvider = workflowConfig.chat.provider;
+      configuredModel = workflowConfig.chat.model;
+      configuredEffort = workflowConfig.chat.effort;
+    }
+  } catch {
+  }
+  if (!configuredProvider) {
+    return resolvePlanStageConfig(config);
+  }
+  const provider = configuredProvider && available.includes(configuredProvider) ? configuredProvider : config.agentProvider && available.includes(config.agentProvider) ? config.agentProvider : available[0];
+  if (!provider) throw new Error("No AI provider available for chat.");
+  const model = provider === configuredProvider ? configuredModel : void 0;
+  return { provider, model, effort: configuredEffort };
+}
 var PLAN_TIMEOUT_MS = 18e5;
 var PLAN_STALE_OUTPUT_MS = 18e5;
 async function runPlanningProcess(options) {
@@ -3399,13 +3524,8 @@ function completeContractNegotiationRun(issue, round, reviewResult, decision, co
 }
 function extractContractDecision(text) {
   const candidates = [text];
-  try {
-    const envelope = JSON.parse(text.trim());
-    if (envelope && typeof envelope === "object") {
-      if (typeof envelope.result === "string") candidates.push(envelope.result);
-    }
-  } catch {
-  }
+  const envelopeResult = extractJsonEnvelopeResult(text);
+  if (envelopeResult) candidates.push(envelopeResult);
   for (const candidate of candidates) {
     const match = candidate.match(/```json contract_decision\n([\s\S]+?)```/);
     if (!match) continue;
@@ -3544,6 +3664,15 @@ async function runContractNegotiation(state, issue, workflowConfig, workspacePat
     markIssueDirty(issue.id);
     return { status: "skipped", approved: true, rounds: 0 };
   }
+  const complexity = issue.plan?.estimatedComplexity;
+  if (complexity === "trivial" || complexity === "low") {
+    issue.contractNegotiationStatus = "skipped";
+    issue.contractNegotiationAttempt = 0;
+    issue.planningError = void 0;
+    markIssueDirty(issue.id);
+    addEvent(state, issue.id, "info", `Contract negotiation skipped for ${issue.identifier}: ${complexity} complexity does not warrant negotiation.`);
+    return { status: "skipped", approved: true, rounds: 0 };
+  }
   issue.contractNegotiationStatus = "running";
   issue.planningError = void 0;
   markIssueDirty(issue.id);
@@ -3826,7 +3955,110 @@ function refinePlanInBackground(state, issue, feedback) {
 }
 
 // src/domains/validation.ts
-import { execFile } from "child_process";
+import { execFile, execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync3 } from "fs";
+import { join as join12 } from "path";
+var cachedMonorepoInfo = null;
+function detectMonorepo(root) {
+  if (cachedMonorepoInfo) return cachedMonorepoInfo;
+  const pm = existsSync6(join12(root, "pnpm-lock.yaml")) ? "pnpm" : existsSync6(join12(root, "yarn.lock")) ? "yarn" : "npm";
+  const packages = /* @__PURE__ */ new Map();
+  const parentDirs = [];
+  const pnpmWs = join12(root, "pnpm-workspace.yaml");
+  if (existsSync6(pnpmWs)) {
+    try {
+      const content = readFileSync5(pnpmWs, "utf8");
+      for (const match of content.matchAll(/^\s+-\s+["']?([^"'\n]+)["']?/gm)) {
+        const glob = match[1].trim().replace(/\/\*.*$/, "");
+        if (glob) parentDirs.push(glob);
+      }
+    } catch {
+    }
+  }
+  if (parentDirs.length === 0) {
+    try {
+      const rootPkg = JSON.parse(readFileSync5(join12(root, "package.json"), "utf8"));
+      if (Array.isArray(rootPkg.workspaces)) {
+        for (const glob of rootPkg.workspaces) {
+          const parent = String(glob).replace(/\/\*.*$/, "");
+          if (parent) parentDirs.push(parent);
+        }
+      }
+    } catch {
+    }
+  }
+  if (parentDirs.length === 0) {
+    cachedMonorepoInfo = { isMonorepo: false, pm, packages };
+    return cachedMonorepoInfo;
+  }
+  for (const parent of parentDirs) {
+    const absParent = join12(root, parent);
+    if (!existsSync6(absParent)) continue;
+    try {
+      for (const child of readdirSync3(absParent, { withFileTypes: true })) {
+        if (!child.isDirectory()) continue;
+        const pkgJsonPath = join12(absParent, child.name, "package.json");
+        if (!existsSync6(pkgJsonPath)) continue;
+        try {
+          const pkg = JSON.parse(readFileSync5(pkgJsonPath, "utf8"));
+          const name = typeof pkg.name === "string" ? pkg.name : child.name;
+          packages.set(`${parent}/${child.name}`, name);
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  cachedMonorepoInfo = { isMonorepo: true, pm, packages };
+  return cachedMonorepoInfo;
+}
+function getChangedFiles(issue) {
+  const cwd = issue.worktreePath;
+  if (!cwd || !issue.baseBranch) return [];
+  try {
+    const out = execFileSync2("git", ["diff", "--name-only", `${issue.baseBranch}...HEAD`], {
+      cwd,
+      encoding: "utf8",
+      timeout: 1e4
+    });
+    return out.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function affectedPackages(changedFiles, packages) {
+  const affected = /* @__PURE__ */ new Set();
+  for (const file of changedFiles) {
+    for (const [dir, name] of packages) {
+      if (file.startsWith(dir + "/")) {
+        affected.add(name);
+        break;
+      }
+    }
+  }
+  return [...affected];
+}
+function buildScopedTestCommand(issue, baseCommand) {
+  const root = TARGET_ROOT;
+  const mono = detectMonorepo(root);
+  if (!mono.isMonorepo || mono.packages.size === 0) return null;
+  const changedFiles = getChangedFiles(issue);
+  if (changedFiles.length === 0) return null;
+  const affected = affectedPackages(changedFiles, mono.packages);
+  if (affected.length === 0) {
+    logger.info({ issueId: issue.id, changedFiles: changedFiles.length }, "[Validation] Changed files don't belong to any workspace package \u2014 skipping gate");
+    return "true";
+  }
+  if (mono.pm === "pnpm") {
+    const filters = affected.map((pkg) => `--filter "${pkg}"`).join(" ");
+    return `pnpm ${filters} test`;
+  }
+  if (mono.pm === "yarn") {
+    const includes = affected.map((pkg) => `--include "${pkg}"`).join(" ");
+    return `yarn workspaces foreach ${includes} run test`;
+  }
+  return affected.map((pkg) => `npm -w "${pkg}" test`).join(" && ");
+}
 async function runValidationGate(issue, config) {
   if (!config.testCommand) return null;
   const cwd = issue.worktreePath ?? issue.workspacePath;
@@ -3834,8 +4066,9 @@ async function runValidationGate(issue, config) {
     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");
+  const scopedCommand = buildScopedTestCommand(issue, config.testCommand);
+  const command = scopedCommand ?? config.testCommand;
+  logger.info({ issueId: issue.id, command, scoped: !!scopedCommand, cwd }, "[Validation] Running validation gate");
   return new Promise((resolve5) => {
     execFile("sh", ["-c", command], {
       cwd,
@@ -3845,7 +4078,7 @@ async function runValidationGate(issue, config) {
     }, (err, stdout, stderr) => {
       const combined = (stdout || "") + (stderr || "");
       if (!err) {
-        logger.info({ issueId: issue.id }, "[Validation] Gate passed");
+        logger.info({ issueId: issue.id, command }, "[Validation] Gate passed");
         resolve5({
           passed: true,
           output: combined.slice(-2048),
@@ -3854,7 +4087,7 @@ async function runValidationGate(issue, config) {
         });
         return;
       }
-      logger.warn({ issueId: issue.id, exitCode: err.code }, "[Validation] Gate failed");
+      logger.warn({ issueId: issue.id, exitCode: err.code, command }, "[Validation] Gate failed");
       resolve5({
         passed: false,
         output: combined.slice(-2048) || String(err).slice(0, 2048),
@@ -3985,6 +4218,7 @@ var waiters = [];
 var staleInterval = null;
 var persistInterval = null;
 var analyticsInterval = null;
+var blockedRetryInterval = null;
 async function initQueueWorkers(state) {
   runtimeState = state;
   active = true;
@@ -3996,13 +4230,13 @@ async function initQueueWorkers(state) {
   }, 3e4);
   persistInterval = setInterval(() => {
     if (!active || !runtimeState) return;
-    import("./store-M6NCKMZY.js").then(
+    import("./store-S3NAYZ3S.js").then(
       ({ persistState: persistState2 }) => persistState2(runtimeState).catch(() => {
       })
     ).catch(() => {
     });
   }, 5e3);
-  import("./analytics-broadcaster-O6YBP66L.js").then(({ initAnalyticsBroadcaster, pushAllAnalytics }) => {
+  import("./analytics-broadcaster-O4AE3RUK.js").then(({ initAnalyticsBroadcaster, pushAllAnalytics }) => {
     initAnalyticsBroadcaster(state);
     analyticsInterval = setInterval(() => {
       if (!active || !runtimeState) return;
@@ -4011,6 +4245,12 @@ async function initQueueWorkers(state) {
       );
     }, 3e4);
   }).catch((err) => logger.error({ err }, "[Queue] Failed to init analytics broadcaster"));
+  blockedRetryInterval = setInterval(() => {
+    if (!active || !runtimeState) return;
+    autoRetryBlockedIssues(runtimeState).catch(
+      (err) => logger.error({ err }, "[Queue] Blocked retry check failed")
+    );
+  }, 1e4);
   logger.info("[Queue] Unified work queue ready");
 }
 async function stopQueueWorkers() {
@@ -4027,6 +4267,10 @@ async function stopQueueWorkers() {
     clearInterval(analyticsInterval);
     analyticsInterval = null;
   }
+  if (blockedRetryInterval) {
+    clearInterval(blockedRetryInterval);
+    blockedRetryInterval = null;
+  }
   runtimeState = null;
   queue.length = 0;
   waiters.length = 0;
@@ -4092,9 +4336,27 @@ async function dispatchReview(issue) {
 }
 async function checkStaleIssues() {
   if (!runtimeState) return;
-  const { ensureNotStale: ensureNotStale2 } = await import("./scheduler-ZP7GOZDW.js");
+  const { ensureNotStale: ensureNotStale2 } = await import("./scheduler-KYILMWLD.js");
   await ensureNotStale2(runtimeState, runtimeState.config.staleInProgressTimeoutMs);
 }
+async function autoRetryBlockedIssues(state) {
+  const now3 = Date.now();
+  for (const issue of state.issues) {
+    if (issue.state !== "Blocked") continue;
+    if (!issue.nextRetryAt) continue;
+    if (issue.attempts >= issue.maxAttempts) continue;
+    const retryAt = new Date(issue.nextRetryAt).getTime();
+    if (isNaN(retryAt) || retryAt > now3) continue;
+    try {
+      const { transitionIssue: transitionIssue2 } = await import("./issues-3YNNTB4U.js");
+      issue.nextRetryAt = void 0;
+      await transitionIssue2(issue, "UNBLOCK", { note: `Auto-retry: nextRetryAt reached.` });
+      logger.info({ issueId: issue.id, identifier: issue.identifier }, "[Queue] Auto-retried blocked issue");
+    } catch (err) {
+      logger.warn({ err: String(err), issueId: issue.id }, "[Queue] Failed to auto-retry blocked issue");
+    }
+  }
+}
 var draining = false;
 async function drain() {
   if (draining) return;
@@ -4179,8 +4441,8 @@ async function recoverState() {
 }
 async function recoverOrphans() {
   if (!runtimeState) return;
-  const { isAgentStillRunning: isAgentStillRunning2, cleanStalePidFile: cleanStalePidFile2, isDaemonAlive: isDaemonAlive2, isDaemonSocketReady: isDaemonSocketReady2 } = await import("./agent-RMQTTUEC.js");
-  const { addEvent: addEvent2 } = await import("./issues-3QRR7KM6.js");
+  const { isAgentStillRunning: isAgentStillRunning2, cleanStalePidFile: cleanStalePidFile2, isDaemonAlive: isDaemonAlive2, isDaemonSocketReady: isDaemonSocketReady2 } = await import("./agent-DFSFG6DG.js");
+  const { addEvent: addEvent2 } = await import("./issues-3YNNTB4U.js");
   const candidates = runtimeState.issues.filter((i) => i.state === "Running" || i.state === "Queued");
   logger.debug({ count: candidates.length }, "[Queue] Checking for orphaned agent processes");
   for (const issue of candidates) {
@@ -4241,7 +4503,7 @@ function cleanTerminalWorkspaces() {
   logger.info({ count: terminals.length }, "[Queue] Scheduling terminal workspace cleanup in background");
   const state = runtimeState;
   setImmediate(async () => {
-    const { cleanWorkspace: cleanWorkspace2 } = await import("./agent-RMQTTUEC.js");
+    const { cleanWorkspace: cleanWorkspace2 } = await import("./agent-DFSFG6DG.js");
     for (const issue of terminals) {
       try {
         await cleanWorkspace2(issue.id, issue, state);
@@ -4285,7 +4547,8 @@ function createContainer(state) {
   });
   setEnqueueFn((issue, job) => enqueue(issue, job));
   setPersistNowFn(() => {
-    persistState(state).catch(() => {
+    persistState(state).catch((err) => {
+      console.error("[PersistNow] Failed to persist state after FSM transition:", err);
     });
   });
   setIssueTransitionExecutor((issue, event, context2) => executeTransition(issue, event, context2));
@@ -4296,34 +4559,6 @@ function getContainer() {
   return _container;
 }
 
-// src/commands/request-rework.command.ts
-async function requestReworkCommand(input, deps) {
-  const { issue, reviewerFeedback, note, eventKind } = input;
-  if (issue.state !== "Reviewing" && issue.state !== "PendingDecision") {
-    throw new Error(
-      `requestReworkCommand requires Reviewing or PendingDecision state, got ${issue.state}.`
-    );
-  }
-  const archivalFeedback = reviewerFeedback.trim() || note?.trim() || issue.lastError || "Manual rework request.";
-  issue.lastError = archivalFeedback;
-  issue.lastFailedPhase = "review";
-  if (issue.state === "Reviewing") {
-    await transitionIssueCommand(
-      { issue, target: "PendingDecision", note: `Reviewer completed for ${issue.identifier}.` },
-      deps
-    );
-  }
-  await transitionIssueCommand(
-    { issue, target: "Queued", note: archivalFeedback },
-    deps
-  );
-  deps.eventStore.addEvent(
-    issue.id,
-    eventKind ?? "runner",
-    note ?? `Issue ${issue.identifier} sent back for rework by reviewer.`
-  );
-}
-
 // src/commands/agent-issue-outcomes.command.ts
 async function sendIssueToManualDecisionCommand(issue, note, deps) {
   await transitionIssueCommand({ issue, target: "PendingDecision", note }, deps);
@@ -4337,13 +4572,10 @@ async function startIssueReviewCommand(issue, note, deps) {
 async function blockIssueForRetryCommand(issue, note, deps) {
   await transitionIssueCommand({ issue, target: "Blocked", note }, deps);
 }
-async function cancelIssueFromAgentCommand(issue, note, deps) {
-  await transitionIssueCommand({ issue, target: "Cancelled", note }, deps);
-}
 
 // src/agents/blueprints.ts
 import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync8 } from "fs";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 import { randomUUID } from "crypto";
 var EXECUTION_NODE_IDS = {
   ingestContext: "ingest_context",
@@ -4462,17 +4694,17 @@ function buildHarnessBlueprint(plan, config) {
   };
 }
 function resolveBlueprintArtifactsRoot(workspacePath) {
-  return join12(workspacePath, BLUEPRINT_ARTIFACTS_DIRNAME);
+  return join13(workspacePath, BLUEPRINT_ARTIFACTS_DIRNAME);
 }
 function ensureNodeDir(workspacePath, runId, nodeId) {
-  const dir = join12(resolveBlueprintArtifactsRoot(workspacePath), runId, nodeId);
+  const dir = join13(resolveBlueprintArtifactsRoot(workspacePath), runId, nodeId);
   mkdirSync6(dir, { recursive: true });
   return dir;
 }
 function writeBlueprintArtifact(workspacePath, runId, nodeId, kind, content, extension = "md") {
   const dir = ensureNodeDir(workspacePath, runId, nodeId);
   const fileName = `${kind}.${extension}`;
-  const absolutePath = join12(dir, fileName);
+  const absolutePath = join13(dir, fileName);
   writeFileSync8(absolutePath, content, "utf8");
   return {
     id: `${nodeId}:${kind}`,
@@ -4577,16 +4809,16 @@ var BLUEPRINT_EXECUTION_NODE_IDS = EXECUTION_NODE_IDS;
 // src/persistence/plugins/fsm-agent.ts
 var AGENT_WATCHER_INTERVAL_MS = 5e3;
 function jobStatePath(fifonyDir, issueId) {
-  return join13(fifonyDir, `agent-${idToSafePath(issueId)}.job.json`);
+  return join14(fifonyDir, `agent-${idToSafePath(issueId)}.job.json`);
 }
 function agentLogPath(workspacePath) {
-  return join13(workspacePath, "live-output.log");
+  return join14(workspacePath, "live-output.log");
 }
 function readJobState(fifonyDir, issueId) {
   const path = jobStatePath(fifonyDir, issueId);
-  if (!existsSync6(path)) return null;
+  if (!existsSync7(path)) return null;
   try {
-    return JSON.parse(readFileSync5(path, "utf8"));
+    return JSON.parse(readFileSync6(path, "utf8"));
   } catch {
     return null;
   }
@@ -4630,7 +4862,7 @@ function getAgentStatus(fifonyDir, issueId, identifier) {
   let pid = null;
   let actualState = job.state;
   if (job.state === "running" || job.state === "preparing") {
-    if (job.workspacePath && existsSync6(job.workspacePath)) {
+    if (job.workspacePath && existsSync7(job.workspacePath)) {
       const pidInfo = readAgentPid(job.workspacePath);
       if (pidInfo && isProcessAlive(pidInfo.pid)) {
         pid = pidInfo.pid;
@@ -4734,7 +4966,7 @@ function buildReplanFailureContext(issue) {
 async function runPlanPhase(state, issue, fifonyDir = STATE_ROOT, onTransition) {
   const _op = deriveAgentOperation(issue);
   const safeId = idToSafePath(issue.id);
-  const workspaceDir = join13(WORKSPACE_ROOT, safeId);
+  const workspaceDir = join14(WORKSPACE_ROOT, safeId);
   const _job = {
     issueId: issue.id,
     identifier: issue.identifier,
@@ -4757,7 +4989,7 @@ async function runPlanPhase(state, issue, fifonyDir = STATE_ROOT, onTransition)
   issue.planningError = void 0;
   issue.updatedAt = now();
   markIssueDirty(issue.id);
-  import("./store-M6NCKMZY.js").then(({ persistState: persistState2 }) => persistState2(state).catch(() => {
+  import("./store-S3NAYZ3S.js").then(({ persistState: persistState2 }) => persistState2(state).catch(() => {
   })).catch(() => {
   });
   mkdirSync7(workspaceDir, { recursive: true });
@@ -4785,12 +5017,16 @@ async function runPlanPhase(state, issue, fifonyDir = STATE_ROOT, onTransition)
     if (failureContext) {
       addEvent(state, issue.id, "info", `Injecting replan failure context into plan prompt (v${issue.planVersion ?? 1}).`);
     }
+    const fast = shouldUseFastMode(issue);
+    if (fast) {
+      addEvent(state, issue.id, "info", `Fast mode activated for ${issue.identifier} (type: ${issue.issueType ?? "unset"}, desc length: ${(issue.description ?? "").length}).`);
+    }
     const { plan, usage, prompt } = await generatePlan(
       issue.title,
       issue.description,
       state.config,
       null,
-      { persistSession: false, failureContext }
+      { fast, persistSession: false, failureContext }
     );
     const plannedIssue = {
       ...issue,
@@ -4856,7 +5092,7 @@ async function runPlanPhase(state, issue, fifonyDir = STATE_ROOT, onTransition)
     issue.plan = plan;
     issue.planVersion = Math.max(issue.planVersion ?? 0, 1);
     try {
-      const { savePlanForIssue: savePlanForIssue2 } = await import("./store-M6NCKMZY.js");
+      const { savePlanForIssue: savePlanForIssue2 } = await import("./store-S3NAYZ3S.js");
       await savePlanForIssue2(issue.id, plan, issue.planVersion);
       logger.debug({ issueId: issue.id, planVersion: issue.planVersion }, "[AgentFSM] Plan saved to issue_plans resource");
     } catch (err) {
@@ -4874,8 +5110,8 @@ async function runPlanPhase(state, issue, fifonyDir = STATE_ROOT, onTransition)
     }
     const pv = issue.planVersion;
     try {
-      writeFileSync9(join13(workspaceDir, `plan.v${pv}.json`), JSON.stringify(plan, null, 2), "utf8");
-      writeFileSync9(join13(workspaceDir, `plan.v${pv}.prompt.md`), prompt, "utf8");
+      writeFileSync9(join14(workspaceDir, `plan.v${pv}.json`), JSON.stringify(plan, null, 2), "utf8");
+      writeFileSync9(join14(workspaceDir, `plan.v${pv}.prompt.md`), prompt, "utf8");
     } catch (artifactErr) {
       logger.warn({ err: String(artifactErr) }, "[AgentFSM] Failed to write versioned plan artifacts");
     }
@@ -4895,8 +5131,21 @@ async function runPlanPhase(state, issue, fifonyDir = STATE_ROOT, onTransition)
       logger.warn({ issueId: issue.id, identifier: issue.identifier }, "[AgentFSM] Plan job completed for stale issue reference \u2014 skipping PLANNED transition");
     } else {
       try {
-        const { transitionIssue: transitionIssue2 } = await import("./issues-3QRR7KM6.js");
+        const { transitionIssue: transitionIssue2 } = await import("./issues-3YNNTB4U.js");
         await transitionIssue2(issue, "PLANNED", { issue });
+        if (state.config.autoApproveTrivialPlans !== false) {
+          const complexity = issue.plan?.estimatedComplexity;
+          if (complexity === "trivial" || complexity === "low") {
+            try {
+              await transitionIssueCommand(
+                { issue, target: "Queued", note: `Auto-approved ${complexity} plan for ${issue.identifier}.` }
+              );
+              addEvent(state, issue.id, "info", `Auto-approved ${complexity} plan for ${issue.identifier}.`);
+            } catch (autoErr) {
+              logger.warn({ err: autoErr, issueId: issue.id }, "[AgentFSM] Auto-approve failed, staying in PendingApproval");
+            }
+          }
+        }
       } catch (transErr) {
         logger.warn({ err: transErr, issueId: issue.id }, "[AgentFSM] PLANNED transition failed after plan generation");
       }
@@ -4915,13 +5164,19 @@ async function runPlanPhase(state, issue, fifonyDir = STATE_ROOT, onTransition)
   }
 }
 function extractGradingReport(text) {
-  const match = text.match(/```json grading_report\n([\s\S]+?)```/);
-  if (!match) return null;
-  try {
-    return JSON.parse(match[1]);
-  } catch {
-    return null;
+  const candidates = [text];
+  const envelopeResult = extractJsonEnvelopeResult(text);
+  if (envelopeResult) candidates.push(envelopeResult);
+  for (const candidate of candidates) {
+    const match = candidate.match(/```json grading_report\n([\s\S]+?)```/);
+    if (!match) continue;
+    try {
+      return JSON.parse(match[1]);
+    } catch {
+      continue;
+    }
   }
+  return null;
 }
 function buildGradingFailureSummary(report, failureScope = "all") {
   const failed = report.criteria.filter((c) => c.result === "FAIL" && (failureScope === "all" || c.blocking));
@@ -4931,10 +5186,21 @@ function buildGradingFailureSummary(report, failureScope = "all") {
 function resolveHarnessMode(issue) {
   return issue.plan?.harnessMode ?? "standard";
 }
+var COMPLEXITY_TURN_FACTOR = {
+  trivial: 0.3,
+  // solo 10 → 3, standard 20 → 6
+  low: 0.5,
+  // solo 10 → 5, standard 20 → 10
+  medium: 1,
+  high: 1
+};
 function resolveMaxTurns(issue, config) {
   if (config.maxTurns) return config.maxTurns;
   const mode = resolveHarnessMode(issue);
-  return DEFAULT_MAX_TURNS_BY_MODE[mode] ?? DEFAULT_MAX_TURNS;
+  const base = DEFAULT_MAX_TURNS_BY_MODE[mode] ?? DEFAULT_MAX_TURNS;
+  const complexity = issue.plan?.estimatedComplexity;
+  const factor = (complexity && COMPLEXITY_TURN_FACTOR[complexity]) ?? 1;
+  return Math.max(3, Math.round(base * factor));
 }
 function requiresCheckpointReview(issue) {
   return resolveHarnessMode(issue) === "contractual" && issue.plan?.executionContract?.checkpointPolicy === "checkpointed" && !issue.checkpointPassedAt;
@@ -5003,16 +5269,21 @@ async function finalizeReviewSuccess(state, issue, container, completionNote) {
   issue.mergedReason = autoReviewApproval ? completionNote : `${completionNote} Waiting for manual approval.`;
   await sendIssueToManualDecisionCommand(issue, completionNote, container);
   if (!autoReviewApproval) return;
-  const validation = await runValidationGate(issue, state.config);
-  if (validation) {
-    issue.validationResult = validation;
-    markIssueDirty(issue.id);
-    if (!validation.passed) {
-      addEvent(state, issue.id, "error", `Validation gate failed for ${issue.identifier}: ${validation.command}`);
-      logger.warn({ issueId: issue.id, command: validation.command }, "[AgentFSM] Validation gate failed after successful review path");
-      return;
+  const preReviewAlreadyPassed = issue.preReviewValidation?.passed === true;
+  if (preReviewAlreadyPassed) {
+    addEvent(state, issue.id, "info", `Post-approval validation skipped for ${issue.identifier}: pre-review gate already passed.`);
+  } else {
+    const validation = await runValidationGate(issue, state.config);
+    if (validation) {
+      issue.validationResult = validation;
+      markIssueDirty(issue.id);
+      if (!validation.passed) {
+        addEvent(state, issue.id, "error", `Validation gate failed for ${issue.identifier}: ${validation.command}`);
+        logger.warn({ issueId: issue.id, command: validation.command }, "[AgentFSM] Validation gate failed after successful review path");
+        return;
+      }
+      addEvent(state, issue.id, "info", `Validation gate passed for ${issue.identifier}.`);
     }
-    addEvent(state, issue.id, "info", `Validation gate passed for ${issue.identifier}.`);
   }
   await approveIssueAfterReviewCommand(issue, completionNote, container);
 }
@@ -5028,8 +5299,8 @@ function ensurePlaywrightMcpConfig(stateRoot) {
   } catch {
     return null;
   }
-  const configPath = join13(stateRoot, "playwright-mcp.json");
-  if (!existsSync6(configPath)) {
+  const configPath = join14(stateRoot, "playwright-mcp.json");
+  if (!existsSync7(configPath)) {
     try {
       writeFileSync9(configPath, JSON.stringify({
         mcpServers: {
@@ -5054,7 +5325,7 @@ function resolveReviewArtifactPrefix(issue, scope) {
   return `${scope}.v${planVersion}a${attempt}`;
 }
 function resolveReviewPromptPath(workspacePath, scope) {
-  return join13(workspacePath, scope === "checkpoint" ? "checkpoint-review-prompt.md" : "review-prompt.md");
+  return join14(workspacePath, scope === "checkpoint" ? "checkpoint-review-prompt.md" : "review-prompt.md");
 }
 function resolveReviewRunId(issue, scope) {
   return `review.${resolveReviewArtifactPrefix(issue, scope)}`;
@@ -5248,13 +5519,17 @@ async function runScopedReviewEvaluation(state, issue, workspacePath, reviewer,
     issue.commandExitCode = reviewResult.code;
     issue.commandOutputTail = reviewResult.output;
     const rawGradingReport = extractGradingReport(reviewResult.output);
-    const gradingReport = rawGradingReport ? applyHarnessReviewPolicy(issue, rawGradingReport, scope) : resolveHarnessMode(issue) === "contractual" ? applyHarnessReviewPolicy(issue, {
+    const isReviewerCrash = !rawGradingReport && !reviewResult.success && resolveHarnessMode(issue) === "contractual";
+    const gradingReport = rawGradingReport ? applyHarnessReviewPolicy(issue, rawGradingReport, scope) : resolveHarnessMode(issue) === "contractual" && !isReviewerCrash ? applyHarnessReviewPolicy(issue, {
       scope,
       overallVerdict: "FAIL",
       blockingVerdict: "FAIL",
       reviewAttempt: resolveReviewAttemptNumber(issue, scope),
       criteria: []
     }, scope) : null;
+    if (isReviewerCrash) {
+      addEvent(state, issue.id, "error", `Reviewer crashed or produced no grading report for ${issue.identifier}. Treating as infrastructure failure, not code quality FAIL.`);
+    }
     if (gradingReport) {
       gradingReport.scope = scope;
       gradingReport.reviewAttempt = resolveReviewAttemptNumber(issue, scope);
@@ -5271,12 +5546,12 @@ async function runScopedReviewEvaluation(state, issue, workspacePath, reviewer,
     try {
       const artifactPrefix = resolveReviewArtifactPrefix(issue, scope);
       const reviewPromptSrc = resolveReviewPromptPath(workspacePath, scope);
-      const reviewAuditSrc = join13(workspacePath, "execution-audit.json");
-      if (existsSync6(reviewPromptSrc)) {
-        writeFileSync9(join13(workspacePath, `${artifactPrefix}.prompt.md`), readFileSync5(reviewPromptSrc, "utf8"), "utf8");
+      const reviewAuditSrc = join14(workspacePath, "execution-audit.json");
+      if (existsSync7(reviewPromptSrc)) {
+        writeFileSync9(join14(workspacePath, `${artifactPrefix}.prompt.md`), readFileSync6(reviewPromptSrc, "utf8"), "utf8");
       }
-      if (existsSync6(reviewAuditSrc)) {
-        writeFileSync9(join13(workspacePath, `${artifactPrefix}.audit.json`), readFileSync5(reviewAuditSrc, "utf8"), "utf8");
+      if (existsSync7(reviewAuditSrc)) {
+        writeFileSync9(join14(workspacePath, `${artifactPrefix}.audit.json`), readFileSync6(reviewAuditSrc, "utf8"), "utf8");
       }
     } catch (vErr) {
       logger.warn({ err: String(vErr), scope }, "[AgentFSM] Failed to write versioned review artifacts");
@@ -5413,7 +5688,7 @@ async function runCheckpointReviewOnce(state, issue, workspacePath, reviewer) {
         "runner",
         `Auto-replan triggered for ${issue.identifier}: checkpoint is failing on the same blocking criteria repeatedly.`
       );
-      const { replanIssueCommand: replanIssueCommand2 } = await import("./replan-issue.command-4UCWYHGZ.js");
+      const { replanIssueCommand: replanIssueCommand2 } = await import("./replan-issue.command-2GQ3QXCR.js");
       await replanIssueCommand2({ issue }, container);
       return "replanned";
     }
@@ -5467,6 +5742,17 @@ async function runReviewOnce(state, issue, workspacePath, reviewer) {
     );
     return;
   }
+  const complexity = issue.plan?.estimatedComplexity;
+  if (harnessMode === "standard" && complexity === "trivial") {
+    addEvent(state, issue.id, "info", `Trivial complexity for ${issue.identifier} \u2014 skipping review, validation gate is sufficient.`);
+    await finalizeReviewSuccess(
+      state,
+      issue,
+      container,
+      `Trivial issue ${issue.identifier} auto-approved; validation gate passed.`
+    );
+    return;
+  }
   if (!reviewer) {
     if (harnessMode === "contractual") {
       issue.mergedReason = "Contractual harness requires review evidence; manual review required.";
@@ -5535,7 +5821,7 @@ async function runReviewOnce(state, issue, workspacePath, reviewer) {
       "runner",
       `Auto-replan triggered for ${issue.identifier}: final review is failing on the same blocking criteria repeatedly.`
     );
-    const { replanIssueCommand: replanIssueCommand2 } = await import("./replan-issue.command-4UCWYHGZ.js");
+    const { replanIssueCommand: replanIssueCommand2 } = await import("./replan-issue.command-2GQ3QXCR.js");
     await replanIssueCommand2({ issue }, container);
     return;
   }
@@ -5587,8 +5873,7 @@ async function runReviewOnce(state, issue, workspacePath, reviewer) {
     issue.lastFailedPhase = "review";
     issue.attempts += 1;
     if (issue.attempts >= issue.maxAttempts) {
-      issue.cancelledReason = `Max attempts reached (${issue.attempts}/${issue.maxAttempts}): reviewer failed or blocked.`;
-      await cancelIssueFromAgentCommand(issue, `Review failed, max attempts reached for ${issue.identifier}.`, container);
+      await blockIssueForRetryCommand(issue, `Review failed \u2014 max attempts reached (${issue.attempts}/${issue.maxAttempts}) for ${issue.identifier}. Manual intervention required.`, container);
     } else {
       issue.nextRetryAt = getNextRetryAt(issue, state.config.retryDelayMs);
       await blockIssueForRetryCommand(issue, `Review failed for ${issue.identifier}. Retry at ${issue.nextRetryAt}.`, container);
@@ -5626,13 +5911,13 @@ async function runExecuteOnce(state, issue, workspacePath, promptText, promptFil
       try {
         const epv = issue.planVersion ?? 1;
         const eea = issue.executeAttempt ?? 1;
-        const vExecPromptSrc = join13(workspacePath, "prompt.md");
-        const vExecAuditSrc = join13(workspacePath, "execution-audit.json");
-        if (existsSync6(vExecPromptSrc)) {
-          writeFileSync9(join13(workspacePath, `execute.v${epv}a${eea}.prompt.md`), readFileSync5(vExecPromptSrc, "utf8"), "utf8");
+        const vExecPromptSrc = join14(workspacePath, "prompt.md");
+        const vExecAuditSrc = join14(workspacePath, "execution-audit.json");
+        if (existsSync7(vExecPromptSrc)) {
+          writeFileSync9(join14(workspacePath, `execute.v${epv}a${eea}.prompt.md`), readFileSync6(vExecPromptSrc, "utf8"), "utf8");
         }
-        if (existsSync6(vExecAuditSrc)) {
-          writeFileSync9(join13(workspacePath, `execute.v${epv}a${eea}.audit.json`), readFileSync5(vExecAuditSrc, "utf8"), "utf8");
+        if (existsSync7(vExecAuditSrc)) {
+          writeFileSync9(join14(workspacePath, `execute.v${epv}a${eea}.audit.json`), readFileSync6(vExecAuditSrc, "utf8"), "utf8");
         }
       } catch (vErr) {
         logger.warn({ err: String(vErr) }, "[AgentFSM] Failed to write versioned execute artifacts");
@@ -5657,8 +5942,7 @@ ${preReviewValidation.output}`;
         issue.lastFailedPhase = "execute";
         issue.attempts += 1;
         if (issue.attempts >= issue.maxAttempts) {
-          issue.cancelledReason = `Max attempts reached: pre-review gate failed repeatedly.`;
-          await cancelIssueFromAgentCommand(issue, `Max attempts reached (${issue.attempts}/${issue.maxAttempts}): pre-review gate failed.`, container);
+          await blockIssueForRetryCommand(issue, `Pre-review validation gate failed \u2014 max attempts reached (${issue.attempts}/${issue.maxAttempts}). Manual intervention required.`, container);
         } else {
           issue.nextRetryAt = getNextRetryAt(issue, state.config.retryDelayMs);
           await blockIssueForRetryCommand(issue, `Pre-review validation gate failed on attempt ${issue.attempts}/${issue.maxAttempts}. Retry scheduled at ${issue.nextRetryAt}.`, container);
@@ -5698,15 +5982,14 @@ ${preReviewValidation.output}`;
           "runner",
           `Auto-replan: "${currentInsight.errorType}" repeated ${stallThreshold}\xD7 \u2014 replanning to break the loop.`
         );
-        const { replanIssueCommand: replanIssueCommand2 } = await import("./replan-issue.command-4UCWYHGZ.js");
+        const { replanIssueCommand: replanIssueCommand2 } = await import("./replan-issue.command-2GQ3QXCR.js");
         await replanIssueCommand2({ issue }, container);
         return;
       }
     }
     if (issue.attempts >= issue.maxAttempts) {
       issue.commandExitCode = runResult.code;
-      issue.cancelledReason = `Max attempts reached (${issue.attempts}/${issue.maxAttempts}): execution failed repeatedly.`;
-      await cancelIssueFromAgentCommand(issue, `Max attempts reached (${issue.attempts}/${issue.maxAttempts}).`, container);
+      await blockIssueForRetryCommand(issue, `Execution failed \u2014 max attempts reached (${issue.attempts}/${issue.maxAttempts}). Manual intervention required.`, container);
     } else {
       issue.nextRetryAt = getNextRetryAt(issue, state.config.retryDelayMs);
       await blockIssueForRetryCommand(issue, `${runResult.blocked ? "Agent requested manual intervention" : "Failure"} on attempt ${issue.attempts}/${issue.maxAttempts}; retry scheduled at ${issue.nextRetryAt}.`, container);
@@ -5717,7 +6000,7 @@ async function runReviewPhase(state, issue, running2, fifonyDir = STATE_ROOT, on
   const startTs = Date.now();
   logger.info({ issueId: issue.id, identifier: issue.identifier, state: issue.state, attempt: issue.attempts + 1 }, "[AgentFSM] Review phase starting");
   const _op = deriveAgentOperation(issue);
-  const _workspacePath = issue.workspacePath ?? join13(WORKSPACE_ROOT, idToSafePath(issue.id));
+  const _workspacePath = issue.workspacePath ?? join14(WORKSPACE_ROOT, idToSafePath(issue.id));
   writeJobState(fifonyDir, {
     issueId: issue.id,
     identifier: issue.identifier,
@@ -5752,7 +6035,7 @@ async function runReviewPhase(state, issue, running2, fifonyDir = STATE_ROOT, on
     const { workspacePath } = await prepareWorkspace(issue, state, state.config.defaultBranch);
     container.issueRepository.markDirty(issue.id);
     container.eventStore.addEvent(issue.id, "info", `Workspace ready at ${workspacePath}.`);
-    const { startIssueLogBroadcasting: _startReviewLog } = await import("./issue-log-broadcaster-WZAHISYB.js");
+    const { startIssueLogBroadcasting: _startReviewLog } = await import("./issue-log-broadcaster-FZGVEEIX.js");
     _startReviewLog(issue.id, workspacePath);
     const reviewer = getReviewProvider(state, issue, workflowConfig);
     if (state.config.enablePlaywrightReview && hasFrontendChanges(issue, "")) {
@@ -5777,8 +6060,7 @@ async function runReviewPhase(state, issue, running2, fifonyDir = STATE_ROOT, on
     issue.lastError = String(error);
     issue.lastFailedPhase = "review";
     if (issue.attempts >= issue.maxAttempts) {
-      issue.cancelledReason = `Max attempts reached (${issue.attempts}/${issue.maxAttempts}): unexpected failure \u2014 ${issue.lastError?.slice(0, 120) ?? "unknown error"}.`;
-      await cancelIssueFromAgentCommand(issue, `Issue failed unexpectedly: ${issue.lastError}`, container);
+      await blockIssueForRetryCommand(issue, `Unexpected failure \u2014 max attempts reached (${issue.attempts}/${issue.maxAttempts}): ${issue.lastError?.slice(0, 120) ?? "unknown error"}. Manual intervention required.`, container);
     } else {
       issue.nextRetryAt = getNextRetryAt(issue, state.config.retryDelayMs);
       await blockIssueForRetryCommand(issue, `Unexpected failure. Retry scheduled at ${issue.nextRetryAt}.`, container);
@@ -5794,15 +6076,15 @@ async function runReviewPhase(state, issue, running2, fifonyDir = STATE_ROOT, on
     await container.persistencePort.persistState(state);
     cleanAgentJobState(fifonyDir, issue.id);
     onTransition?.({ issueId: issue.id, identifier: issue.identifier, operation: _op, from: "running", to: "done", pid: null, reason: "review phase complete", at: now() });
-    import("./issue-log-broadcaster-WZAHISYB.js").then(({ stopIssueLogBroadcasting }) => stopIssueLogBroadcasting(issue.id)).catch(() => {
+    import("./issue-log-broadcaster-FZGVEEIX.js").then(({ stopIssueLogBroadcasting }) => stopIssueLogBroadcasting(issue.id)).catch(() => {
     });
   }
 }
-async function runExecutePhase(state, issue, running2, active3, getCurrentIssue2, fifonyDir = STATE_ROOT, onTransition) {
+async function runExecutePhase(state, issue, running2, active2, getCurrentIssue2, fifonyDir = STATE_ROOT, onTransition) {
   const startTs = Date.now();
   logger.info({ issueId: issue.id, identifier: issue.identifier, state: issue.state, attempt: issue.attempts + 1 }, "[AgentFSM] Execute phase starting");
   const _op = deriveAgentOperation(issue);
-  const _initWorkspacePath = issue.workspacePath ?? join13(WORKSPACE_ROOT, idToSafePath(issue.id));
+  const _initWorkspacePath = issue.workspacePath ?? join14(WORKSPACE_ROOT, idToSafePath(issue.id));
   const _jobInit = {
     issueId: issue.id,
     identifier: issue.identifier,
@@ -5841,7 +6123,7 @@ async function runExecutePhase(state, issue, running2, active3, getCurrentIssue2
   }
   let current = issue;
   try {
-    while (active3() && current) {
+    while (active2() && current) {
       if (current.state !== "Queued" && current.state !== "Running") break;
       const workspaceDerivedPaths = hydrateIssuePathsFromWorkspace(current);
       void workspaceDerivedPaths;
@@ -5850,7 +6132,7 @@ async function runExecutePhase(state, issue, running2, active3, getCurrentIssue2
       const _turnNum = (readJobState(fifonyDir, issue.id)?.turn ?? 0) + 1;
       writeJobState(fifonyDir, { ..._jobInit, workspacePath, logFile: agentLogPath(workspacePath), state: "running", turn: _turnNum, updatedAt: now() });
       try {
-        const { getIssueStateResource: getIssueStateResource2 } = await import("./store-M6NCKMZY.js");
+        const { getIssueStateResource: getIssueStateResource2 } = await import("./store-S3NAYZ3S.js");
         const res = getIssueStateResource2();
         if (res) {
           await res.patch(current.id, {
@@ -5863,7 +6145,7 @@ async function runExecutePhase(state, issue, running2, active3, getCurrentIssue2
       } catch {
       }
       container.eventStore.addEvent(current.id, "info", `Workspace ready at ${workspacePath}.`);
-      const { startIssueLogBroadcasting } = await import("./issue-log-broadcaster-WZAHISYB.js");
+      const { startIssueLogBroadcasting } = await import("./issue-log-broadcaster-FZGVEEIX.js");
       startIssueLogBroadcasting(current.id, workspacePath);
       const executeProviders = getExecutionProviders(state, current, workflowConfig);
       const reviewer = getReviewProvider(state, current, workflowConfig);
@@ -5876,8 +6158,7 @@ async function runExecutePhase(state, issue, running2, active3, getCurrentIssue2
     target.lastError = String(error);
     target.lastFailedPhase = target.lastFailedPhase ?? "execute";
     if (target.attempts >= target.maxAttempts) {
-      target.cancelledReason = `Max attempts reached (${target.attempts}/${target.maxAttempts}): unexpected failure \u2014 ${target.lastError?.slice(0, 120) ?? "unknown error"}.`;
-      await cancelIssueFromAgentCommand(target, `Issue failed unexpectedly: ${target.lastError}`, container);
+      await blockIssueForRetryCommand(target, `Unexpected failure \u2014 max attempts reached (${target.attempts}/${target.maxAttempts}): ${target.lastError?.slice(0, 120) ?? "unknown error"}. Manual intervention required.`, container);
     } else {
       target.nextRetryAt = getNextRetryAt(target, state.config.retryDelayMs);
       await blockIssueForRetryCommand(target, `Unexpected failure. Retry scheduled at ${target.nextRetryAt}.`, container);
@@ -5894,7 +6175,7 @@ async function runExecutePhase(state, issue, running2, active3, getCurrentIssue2
     await container.persistencePort.persistState(state);
     cleanAgentJobState(fifonyDir, issue.id);
     onTransition?.({ issueId: issue.id, identifier: issue.identifier, operation: _op, from: "running", to: "done", pid: null, reason: "execute phase complete", at: now() });
-    import("./issue-log-broadcaster-WZAHISYB.js").then(({ stopIssueLogBroadcasting }) => stopIssueLogBroadcasting(issue.id)).catch(() => {
+    import("./issue-log-broadcaster-FZGVEEIX.js").then(({ stopIssueLogBroadcasting }) => stopIssueLogBroadcasting(issue.id)).catch(() => {
     });
   }
 }
@@ -5903,7 +6184,7 @@ function tickOneAgent(issue, fifonyDir) {
   if (!job) return null;
   if (job.state === "done" || job.state === "failed" || job.state === "idle" || job.state === "crashed") return null;
   if (job.state === "running" || job.state === "preparing") {
-    if (!job.workspacePath || !existsSync6(job.workspacePath)) return null;
+    if (!job.workspacePath || !existsSync7(job.workspacePath)) return null;
     const pidInfo = readAgentPid(job.workspacePath);
     const alive = pidInfo ? isProcessAlive(pidInfo.pid) : false;
     if (!alive && pidInfo) {
@@ -5953,7 +6234,7 @@ function reconcileAgentStates(issues, fifonyDir) {
     if (!job) continue;
     if (job.state === "done" || job.state === "failed" || job.state === "idle" || job.state === "crashed") continue;
     if (job.state === "running" || job.state === "preparing") {
-      const pidInfo = job.workspacePath && existsSync6(job.workspacePath) ? readAgentPid(job.workspacePath) : null;
+      const pidInfo = job.workspacePath && existsSync7(job.workspacePath) ? readAgentPid(job.workspacePath) : null;
       const alive = pidInfo ? isProcessAlive(pidInfo.pid) : false;
       if (!alive) {
         const crashCount = (job.crashCount ?? 0) + 1;
@@ -5977,10 +6258,10 @@ function reconcileAgentStates(issues, fifonyDir) {
 
 // src/agents/handoff-writer.ts
 import { writeFileSync as writeFileSync10 } from "fs";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 import { execSync as execSync2 } from "child_process";
 function writeHandoffArtifact(workspacePath, issue, lastOutput, nextPrompt) {
-  const handoffPath = join14(workspacePath, "handoff.md");
+  const handoffPath = join15(workspacePath, "handoff.md");
   let diffStat = "";
   try {
     diffStat = execSync2("git diff --stat HEAD", { cwd: workspacePath, timeout: 5e3 }).toString().trim();
@@ -6052,7 +6333,7 @@ async function runAgentSession(state, issue, provider, cycle, workspacePath, bas
   let nextPrompt = session.nextPrompt;
   let lastCode = session.lastCode;
   let lastOutput = session.lastOutput;
-  const resultFile = join15(workspacePath, `result-${provider.role}-${provider.provider}.json`);
+  const resultFile = join16(workspacePath, `result-${provider.role}-${provider.provider}.json`);
   if (session.status === "done" && session.turns.length > 0) {
     logger.debug({ issueId: issue.id, identifier: issue.identifier, provider: provider.provider, role: provider.role }, "[Agent] Session already completed, returning cached result");
     return { success: true, blocked: false, continueRequested: false, code: session.lastCode, output: session.lastOutput, turns: session.turns.length };
@@ -6102,7 +6383,7 @@ ${previousOutput.slice(-maxOutputChars)}` : previousOutput;
 
 ${basePromptText}` : basePromptText;
   const turnPrompt = await buildTurnPrompt(issue, effectiveBasePrompt, compactedOutput, turnIndex, maxTurns, nextPrompt);
-  const turnPromptFile = turnIndex === 1 ? basePromptFile : join15(workspacePath, `turn-${String(turnIndex).padStart(2, "0")}.md`);
+  const turnPromptFile = turnIndex === 1 ? basePromptFile : join16(workspacePath, `turn-${String(turnIndex).padStart(2, "0")}.md`);
   if (turnIndex > 1) writeFileSync11(turnPromptFile, `${turnPrompt}
 `, "utf8");
   session.status = "running";
@@ -6110,7 +6391,7 @@ ${basePromptText}` : basePromptText;
   session.lastPromptFile = turnPromptFile;
   session.maxTurns = maxTurns;
   await persistAgentSessionState(sessionKey, issue, provider, cycle, session);
-  const outputsDir = join15(workspacePath, "outputs");
+  const outputsDir = join16(workspacePath, "outputs");
   mkdirSync8(outputsDir, { recursive: true });
   const outputFileName = resolveOutputFileName(
     provider.role,
@@ -6118,7 +6399,7 @@ ${basePromptText}` : basePromptText;
     provider.role === "planner" ? 0 : issue.executeAttempt ?? 1,
     turnIndex
   );
-  const outputFilePath = join15(outputsDir, outputFileName);
+  const outputFilePath = join16(outputsDir, outputFileName);
   logger.info({ issueId: issue.id, identifier: issue.identifier, turn: turnIndex, maxTurns, provider: provider.provider, role: provider.role, cycle, command: provider.command.slice(0, 120) }, "[Agent] Spawning agent command");
   const turnStartedAt = now();
   const turnEnv = {
@@ -6289,7 +6570,7 @@ async function runAgentPipeline(state, issue, workspacePath, basePromptText, bas
   const commands = discoverCommands(workspacePath);
   const capabilitiesManifest = buildCapabilitiesManifest(skills, agents, commands);
   if (skillContext) {
-    writeFileSync11(join15(workspacePath, "skills.md"), skillContext, "utf8");
+    writeFileSync11(join16(workspacePath, "skills.md"), skillContext, "utf8");
   }
   const compiled = await compileExecution(issue, activeProvider, state.config, workspacePath, skillContext, capabilitiesManifest);
   const blueprint = issue.plan ? buildHarnessBlueprint(issue.plan, state.config) : null;
@@ -6314,7 +6595,7 @@ async function runAgentPipeline(state, issue, workspacePath, basePromptText, bas
       `Plan compiled for ${compiled.meta.adapter}: effort=${compiled.meta.reasoningEffort}, skills=[${compiled.meta.skillsActivated.join(",")}], subagents=[${compiled.meta.subagentsRequested.join(",")}].`
     );
     if (Object.keys(compiled.env).length > 0) {
-      const envFile = join15(workspacePath, ".compiled-env.sh");
+      const envFile = join16(workspacePath, ".compiled-env.sh");
       const envLines = Object.entries(compiled.env).map(([k, v]) => `export ${k}=${JSON.stringify(v)}`).join("\n");
       writeFileSync11(envFile, envLines, "utf8");
     }
@@ -6353,9 +6634,9 @@ ${retryCtx}`;
     }
   }
   if (issue.lastHandoffFile && (issue.contextResetCount ?? 0) > 0) {
-    const { readFileSync: readFileSync15, existsSync: existsSync19 } = await import("fs");
-    if (existsSync19(issue.lastHandoffFile)) {
-      const handoffContent = readFileSync15(issue.lastHandoffFile, "utf8");
+    const { readFileSync: readFileSync18, existsSync: existsSync20 } = await import("fs");
+    if (existsSync20(issue.lastHandoffFile)) {
+      const handoffContent = readFileSync18(issue.lastHandoffFile, "utf8");
       providerPrompt = `## Context Reset \u2014 Prior Session Summary
 
 ${handoffContent}
@@ -6442,7 +6723,7 @@ ${providerPrompt}`;
   }
   let parallelExecuted = false;
   if (issue.plan?.executionContract?.parallelSubTasks && issue.plan.executionContract.parallelSubTasks.length >= 2) {
-    const { spawnParallelSubTasks } = await import("./parallel-executor-6INE6NDO.js");
+    const { spawnParallelSubTasks } = await import("./parallel-executor-DWESCNX3.js");
     const parallelSuccess = await spawnParallelSubTasks(state, issue, effectiveProvider, pipeline.cycle, providerPrompt, basePromptFile);
     parallelExecuted = true;
     if (!parallelSuccess) {
@@ -6632,19 +6913,19 @@ function issueHasResumableSession(issue) {
 }
 
 // src/commands/create-issue.command.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync9, renameSync } from "fs";
-import { basename as basename2, join as join16 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync9, renameSync } from "fs";
+import { basename as basename2, join as join17 } from "path";
 async function createIssueCommand(input, deps) {
   const { payload, state } = input;
   const issue = createIssueFromPayload(payload, state.issues, state.config.defaultBranch);
   const tempImages = Array.isArray(payload.images) ? payload.images : [];
   if (tempImages.length) {
-    const issueAttachDir = join16(ATTACHMENTS_ROOT, issue.id);
+    const issueAttachDir = join17(ATTACHMENTS_ROOT, issue.id);
     mkdirSync9(issueAttachDir, { recursive: true });
     const finalPaths = [];
     for (const tempPath of tempImages) {
-      if (typeof tempPath === "string" && existsSync7(tempPath)) {
-        const dest = join16(issueAttachDir, basename2(tempPath));
+      if (typeof tempPath === "string" && existsSync8(tempPath)) {
+        const dest = join17(issueAttachDir, basename2(tempPath));
         try {
           renameSync(tempPath, dest);
           finalPaths.push(dest);
@@ -6747,13 +7028,13 @@ async function deleteIssueCommand(input) {
 }
 
 // src/commands/merge-workspace.command.ts
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { execSync as execSync4 } from "child_process";
 
 // src/domains/merge-conflict-resolver.ts
 import { execSync as execSync3 } from "child_process";
 import { mkdtempSync as mkdtempSync3, writeFileSync as writeFileSync12, rmSync as rmSync4 } from "fs";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 async function resolveConflictsWithAgent(options) {
   const { issue, conflictFiles, provider, model, targetRoot } = options;
@@ -6774,8 +7055,8 @@ async function resolveConflictsWithAgent(options) {
     featureBranch: issue.branchName || "unknown",
     conflictFiles
   });
-  const tempDir = mkdtempSync3(join17(tmpdir3(), "fifony-conflict-"));
-  const promptFile = join17(tempDir, "fifony-conflict-prompt.md");
+  const tempDir = mkdtempSync3(join18(tmpdir3(), "fifony-conflict-"));
+  const promptFile = join18(tempDir, "fifony-conflict-prompt.md");
   writeFileSync12(promptFile, `${prompt}
 `, "utf8");
   let output = "";
@@ -6854,7 +7135,7 @@ async function mergeWorkspaceCommand(input, deps) {
     );
   }
   const wp = issue.worktreePath ?? issue.workspacePath;
-  if (!wp || !existsSync8(wp)) {
+  if (!wp || !existsSync9(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) {
@@ -6894,13 +7175,32 @@ async function mergeWorkspaceCommand(input, deps) {
     }
   }
   let result;
-  const mergeResult = mergeWorkspace(
-    issue,
-    /* abortOnConflict */
-    false
-  );
-  result = mergeResult;
-  if (result.conflicts.length > 0) {
+  const autoCommit = state.config.autoCommitBeforeMerge ?? true;
+  const autoResolve = state.config.autoResolveConflicts ?? false;
+  try {
+    result = mergeWorkspace(
+      issue,
+      /* abortOnConflict */
+      !autoResolve,
+      autoCommit
+    );
+  } catch (mergeErr) {
+    const msg = mergeErr instanceof Error ? mergeErr.message : String(mergeErr);
+    if (msg.includes("uncommitted changes") && !autoCommit) {
+      issue.lastError = msg;
+      issue.lastFailedPhase = "merge";
+      deps.issueRepository.markDirty(issue.id);
+      deps.eventStore.addEvent(issue.id, "error", `Merge blocked: ${msg}`);
+      await transitionIssueCommand(
+        { issue, target: "Blocked", note: "Merge blocked by uncommitted changes in target repo. Enable 'Auto-commit before merge' or commit manually." },
+        deps
+      );
+      await deps.persistencePort.persistState(state);
+      return { copied: [], deleted: [], skipped: [], conflicts: [] };
+    }
+    throw mergeErr;
+  }
+  if (result.conflicts.length > 0 && autoResolve) {
     deps.eventStore.addEvent(issue.id, "info", `Merge conflicts in ${result.conflicts.length} file(s): ${result.conflicts.join(", ")}. Attempting agent-based resolution...`);
     logger.info({ issueId: issue.id, conflicts: result.conflicts }, "[Merge] Conflicts detected \u2014 spawning agent to resolve");
     try {
@@ -6990,7 +7290,17 @@ async function mergeWorkspaceCommand(input, deps) {
     ...issue.mergeResult?.conflictResolution ? { conflictResolution: issue.mergeResult.conflictResolution } : {}
   };
   if (result.conflicts.length > 0) {
-    deps.eventStore.addEvent(issue.id, "error", `Merge aborted \u2014 ${result.conflicts.length} conflict(s) remain: ${result.conflicts.join(", ")}`);
+    const conflictMsg = `Merge has ${result.conflicts.length} conflict(s): ${result.conflicts.join(", ")}`;
+    deps.eventStore.addEvent(issue.id, "error", conflictMsg);
+    if (!autoResolve) {
+      issue.lastError = conflictMsg;
+      issue.lastFailedPhase = "merge";
+      deps.issueRepository.markDirty(issue.id);
+      await transitionIssueCommand(
+        { issue, target: "Blocked", note: "Merge blocked by conflicts. Enable 'Auto-resolve conflicts' or resolve manually." },
+        deps
+      );
+    }
     await deps.persistencePort.persistState(state);
     return result;
   }
@@ -7012,10 +7322,10 @@ async function mergeWorkspaceCommand(input, deps) {
 }
 
 // src/commands/push-workspace.command.ts
-import { execFileSync as execFileSync2, execSync as execSync5 } from "child_process";
+import { execFileSync as execFileSync3, execSync as execSync5 } from "child_process";
 function isGhAvailable() {
   try {
-    execFileSync2("gh", ["--version"], { stdio: "pipe", timeout: 5e3 });
+    execFileSync3("gh", ["--version"], { stdio: "pipe", timeout: 5e3 });
     return true;
   } catch {
     return false;
@@ -7032,7 +7342,7 @@ function getCompareUrl(branchName, baseBranch) {
 }
 function findExistingPr(branchName) {
   try {
-    const result = execFileSync2(
+    const result = execFileSync3(
       "gh",
       ["pr", "view", branchName, "--json", "url,state", "--jq", 'select(.state == "OPEN") | .url'],
       { cwd: TARGET_ROOT, encoding: "utf8", stdio: "pipe", timeout: 15e3 }
@@ -7043,7 +7353,7 @@ function findExistingPr(branchName) {
   }
 }
 function createPr(branchName, baseBranch, title, body) {
-  return execFileSync2(
+  return execFileSync3(
     "gh",
     ["pr", "create", "--head", branchName, "--base", baseBranch, "--title", title, "--body", body],
     { cwd: TARGET_ROOT, encoding: "utf8", stdio: "pipe", timeout: 3e4 }
@@ -7124,118 +7434,20 @@ ${diffStat || "No diff stats available"}
   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.`
-    );
+// src/commands/execute-issue.command.ts
+async function executeIssueCommand(input, deps) {
+  const { issue } = input;
+  if (issue.state === "Queued" || issue.state === "Running") return;
+  if (issue.state !== "PendingApproval") {
+    throw new Error(`Cannot execute issue in state ${issue.state}. Must be in PendingApproval.`);
   }
+  assertPlanReadyForExecution(issue, "execute this issue");
+  ensureGitRepoReadyForWorktrees(TARGET_ROOT, "execute issues");
   await transitionIssueCommand(
-    { issue, target: "Queued", note: note ?? `Retry execution for ${issue.identifier} (attempt ${(issue.attempts ?? 0) + 1}).` },
+    { issue, target: "Queued", note: `Execution requested for ${issue.identifier}.` },
     deps
   );
-  deps.eventStore.addEvent(
-    issue.id,
-    "manual",
-    `Execution retry requested for ${issue.identifier} \u2014 re-queued from Blocked.`
-  );
-}
-
-// src/commands/retry-issue.command.ts
-async function retryIssueCommand(input, deps) {
-  const { issue, feedback } = input;
-  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 }, deps);
-    if (issue.plan?.steps?.length && getPlanExecutionBlocker(issue) === null) {
-      await transitionIssueCommand({ issue, target: "PendingApproval", note: "Existing plan found." }, deps);
-      await transitionIssueCommand({ issue, target: "Queued", note: "Auto-queued after plan approval." }, deps);
-    }
-    deps.eventStore.addEvent(issue.id, "manual", `Manual retry requested for ${issue.id}.`);
-    return;
-  }
-  if (issue.state === "Approved") {
-    await transitionIssueCommand({ issue, target: "Planning", note }, deps);
-    if (issue.plan?.steps?.length && getPlanExecutionBlocker(issue) === null) {
-      await transitionIssueCommand({ issue, target: "PendingApproval", note: "Existing plan found." }, deps);
-      await transitionIssueCommand({ issue, target: "Queued", note: "Auto-queued for rework." }, deps);
-    }
-    deps.eventStore.addEvent(issue.id, "manual", `Manual retry requested for ${issue.id}.`);
-    return;
-  }
-  if (issue.state === "Blocked" && issue.lastFailedPhase === "review") {
-    if (issue.checkpointStatus === "failed") {
-      await retryExecutionCommand({ issue, note }, deps);
-      return;
-    }
-    issue.lastError = void 0;
-    issue.lastFailedPhase = void 0;
-    await transitionIssueCommand({ issue, target: "Reviewing", note }, deps);
-    deps.eventStore.addEvent(issue.id, "manual", `Manual retry requested for ${issue.id}.`);
-    return;
-  }
-  if (issue.state === "Blocked") {
-    await retryExecutionCommand({ issue, note }, deps);
-    return;
-  }
-  if (issue.state === "Reviewing" || issue.state === "PendingDecision") {
-    await requestReworkCommand(
-      {
-        issue,
-        reviewerFeedback: feedback || issue.lastError || "Manual rework request.",
-        note: `Manual rework requested for ${issue.identifier}.`,
-        eventKind: "manual"
-      },
-      deps
-    );
-    return;
-  }
-  if (issue.state === "PendingApproval") {
-    assertPlanReadyForExecution(issue, "retry this issue");
-    await transitionIssueCommand({ issue, target: "Queued", note }, deps);
-    deps.eventStore.addEvent(issue.id, "manual", `Manual retry requested for ${issue.id}.`);
-    return;
-  }
-  issue.lastError = void 0;
-  issue.nextRetryAt = void 0;
-  issue.updatedAt = now();
-  deps.eventStore.addEvent(issue.id, "manual", `Manual retry requested for ${issue.id}.`);
-}
-
-// src/commands/approve-plan.command.ts
-async function approvePlanCommand(input, deps) {
-  const { issue } = input;
-  if (issue.state !== "Planning") {
-    throw new Error(`Cannot approve issue in state ${issue.state}. Must be in Planning.`);
-  }
-  assertPlanReadyForExecution(issue, "approve this plan");
-  ensureGitRepoReadyForWorktrees(TARGET_ROOT, "execute approved plans");
-  await transitionIssueCommand(
-    { issue, target: "PendingApproval", note: `Plan approved for ${issue.identifier}. Ready for execution.` },
-    deps
-  );
-  await transitionIssueCommand(
-    { issue, target: "Queued", note: `${issue.identifier} queued for execution after plan approval.` },
-    deps
-  );
-}
-
-// src/commands/execute-issue.command.ts
-async function executeIssueCommand(input, deps) {
-  const { issue } = input;
-  if (issue.state === "Queued" || issue.state === "Running") return;
-  if (issue.state !== "PendingApproval") {
-    throw new Error(`Cannot execute issue in state ${issue.state}. Must be in PendingApproval.`);
-  }
-  assertPlanReadyForExecution(issue, "execute this issue");
-  ensureGitRepoReadyForWorktrees(TARGET_ROOT, "execute issues");
-  await transitionIssueCommand(
-    { issue, target: "Queued", note: `Execution requested for ${issue.identifier}.` },
-    deps
-  );
-  deps.eventStore.addEvent(issue.id, "state", `Execute requested \u2014 ${issue.identifier} moved to Queued.`);
+  deps.eventStore.addEvent(issue.id, "state", `Execute requested \u2014 ${issue.identifier} moved to Queued.`);
 }
 
 // src/persistence/resources/issue-milestone.api.ts
@@ -7284,12 +7496,12 @@ async function assignIssueMilestoneForState(state, c, deps) {
 }
 
 // src/persistence/resources/issues.resource.ts
-import { closeSync, existsSync as existsSync9, mkdirSync as mkdirSync10, openSync, readFileSync as readFileSync6, readSync, readdirSync as readdirSync3, statSync as statSync2, writeFileSync as writeFileSync13 } from "fs";
+import { closeSync, existsSync as existsSync10, mkdirSync as mkdirSync10, openSync, readFileSync as readFileSync7, readSync, readdirSync as readdirSync4, statSync as statSync2, writeFileSync as writeFileSync13 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
-import { basename as basename3, extname as extname2, join as join18 } from "path";
+import { basename as basename3, extname as extname2, join as join19 } from "path";
 import { execSync as execSync6 } from "child_process";
 async function loadIssueApiDeps() {
-  const { persistState: persistState2 } = await import("./store-M6NCKMZY.js");
+  const { persistState: persistState2 } = await import("./store-S3NAYZ3S.js");
   return { persistState: persistState2 };
 }
 function respond(c, result, createdStatus) {
@@ -7345,7 +7557,7 @@ async function getIssueContext(c) {
 }
 async function patchIssueState(c) {
   const context2 = getApiRuntimeContextOrThrow();
-  const { persistState: persistState2 } = await import("./store-M6NCKMZY.js");
+  const { persistState: persistState2 } = await import("./store-S3NAYZ3S.js");
   const issueId = parseIssue(c);
   if (!issueId) {
     return { status: 400, body: { ok: false, error: "Issue id is required." } };
@@ -7376,7 +7588,7 @@ async function patchIssueState(c) {
 }
 async function retryIssue(c) {
   const context2 = getApiRuntimeContextOrThrow();
-  const { persistState: persistState2 } = await import("./store-M6NCKMZY.js");
+  const { persistState: persistState2 } = await import("./store-S3NAYZ3S.js");
   const issueId = parseIssue(c);
   if (!issueId) {
     return { status: 400, body: { ok: false, error: "Issue id is required." } };
@@ -7399,7 +7611,7 @@ async function retryIssue(c) {
 }
 async function createIssue(c) {
   const context2 = getApiRuntimeContextOrThrow();
-  const { persistState: persistState2 } = await import("./store-M6NCKMZY.js");
+  const { persistState: persistState2 } = await import("./store-S3NAYZ3S.js");
   try {
     const payload = await c.req.json();
     const container = getContainer();
@@ -7415,7 +7627,7 @@ async function createIssue(c) {
 }
 async function cancelIssue(c) {
   const context2 = getApiRuntimeContextOrThrow();
-  const { persistState: persistState2 } = await import("./store-M6NCKMZY.js");
+  const { persistState: persistState2 } = await import("./store-S3NAYZ3S.js");
   const issueId = parseIssue(c);
   if (!issueId) {
     return { status: 400, body: { ok: false, error: "Issue id is required." } };
@@ -7434,7 +7646,7 @@ async function cancelIssue(c) {
 }
 async function deleteIssue(c) {
   const context2 = getApiRuntimeContextOrThrow();
-  const { persistState: persistState2 } = await import("./store-M6NCKMZY.js");
+  const { persistState: persistState2 } = await import("./store-S3NAYZ3S.js");
   const issueId = parseIssue(c);
   if (!issueId) {
     return { status: 400, body: { ok: false, error: "Issue id is required." } };
@@ -7456,7 +7668,7 @@ async function deleteIssue(c) {
 }
 async function approveAndMerge(c) {
   const context2 = getApiRuntimeContextOrThrow();
-  const { persistState: persistState2 } = await import("./store-M6NCKMZY.js");
+  const { persistState: persistState2 } = await import("./store-S3NAYZ3S.js");
   const issueId = parseIssue(c);
   if (!issueId) {
     return { status: 400, body: { ok: false, error: "Issue id is required." } };
@@ -7509,7 +7721,7 @@ async function approveIssue(c) {
   try {
     const container = getContainer();
     await approvePlanCommand({ issue }, container);
-    const { persistState: persistState2 } = await import("./store-M6NCKMZY.js");
+    const { persistState: persistState2 } = await import("./store-S3NAYZ3S.js");
     await persistState2(context2.state);
     return { body: { ok: true, issue } };
   } catch (error) {
@@ -7526,7 +7738,7 @@ async function executeIssue(c) {
   try {
     const container = getContainer();
     await executeIssueCommand({ issue }, container);
-    const { persistState: persistState2 } = await import("./store-M6NCKMZY.js");
+    const { persistState: persistState2 } = await import("./store-S3NAYZ3S.js");
     await persistState2(context2.state);
     return { body: { ok: true, issue } };
   } catch (error) {
@@ -7543,7 +7755,7 @@ async function replanIssue(c) {
   try {
     const container = getContainer();
     await replanIssueCommand({ issue }, container);
-    const { persistState: persistState2 } = await import("./store-M6NCKMZY.js");
+    const { persistState: persistState2 } = await import("./store-S3NAYZ3S.js");
     await persistState2(context2.state);
     return { body: { ok: true, issue } };
   } catch (error) {
@@ -7577,8 +7789,9 @@ async function mergeIssuePreview(c) {
   const issue = findIssue(context2.state, issueId);
   if (!issue) return { status: 404, body: { ok: false, error: "Issue not found." } };
   try {
-    const { dryMerge } = await import("./workspace-CJTWFWTJ.js");
-    const result = dryMerge(issue);
+    const { dryMerge } = await import("./workspace-OS7GPMCN.js");
+    const autoCommit = context2.state.config.autoCommitBeforeMerge ?? true;
+    const result = dryMerge(issue, autoCommit);
     return { body: { ok: true, ...result } };
   } catch (error) {
     logger.error(`Failed to preview merge for ${issueId}: ${String(error)}`);
@@ -7592,12 +7805,12 @@ async function rebaseIssue(c) {
   const issue = findIssue(context2.state, issueId);
   if (!issue) return { status: 404, body: { ok: false, error: "Issue not found." } };
   try {
-    const { rebaseWorktree: rebaseWorktree2 } = await import("./workspace-CJTWFWTJ.js");
+    const { rebaseWorktree: rebaseWorktree2 } = await import("./workspace-OS7GPMCN.js");
     const result = rebaseWorktree2(issue);
     if (result.success) {
       addEvent(context2.state, issue.id, "info", `Branch ${issue.branchName} rebased onto ${issue.baseBranch}.`);
     }
-    const { persistState: persistState2 } = await import("./store-M6NCKMZY.js");
+    const { persistState: persistState2 } = await import("./store-S3NAYZ3S.js");
     await persistState2(context2.state);
     return { body: { ok: true, ...result } };
   } catch (error) {
@@ -7617,7 +7830,7 @@ async function createIssueTestWorkspace(c) {
   const testWorkspacePath = createTestWorkspace(issue);
   markIssueDirty(issue.id);
   addEvent(context2.state, issue.id, "manual", `Isolated test workspace created at ${testWorkspacePath}.`);
-  const { persistState: persistState2 } = await import("./store-M6NCKMZY.js");
+  const { persistState: persistState2 } = await import("./store-S3NAYZ3S.js");
   await persistState2(context2.state);
   return { body: { ok: true, issue } };
 }
@@ -7630,7 +7843,7 @@ async function revertIssueTestWorkspace(c) {
   removeTestWorkspace(issue);
   markIssueDirty(issue.id);
   addEvent(context2.state, issue.id, "manual", "Isolated test workspace removed.");
-  const { persistState: persistState2 } = await import("./store-M6NCKMZY.js");
+  const { persistState: persistState2 } = await import("./store-S3NAYZ3S.js");
   await persistState2(context2.state);
   return { body: { ok: true, issue } };
 }
@@ -7658,7 +7871,7 @@ async function rollbackIssue(c) {
     container
   );
   addEvent(context2.state, issue.id, "manual", `${issue.identifier} rolled back. Worktree and branch removed.`);
-  const { persistState: persistState2 } = await import("./store-M6NCKMZY.js");
+  const { persistState: persistState2 } = await import("./store-S3NAYZ3S.js");
   await persistState2(context2.state);
   return { body: { ok: true, issue } };
 }
@@ -7697,21 +7910,21 @@ async function uploadIssueImages(c) {
     if (!Array.isArray(payload.files) || payload.files.length === 0) {
       return { status: 400, body: { ok: false, error: "No files provided." } };
     }
-    const issueAttachDir = join18(ATTACHMENTS_ROOT, issue.id);
+    const issueAttachDir = join19(ATTACHMENTS_ROOT, issue.id);
     mkdirSync10(issueAttachDir, { recursive: true });
     const newPaths = [];
     for (const file of payload.files) {
       if (typeof file.data !== "string" || !file.name) continue;
       const safeExt = extname2(file.name).replace(/[^a-z0-9.]/gi, "").slice(0, 10) || ".bin";
       const safeName = `${randomUUID2()}${safeExt}`;
-      const dest = join18(issueAttachDir, safeName);
+      const dest = join19(issueAttachDir, safeName);
       writeFileSync13(dest, Buffer.from(file.data, "base64"));
       newPaths.push(dest);
     }
     issue.images = [...issue.images ?? [], ...newPaths];
     issue.updatedAt = now();
     markIssueDirty(issue.id);
-    const { persistState: persistState2 } = await import("./store-M6NCKMZY.js");
+    const { persistState: persistState2 } = await import("./store-S3NAYZ3S.js");
     await persistState2(context2.state);
     return { body: { ok: true, paths: newPaths, issue } };
   } catch (error) {
@@ -7725,8 +7938,8 @@ async function getIssueImage(c) {
   const filename = c?.req?.param?.("filename") ?? "";
   if (!filename) return { status: 400, body: { ok: false, error: "Filename is required." } };
   const safeName = basename3(filename);
-  const filePath = join18(ATTACHMENTS_ROOT, issueId, safeName);
-  if (!existsSync9(filePath)) return { status: 404, body: { ok: false, error: "Image not found." } };
+  const filePath = join19(ATTACHMENTS_ROOT, issueId, safeName);
+  if (!existsSync10(filePath)) return { status: 404, body: { ok: false, error: "Image not found." } };
   const ext = extname2(safeName).toLowerCase();
   const mimeMap = {
     ".png": "image/png",
@@ -7737,7 +7950,7 @@ async function getIssueImage(c) {
     ".svg": "image/svg+xml"
   };
   const mime = mimeMap[ext] ?? "application/octet-stream";
-  const data = readFileSync6(filePath);
+  const data = readFileSync7(filePath);
   return { body: new Response(data, { headers: { "Content-Type": mime, "Cache-Control": "private, max-age=86400" } }) };
 }
 async function getIssueHistory(c) {
@@ -7770,7 +7983,7 @@ async function writeToIssueAgent(c) {
     return { status: 400, body: { ok: false, error: "Body must include { text: string } \u2014 the text to send to the agent's PTY stdin." } };
   }
   const payload = text.endsWith("\r") || text.endsWith("\n") ? text : `${text}\r`;
-  const { writeToDaemon: writeToDaemon2, isDaemonSocketReady: isDaemonSocketReady2 } = await import("./agent-RMQTTUEC.js");
+  const { writeToDaemon: writeToDaemon2, isDaemonSocketReady: isDaemonSocketReady2 } = await import("./agent-DFSFG6DG.js");
   if (!isDaemonSocketReady2(issue.workspacePath)) {
     return { status: 409, body: { ok: false, error: "Agent is running but not via PTY daemon \u2014 write not supported for this session." } };
   }
@@ -7807,7 +8020,7 @@ async function streamIssueAgentRuntime(c) {
     start(ctrl) {
       let lastSize = 0;
       const logFile = getLogFile();
-      if (logFile && existsSync9(logFile)) {
+      if (logFile && existsSync10(logFile)) {
         try {
           const stat = statSync2(logFile);
           lastSize = stat.size;
@@ -7825,7 +8038,7 @@ async function streamIssueAgentRuntime(c) {
       }
       chunkIntervalId = setInterval(() => {
         const lf = getLogFile();
-        if (!lf || !existsSync9(lf)) return;
+        if (!lf || !existsSync10(lf)) return;
         try {
           const stat = statSync2(lf);
           if (stat.size < lastSize) {
@@ -7910,7 +8123,7 @@ async function getIssueLive(c) {
     const liveLog = wp ? `${wp}/live-output.log` : null;
     let logTail = "";
     let logSize = 0;
-    if (liveLog && existsSync9(liveLog)) {
+    if (liveLog && existsSync10(liveLog)) {
       try {
         const stat = statSync2(liveLog);
         logSize = stat.size;
@@ -7924,7 +8137,7 @@ async function getIssueLive(c) {
       }
     }
     const agentStatus = isAgentStillRunning(issue);
-    const daemonSocketReady = wp ? existsSync9(join18(wp, "agent.sock")) : false;
+    const daemonSocketReady = wp ? existsSync10(join19(wp, "agent.sock")) : false;
     return {
       body: {
         ok: true,
@@ -7964,7 +8177,7 @@ async function streamIssueLive(c) {
       const wp = issue.workspacePath;
       const liveLog = wp ? `${wp}/live-output.log` : null;
       let lastSize = 0;
-      if (liveLog && existsSync9(liveLog)) {
+      if (liveLog && existsSync10(liveLog)) {
         try {
           const stat = statSync2(liveLog);
           lastSize = stat.size;
@@ -7992,7 +8205,7 @@ async function streamIssueLive(c) {
           return;
         }
         const logPath = currentIssue.workspacePath ? `${currentIssue.workspacePath}/live-output.log` : null;
-        if (logPath && existsSync9(logPath)) {
+        if (logPath && existsSync10(logPath)) {
           try {
             const stat = statSync2(logPath);
             if (stat.size > lastSize) {
@@ -8040,7 +8253,7 @@ async function getIssueDiff(c) {
   if (!issue) return { status: 404, body: { ok: false, error: "Issue not found." } };
   try {
     const wp = issue.workspacePath;
-    if (!wp || !existsSync9(wp)) {
+    if (!wp || !existsSync10(wp)) {
       return { body: { ok: true, files: [], diff: "", message: "No workspace found." } };
     }
     let raw = "";
@@ -8055,7 +8268,7 @@ async function getIssueDiff(c) {
         raw = typeof failedDiff.stdout === "string" ? failedDiff.stdout : "";
       }
     } else {
-      if (!existsSync9(SOURCE_ROOT)) {
+      if (!existsSync10(SOURCE_ROOT)) {
         return { body: { ok: true, files: [], diff: "", message: "Source root not found." } };
       }
       try {
@@ -8113,11 +8326,11 @@ async function listIssueOutputs(c) {
   if (!issue) return { status: 404, body: { ok: false, error: "Issue not found." } };
   const wp = issue.workspacePath;
   if (!wp) return { body: { ok: true, files: [] } };
-  const outputsDir = join18(wp, "outputs");
-  if (!existsSync9(outputsDir)) return { body: { ok: true, files: [] } };
-  const entries = readdirSync3(outputsDir).filter((file) => file.endsWith(".stdout.log")).map((file) => {
+  const outputsDir = join19(wp, "outputs");
+  if (!existsSync10(outputsDir)) return { body: { ok: true, files: [] } };
+  const entries = readdirSync4(outputsDir).filter((file) => file.endsWith(".stdout.log")).map((file) => {
     try {
-      const stats = statSync2(join18(outputsDir, file));
+      const stats = statSync2(join19(outputsDir, file));
       return { name: file, size: stats.size };
     } catch {
       return { name: file, size: 0 };
@@ -8139,9 +8352,9 @@ async function getIssueOutput(c) {
   }
   const wp = issue.workspacePath;
   if (!wp) return { status: 404, body: { ok: false, error: "No workspace found." } };
-  const filePath = join18(wp, "outputs", safeName);
-  if (!existsSync9(filePath)) return { status: 404, body: { ok: false, error: "Output file not found." } };
-  const content = readFileSync6(filePath, "utf8");
+  const filePath = join19(wp, "outputs", safeName);
+  if (!existsSync10(filePath)) return { status: 404, body: { ok: false, error: "Output file not found." } };
+  const content = readFileSync7(filePath, "utf8");
   return { body: new Response(content, { headers: { "Content-Type": "text/plain; charset=utf-8" } }) };
 }
 async function assignIssueMilestone(c, deps) {
@@ -8363,7 +8576,7 @@ var issues_resource_default = {
 
 // src/persistence/resources/milestones.resource.ts
 async function loadMilestoneApiDeps() {
-  const { getMilestoneStateResource: getMilestoneStateResource2, persistState: persistState2 } = await import("./store-M6NCKMZY.js");
+  const { getMilestoneStateResource: getMilestoneStateResource2, persistState: persistState2 } = await import("./store-S3NAYZ3S.js");
   return {
     persistState: persistState2,
     deleteMilestoneRecord: async (id) => {
@@ -8556,7 +8769,7 @@ async function getSetting(c) {
 }
 async function updateSetting(c) {
   const context2 = getApiRuntimeContextOrThrow();
-  const { persistState: persistState2 } = await import("./store-M6NCKMZY.js");
+  const { persistState: persistState2 } = await import("./store-S3NAYZ3S.js");
   const settingId = c.req.param("id") || "";
   if (!settingId) {
     return respond2(c, { ok: false, error: "Setting id is required" }, 400);
@@ -8684,7 +8897,7 @@ async function loadServiceApiDeps() {
     replacePersistedService: replacePersistedService2,
     deletePersistedService: deletePersistedService2,
     replaceAllServices: replaceAllServices2
-  } = await import("./store-M6NCKMZY.js");
+  } = await import("./store-S3NAYZ3S.js");
   return {
     replacePersistedService: replacePersistedService2,
     deletePersistedService: deletePersistedService2,
@@ -8814,7 +9027,7 @@ var services_resource_default = {
 };
 
 // src/persistence/resources/variables.resource.ts
-var ENV_KEY_PATTERN2 = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var ENV_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 function getRuntimeState2() {
   return getApiRuntimeContextOrThrow().state;
 }
@@ -8827,7 +9040,7 @@ function normalizeVariableEntry(value) {
   const scope = typeof raw.scope === "string" ? raw.scope.trim() : "";
   const val = typeof raw.value === "string" ? raw.value : String(raw.value ?? "");
   if (!key) return { error: "Variable key is required." };
-  if (!ENV_KEY_PATTERN2.test(key)) return { error: `Invalid variable name "${key}". Must match [A-Za-z_][A-Za-z0-9_]*.` };
+  if (!ENV_KEY_PATTERN.test(key)) return { error: `Invalid variable name "${key}". Must match [A-Za-z_][A-Za-z0-9_]*.` };
   if (!scope) return { error: "Variable scope is required." };
   const id = `${scope}:${key}`;
   const entry = { id, key, value: val, scope, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
@@ -8928,640 +9141,6 @@ var NATIVE_RESOURCE_CONFIGS = [
 ];
 var NATIVE_RESOURCE_NAMES = NATIVE_RESOURCE_CONFIGS.map((resource) => resource.name);
 
-// src/persistence/plugins/service-log-broadcaster.ts
-import {
-  closeSync as closeSync3,
-  existsSync as existsSync11,
-  openSync as openSync3,
-  readSync as readSync3,
-  statSync as statSync4,
-  watch
-} from "fs";
-
-// src/persistence/plugins/fsm-service.ts
-import {
-  closeSync as closeSync2,
-  existsSync as existsSync10,
-  openSync as openSync2,
-  readFileSync as readFileSync7,
-  readSync as readSync2,
-  rmSync as rmSync5,
-  statSync as statSync3,
-  writeFileSync as writeFileSync14
-} from "fs";
-import { join as join19, resolve as resolve3 } from "path";
-import { spawn as spawn2 } from "child_process";
-var STARTING_GRACE_MS = 3e3;
-var STOPPING_KILL_MS = 5e3;
-var SERVICE_WATCHER_INTERVAL_MS = 5e3;
-function pidPath(fifonyDir, id) {
-  return join19(fifonyDir, `service-${id}.pid`);
-}
-function serviceLogPath(fifonyDir, id) {
-  return join19(fifonyDir, `service-${id}.log`);
-}
-function readPidInfo(fifonyDir, id) {
-  const path = pidPath(fifonyDir, id);
-  if (!existsSync10(path)) return null;
-  try {
-    const data = JSON.parse(readFileSync7(path, "utf8"));
-    if (!data?.pid || typeof data.pid !== "number") return null;
-    if (!data.state) {
-      data.state = isProcessAlive(data.pid) ? "running" : "crashed";
-      data.crashCount ??= 0;
-    }
-    return data;
-  } catch {
-    return null;
-  }
-}
-function writePidInfo(fifonyDir, id, info) {
-  writeFileSync14(pidPath(fifonyDir, id), JSON.stringify(info));
-}
-function removePidInfo(fifonyDir, id) {
-  try {
-    rmSync5(pidPath(fifonyDir, id), { force: true });
-  } catch {
-  }
-}
-function spawnProcess(entry, targetRoot, fifonyDir, globalEnv) {
-  const cwd = entry.cwd ? resolve3(targetRoot, entry.cwd) : targetRoot;
-  const log = serviceLogPath(fifonyDir, entry.id);
-  const command = buildServiceCommand(entry.command, globalEnv, entry.env);
-  try {
-    writeFileSync14(log, "");
-  } catch {
-  }
-  const logFd = openSync2(log, "a");
-  const child = spawn2(command, [], {
-    shell: true,
-    cwd,
-    detached: true,
-    stdio: ["ignore", logFd, logFd]
-  });
-  try {
-    closeSync2(logFd);
-  } catch {
-  }
-  child.unref();
-  if (child.pid === void 0) {
-    throw new Error(`Failed to spawn service process: ${command}`);
-  }
-  return { pid: child.pid, command };
-}
-function getServiceStatus(entry, fifonyDir) {
-  const info = readPidInfo(fifonyDir, entry.id);
-  const alive = info !== null && isProcessAlive(info.pid);
-  let state;
-  if (!info) {
-    state = "stopped";
-  } else if (info.state === "stopping") {
-    state = alive ? "stopping" : "stopped";
-  } else if (info.state === "starting" || info.state === "running") {
-    state = alive ? info.state : "crashed";
-  } else {
-    state = info.state;
-  }
-  const logFile = serviceLogPath(fifonyDir, entry.id);
-  let logSize = 0;
-  if (existsSync10(logFile)) {
-    try {
-      logSize = statSync3(logFile).size;
-    } catch {
-    }
-  }
-  const startedAt = info?.startedAt ?? null;
-  const running2 = state === "starting" || state === "running";
-  const uptime = startedAt && running2 ? Date.now() - Date.parse(startedAt) : 0;
-  return {
-    id: entry.id,
-    name: entry.name,
-    command: entry.command,
-    cwd: entry.cwd,
-    env: entry.env,
-    autoStart: entry.autoStart,
-    autoRestart: entry.autoRestart,
-    maxCrashes: entry.maxCrashes,
-    port: entry.port,
-    state,
-    running: running2,
-    pid: alive ? info?.pid ?? null : null,
-    startedAt,
-    uptime: Number.isFinite(uptime) ? uptime : 0,
-    logSize,
-    crashCount: info?.crashCount ?? 0,
-    nextRetryAt: info?.nextRetryAt
-  };
-}
-function getAllServiceStatuses(entries, fifonyDir) {
-  return entries.map((e) => getServiceStatus(e, fifonyDir));
-}
-function cmdStart(entry, targetRoot, fifonyDir, globalEnv) {
-  const existing = readPidInfo(fifonyDir, entry.id);
-  const fromState = existing?.state ?? "none";
-  if (existing && isProcessAlive(existing.pid)) {
-    try {
-      process.kill(-existing.pid, "SIGKILL");
-    } catch {
-    }
-    try {
-      process.kill(existing.pid, "SIGKILL");
-    } catch {
-    }
-  }
-  const spawned = spawnProcess(entry, targetRoot, fifonyDir, globalEnv);
-  writePidInfo(fifonyDir, entry.id, {
-    pid: spawned.pid,
-    command: spawned.command,
-    startedAt: now(),
-    state: "starting",
-    crashCount: 0
-    // manual start always resets crash count
-  });
-  logger.info({ id: entry.id, pid: spawned.pid, from: fromState }, "[Service] FSM: \u2192 starting (manual start)");
-  return { id: entry.id, from: fromState, to: "starting", pid: spawned.pid, reason: "manual start" };
-}
-function cmdStop(id, fifonyDir) {
-  const existing = readPidInfo(fifonyDir, id);
-  if (!existing || existing.state === "stopped") return null;
-  const fromState = existing.state;
-  if (isProcessAlive(existing.pid)) {
-    try {
-      process.kill(-existing.pid, "SIGTERM");
-    } catch {
-    }
-  }
-  writePidInfo(fifonyDir, id, {
-    ...existing,
-    state: "stopping",
-    stoppingAt: now()
-  });
-  logger.info({ id, pid: existing.pid, from: fromState }, "[Service] FSM: \u2192 stopping (manual stop)");
-  return { id, from: fromState, to: "stopping", pid: existing.pid, reason: "manual stop" };
-}
-function autoRestartBackoffMs(crashCount) {
-  return Math.min(Math.pow(2, crashCount) * 1e3, 6e4);
-}
-function tickOne(entry, globalEnv, fifonyDir, targetRoot) {
-  const info = readPidInfo(fifonyDir, entry.id);
-  if (!info) return null;
-  const alive = isProcessAlive(info.pid);
-  const nowMs = Date.now();
-  switch (info.state) {
-    case "starting": {
-      if (!alive) {
-        const crashCount = (info.crashCount ?? 0) + 1;
-        const maxCrashes = entry.maxCrashes ?? 5;
-        const autoRestart = entry.autoRestart ?? false;
-        const nextRetryAt = autoRestart && crashCount < maxCrashes ? new Date(nowMs + autoRestartBackoffMs(crashCount)).toISOString() : void 0;
-        writePidInfo(fifonyDir, entry.id, {
-          ...info,
-          state: "crashed",
-          crashCount,
-          lastCrashAt: now(),
-          nextRetryAt
-        });
-        logger.warn({ id: entry.id, crashCount, nextRetryAt }, "[Service] FSM: starting \u2192 crashed");
-        return {
-          id: entry.id,
-          from: "starting",
-          to: "crashed",
-          pid: null,
-          reason: `died during startup (crash #${crashCount})`
-        };
-      }
-      const ageMs = nowMs - Date.parse(info.startedAt);
-      if (ageMs >= STARTING_GRACE_MS) {
-        writePidInfo(fifonyDir, entry.id, { ...info, state: "running" });
-        logger.info({ id: entry.id, pid: info.pid }, "[Service] FSM: starting \u2192 running");
-        return {
-          id: entry.id,
-          from: "starting",
-          to: "running",
-          pid: info.pid,
-          reason: "startup grace period elapsed"
-        };
-      }
-      return null;
-    }
-    case "running": {
-      if (!alive) {
-        const crashCount = (info.crashCount ?? 0) + 1;
-        const maxCrashes = entry.maxCrashes ?? 5;
-        const autoRestart = entry.autoRestart ?? false;
-        const nextRetryAt = autoRestart && crashCount < maxCrashes ? new Date(nowMs + autoRestartBackoffMs(crashCount)).toISOString() : void 0;
-        writePidInfo(fifonyDir, entry.id, {
-          ...info,
-          state: "crashed",
-          crashCount,
-          lastCrashAt: now(),
-          nextRetryAt
-        });
-        logger.warn({ id: entry.id, crashCount, nextRetryAt }, "[Service] FSM: running \u2192 crashed");
-        return {
-          id: entry.id,
-          from: "running",
-          to: "crashed",
-          pid: null,
-          reason: `process died unexpectedly (crash #${crashCount})`
-        };
-      }
-      return null;
-    }
-    case "stopping": {
-      if (!alive) {
-        removePidInfo(fifonyDir, entry.id);
-        logger.info({ id: entry.id }, "[Service] FSM: stopping \u2192 stopped (process exited)");
-        return {
-          id: entry.id,
-          from: "stopping",
-          to: "stopped",
-          pid: null,
-          reason: "process exited gracefully"
-        };
-      }
-      const stoppingAgeMs = info.stoppingAt ? nowMs - Date.parse(info.stoppingAt) : STOPPING_KILL_MS + 1;
-      if (stoppingAgeMs >= STOPPING_KILL_MS) {
-        try {
-          process.kill(-info.pid, "SIGKILL");
-        } catch {
-        }
-        try {
-          process.kill(info.pid, "SIGKILL");
-        } catch {
-        }
-        removePidInfo(fifonyDir, entry.id);
-        logger.info({ id: entry.id, pid: info.pid }, "[Service] FSM: stopping \u2192 stopped (SIGKILL)");
-        return {
-          id: entry.id,
-          from: "stopping",
-          to: "stopped",
-          pid: null,
-          reason: "SIGKILL after stop timeout"
-        };
-      }
-      return null;
-    }
-    case "crashed": {
-      const maxCrashes = entry.maxCrashes ?? 5;
-      if (!(entry.autoRestart ?? false) || (info.crashCount ?? 0) >= maxCrashes) return null;
-      const nextRetryMs = info.nextRetryAt ? Date.parse(info.nextRetryAt) : 0;
-      if (nowMs < nextRetryMs) return null;
-      const spawned = spawnProcess(entry, targetRoot, fifonyDir, globalEnv);
-      writePidInfo(fifonyDir, entry.id, {
-        pid: spawned.pid,
-        command: spawned.command,
-        startedAt: now(),
-        state: "starting",
-        crashCount: info.crashCount
-        // preserve crash count on auto-restart
-      });
-      logger.info(
-        { id: entry.id, pid: spawned.pid, crashCount: info.crashCount },
-        "[Service] FSM: crashed \u2192 starting (auto-restart)"
-      );
-      return {
-        id: entry.id,
-        from: "crashed",
-        to: "starting",
-        pid: spawned.pid,
-        reason: `auto-restart after backoff (crash #${info.crashCount})`
-      };
-    }
-    case "stopped":
-      return null;
-    default:
-      return null;
-  }
-}
-function tickServiceWatcher(entries, globalEnv, fifonyDir, targetRoot) {
-  const transitions = [];
-  for (const entry of entries) {
-    try {
-      const t = tickOne(entry, globalEnv, fifonyDir, targetRoot);
-      if (t) transitions.push(t);
-    } catch (err) {
-      logger.warn({ err, id: entry.id }, "[Service] Watcher tick error");
-    }
-  }
-  return transitions;
-}
-function initServiceWatcher(getEntries, getGlobalEnv, fifonyDir, targetRoot, onTransition) {
-  const intervalId = setInterval(() => {
-    const entries = getEntries();
-    if (entries.length === 0) return;
-    const transitions = tickServiceWatcher(entries, getGlobalEnv(), fifonyDir, targetRoot);
-    for (const t of transitions) onTransition(t);
-  }, SERVICE_WATCHER_INTERVAL_MS);
-  return { stop: () => clearInterval(intervalId) };
-}
-function readServiceLogTail(id, fifonyDir, bytes = 8192) {
-  const log = serviceLogPath(fifonyDir, id);
-  if (!existsSync10(log)) return "";
-  try {
-    const size = statSync3(log).size;
-    const readSize = Math.min(size, bytes);
-    const fd = openSync2(log, "r");
-    const buf = Buffer.alloc(readSize);
-    readSync2(fd, buf, 0, readSize, Math.max(0, size - readSize));
-    closeSync2(fd);
-    return buf.toString("utf8");
-  } catch {
-    return "";
-  }
-}
-function reconcileServiceStates(entries, fifonyDir) {
-  for (const entry of entries) {
-    const info = readPidInfo(fifonyDir, entry.id);
-    if (!info) continue;
-    if (info.state === "stopped") continue;
-    if (!isProcessAlive(info.pid)) {
-      const crashCount = (info.crashCount ?? 0) + 1;
-      writePidInfo(fifonyDir, entry.id, {
-        ...info,
-        state: "crashed",
-        crashCount,
-        lastCrashAt: now()
-      });
-      logger.info({ id: entry.id, crashCount }, "[Service] Boot: process dead \u2192 crashed");
-    }
-  }
-}
-
-// src/persistence/plugins/service-log-broadcaster.ts
-var MAX_CHUNK_BYTES = 16384;
-var active2 = /* @__PURE__ */ new Map();
-function readNewBytes(logPath, position) {
-  try {
-    const size = statSync4(logPath).size;
-    if (size <= position) return null;
-    const toRead = Math.min(size - position, MAX_CHUNK_BYTES);
-    const buf = Buffer.alloc(toRead);
-    const fd = openSync3(logPath, "r");
-    const n = readSync3(fd, buf, 0, toRead, position);
-    closeSync3(fd);
-    if (n <= 0) return null;
-    return { chunk: buf.slice(0, n).toString("utf8"), newPosition: position + n };
-  } catch {
-    return null;
-  }
-}
-function startServiceLogBroadcasting(id, fifonyDir) {
-  stopServiceLogBroadcasting(id);
-  const logPath = serviceLogPath(fifonyDir, id);
-  if (!existsSync11(logPath)) return;
-  const entry = { watcher: null, position: 0 };
-  const flush = () => {
-    if (serviceLogRoomSize(id) === 0) return;
-    try {
-      const size = statSync4(logPath).size;
-      if (size < entry.position) entry.position = 0;
-    } catch {
-      return;
-    }
-    const result = readNewBytes(logPath, entry.position);
-    if (!result) return;
-    entry.position = result.newPosition;
-    sendToServiceLogRoom(id, JSON.stringify({ type: "service:log", id, chunk: result.chunk }));
-  };
-  try {
-    const watcher = watch(logPath, { persistent: false }, flush);
-    watcher.on("error", () => active2.delete(id));
-    entry.watcher = watcher;
-    active2.set(id, entry);
-    logger.debug({ id }, "[ServiceLogBroadcaster] Started");
-    flush();
-  } catch (err) {
-    logger.debug({ err, id }, "[ServiceLogBroadcaster] Could not watch log file");
-  }
-}
-function stopServiceLogBroadcasting(id) {
-  const entry = active2.get(id);
-  if (!entry) return;
-  try {
-    entry.watcher.close();
-  } catch {
-  }
-  active2.delete(id);
-}
-
-// src/routes/websocket.ts
-var wsClients = /* @__PURE__ */ new Map();
-var broadcastSeq = 0;
-var lastBroadcastIssueSnapshot = /* @__PURE__ */ new Map();
-var serviceLogRooms = /* @__PURE__ */ new Map();
-function subscribeServiceLogRoom(socketId, serviceId) {
-  if (!serviceLogRooms.has(serviceId)) serviceLogRooms.set(serviceId, /* @__PURE__ */ new Set());
-  serviceLogRooms.get(serviceId).add(socketId);
-}
-function unsubscribeServiceLogRoom(socketId, serviceId) {
-  serviceLogRooms.get(serviceId)?.delete(socketId);
-}
-var analyticsRooms = /* @__PURE__ */ new Map();
-var analyticsOnSubscribeFn = null;
-function setAnalyticsOnSubscribeFn(fn) {
-  analyticsOnSubscribeFn = fn;
-}
-function subscribeAnalyticsRoom(socketId, topic) {
-  if (!analyticsRooms.has(topic)) analyticsRooms.set(topic, /* @__PURE__ */ new Set());
-  analyticsRooms.get(topic).add(socketId);
-  analyticsOnSubscribeFn?.(socketId, topic);
-}
-function unsubscribeAnalyticsRoom(socketId, topic) {
-  analyticsRooms.get(topic)?.delete(socketId);
-}
-function analyticsRoomHasSubscribers(topic) {
-  return (analyticsRooms.get(topic)?.size ?? 0) > 0;
-}
-function sendToAnalyticsRoom(topic, data) {
-  const room = analyticsRooms.get(topic);
-  if (!room || room.size === 0) return;
-  const msg = JSON.stringify({ type: "analytics:update", topic, data });
-  for (const socketId of [...room]) {
-    const send = wsClients.get(socketId);
-    if (!send) {
-      room.delete(socketId);
-      continue;
-    }
-    try {
-      send(msg);
-    } catch {
-      wsClients.delete(socketId);
-      room.delete(socketId);
-    }
-  }
-}
-var issueLogRooms = /* @__PURE__ */ new Map();
-function subscribeIssueLogRoom(socketId, issueId) {
-  if (!issueLogRooms.has(issueId)) issueLogRooms.set(issueId, /* @__PURE__ */ new Set());
-  issueLogRooms.get(issueId).add(socketId);
-}
-function unsubscribeIssueLogRoom(socketId, issueId) {
-  issueLogRooms.get(issueId)?.delete(socketId);
-}
-function issueLogRoomSize(issueId) {
-  return issueLogRooms.get(issueId)?.size ?? 0;
-}
-function sendToIssueLogRoom(issueId, data) {
-  const room = issueLogRooms.get(issueId);
-  if (!room || room.size === 0) return;
-  for (const socketId of [...room]) {
-    const send = wsClients.get(socketId);
-    if (!send) {
-      room.delete(socketId);
-      continue;
-    }
-    try {
-      send(data);
-    } catch {
-      wsClients.delete(socketId);
-      room.delete(socketId);
-    }
-  }
-}
-function unsubscribeFromAllRooms(socketId) {
-  for (const room of serviceLogRooms.values()) room.delete(socketId);
-  for (const room of analyticsRooms.values()) room.delete(socketId);
-  for (const room of issueLogRooms.values()) room.delete(socketId);
-}
-function serviceLogRoomSize(serviceId) {
-  return serviceLogRooms.get(serviceId)?.size ?? 0;
-}
-function sendToServiceLogRoom(serviceId, data) {
-  const room = serviceLogRooms.get(serviceId);
-  if (!room || room.size === 0) return;
-  for (const socketId of [...room]) {
-    const send = wsClients.get(socketId);
-    if (!send) {
-      room.delete(socketId);
-      continue;
-    }
-    try {
-      send(data);
-    } catch {
-      wsClients.delete(socketId);
-      room.delete(socketId);
-    }
-  }
-}
-function sendToAllClients(data) {
-  for (const [socketId, send] of [...wsClients]) {
-    try {
-      send(data);
-    } catch (error) {
-      logger.debug(`WebSocket send failed for ${socketId}, removing (remaining: ${wsClients.size - 1}): ${String(error)}`);
-      wsClients.delete(socketId);
-    }
-  }
-}
-function broadcastToWebSocketClients(message) {
-  if (wsClients.size === 0) return;
-  broadcastSeq++;
-  logger.debug({ seq: broadcastSeq, type: message.type, clientCount: wsClients.size }, "[WebSocket] Broadcasting state update");
-  const issues = message.issues;
-  if (issues && lastBroadcastIssueSnapshot.size > 0) {
-    const currentIds = /* @__PURE__ */ new Set();
-    const changedIssues = [];
-    for (const issue of issues) {
-      const id = issue.id;
-      currentIds.add(id);
-      const serialized = JSON.stringify(issue);
-      if (lastBroadcastIssueSnapshot.get(id) !== serialized) {
-        changedIssues.push(issue);
-      }
-    }
-    const removedIds = [];
-    for (const prevId of lastBroadcastIssueSnapshot.keys()) {
-      if (!currentIds.has(prevId)) {
-        removedIds.push(prevId);
-      }
-    }
-    lastBroadcastIssueSnapshot = new Map(
-      issues.map((issue) => [issue.id, JSON.stringify(issue)])
-    );
-    if (changedIssues.length < issues.length / 2 || changedIssues.length <= 3) {
-      const delta = {
-        type: "state:delta",
-        seq: broadcastSeq,
-        metrics: message.metrics,
-        milestones: message.milestones,
-        updatedAt: message.updatedAt,
-        issuesDelta: changedIssues,
-        issuesRemoved: removedIds,
-        events: message.events
-      };
-      sendToAllClients(JSON.stringify(delta));
-      return;
-    }
-  }
-  if (issues) {
-    lastBroadcastIssueSnapshot = new Map(
-      issues.map((issue) => [issue.id, JSON.stringify(issue)])
-    );
-  }
-  sendToAllClients(JSON.stringify({
-    ...message,
-    seq: broadcastSeq
-  }));
-}
-function makeWebSocketConfig(state) {
-  return {
-    enabled: true,
-    path: "/ws",
-    maxPayloadBytes: 512e3,
-    onConnection: (socketId, send) => {
-      wsClients.set(socketId, send);
-      logger.debug(`WebSocket client connected: ${socketId} (total: ${wsClients.size})`);
-      try {
-        send(JSON.stringify({
-          type: "connected",
-          seq: broadcastSeq,
-          timestamp: now(),
-          metrics: computeMetrics(state.issues),
-          milestones: state.milestones,
-          issues: state.issues,
-          events: state.events.slice(0, 50)
-        }));
-      } catch (error) {
-        logger.debug(`WebSocket initial send failed for ${socketId}: ${String(error)}`);
-      }
-    },
-    onMessage: (socketId, message, send) => {
-      try {
-        const msg = JSON.parse(typeof message === "string" ? message : message.toString("utf8"));
-        if (msg.type === "ping") {
-          send(JSON.stringify({ type: "pong", timestamp: now() }));
-        } else if (msg.type === "service:log:subscribe" && typeof msg.id === "string") {
-          subscribeServiceLogRoom(socketId, msg.id);
-          startServiceLogBroadcasting(msg.id, STATE_ROOT);
-          logger.debug({ socketId, serviceId: msg.id }, "[WebSocket] Subscribed to service log room");
-        } else if (msg.type === "service:log:unsubscribe" && typeof msg.id === "string") {
-          unsubscribeServiceLogRoom(socketId, msg.id);
-          logger.debug({ socketId, serviceId: msg.id }, "[WebSocket] Unsubscribed from service log room");
-        } else if (msg.type === "analytics:subscribe" && typeof msg.topic === "string") {
-          subscribeAnalyticsRoom(socketId, msg.topic);
-          logger.debug({ socketId, topic: msg.topic }, "[WebSocket] Subscribed to analytics room");
-        } else if (msg.type === "analytics:unsubscribe" && typeof msg.topic === "string") {
-          unsubscribeAnalyticsRoom(socketId, msg.topic);
-          logger.debug({ socketId, topic: msg.topic }, "[WebSocket] Unsubscribed from analytics room");
-        } else if (msg.type === "issue:log:subscribe" && typeof msg.id === "string") {
-          subscribeIssueLogRoom(socketId, msg.id);
-          logger.debug({ socketId, issueId: msg.id }, "[WebSocket] Subscribed to issue log room");
-        } else if (msg.type === "issue:log:unsubscribe" && typeof msg.id === "string") {
-          unsubscribeIssueLogRoom(socketId, msg.id);
-          logger.debug({ socketId, issueId: msg.id }, "[WebSocket] Unsubscribed from issue log room");
-        }
-      } catch {
-      }
-    },
-    onClose: (socketId) => {
-      wsClients.delete(socketId);
-      unsubscribeFromAllRooms(socketId);
-      logger.debug(`WebSocket client disconnected: ${socketId} (total: ${wsClients.size})`);
-    }
-  };
-}
-
 // src/persistence/plugins/scheduler.ts
 var shuttingDown = false;
 function isShuttingDown() {
@@ -9718,7 +9297,7 @@ function hasTerminalQueue(state) {
 // src/agents/providers-usage.ts
 import { execFile as execFile2 } from "child_process";
 import { promisify } from "util";
-import { existsSync as existsSync12, readFileSync as readFileSync8, readdirSync as readdirSync4, realpathSync } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync8, readdirSync as readdirSync5, realpathSync } from "fs";
 import { join as join20, dirname as dirname2 } from "path";
 import { homedir as homedir2 } from "os";
 import { env } from "process";
@@ -9757,7 +9336,7 @@ function resolveCodexHomeCandidates() {
 }
 function resolveCodexDir() {
   for (const candidate of resolveCodexHomeCandidates()) {
-    if (existsSync12(candidate)) {
+    if (existsSync11(candidate)) {
       return candidate;
     }
   }
@@ -9765,16 +9344,16 @@ function resolveCodexDir() {
 }
 function findLatestCodexDb(codexDir) {
   const explicit = join20(codexDir, "state_5.sqlite");
-  if (existsSync12(explicit)) return explicit;
-  const candidates = readdirSync4(codexDir).filter((name) => name.startsWith("state_") && name.endsWith(".sqlite")).sort().reverse();
+  if (existsSync11(explicit)) return explicit;
+  const candidates = readdirSync5(codexDir).filter((name) => name.startsWith("state_") && name.endsWith(".sqlite")).sort().reverse();
   if (candidates.length === 0) return null;
   return join20(codexDir, candidates[0]);
 }
 function computeNextMonday() {
-  const now2 = /* @__PURE__ */ new Date();
-  const utcDay = now2.getUTCDay();
+  const now3 = /* @__PURE__ */ new Date();
+  const utcDay = now3.getUTCDay();
   const daysUntilMonday = utcDay === 0 ? 1 : utcDay === 1 ? 7 : 8 - utcDay;
-  const next = new Date(now2);
+  const next = new Date(now3);
   next.setUTCDate(next.getUTCDate() + daysUntilMonday);
   next.setUTCHours(0, 0, 0, 0);
   return next;
@@ -9830,7 +9409,7 @@ function resolveClaudePlanKey(displayName) {
 async function collectClaudeUsage() {
   const home = homedir2();
   const claudeDir = join20(home, ".claude");
-  if (!existsSync12(claudeDir)) return null;
+  if (!existsSync11(claudeDir)) return null;
   const available = await whichExists("claude");
   const projectsDir = join20(claudeDir, "projects");
   let totalInputTokens = 0;
@@ -9851,15 +9430,15 @@ async function collectClaudeUsage() {
   const weekMs = weekStart.getTime();
   const last5hStart = computeLastHoursStart(5);
   const last5hMs = last5hStart.getTime();
-  if (existsSync12(projectsDir)) {
+  if (existsSync11(projectsDir)) {
     try {
-      const projectDirs = readdirSync4(projectsDir, { withFileTypes: true });
+      const projectDirs = readdirSync5(projectsDir, { withFileTypes: true });
       for (const dir of projectDirs) {
         if (!dir.isDirectory()) continue;
         const projectPath = join20(projectsDir, dir.name);
         let sessionFiles;
         try {
-          sessionFiles = readdirSync4(projectPath).filter((f) => f.endsWith(".jsonl"));
+          sessionFiles = readdirSync5(projectPath).filter((f) => f.endsWith(".jsonl"));
         } catch {
           continue;
         }
@@ -9933,7 +9512,7 @@ async function collectClaudeUsage() {
   let resetInfo = "Weekly reset (every Monday 00:00 UTC)";
   let currentModel = "";
   const settingsPath = join20(claudeDir, "settings.json");
-  if (existsSync12(settingsPath)) {
+  if (existsSync11(settingsPath)) {
     try {
       const settings = JSON.parse(readFileSync8(settingsPath, "utf8"));
       if (settings.plan === "max" || settings.plan === "max5x") {
@@ -10057,7 +9636,7 @@ function aggregateCodexSessionUsageFromJsonl(lines) {
 }
 function collectCodexSessionUsagesFromJsonl(codexDir) {
   const sessionsDir = join20(codexDir, "sessions");
-  if (!existsSync12(sessionsDir)) return [];
+  if (!existsSync11(sessionsDir)) return [];
   const stack = [sessionsDir];
   const usageByFile = [];
   const seen = /* @__PURE__ */ new Set();
@@ -10067,7 +9646,7 @@ function collectCodexSessionUsagesFromJsonl(codexDir) {
     seen.add(current);
     let entries = [];
     try {
-      entries = readdirSync4(current, { withFileTypes: true });
+      entries = readdirSync5(current, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -10097,7 +9676,7 @@ async function collectCodexUsage() {
   const models = [];
   const modelsCachePath = join20(codexDir, "models_cache.json");
   let currentModel = "";
-  if (existsSync12(modelsCachePath)) {
+  if (existsSync11(modelsCachePath)) {
     try {
       const cache = JSON.parse(readFileSync8(modelsCachePath, "utf8"));
       for (const m of cache.models || []) {
@@ -10111,7 +9690,7 @@ async function collectCodexUsage() {
     }
   }
   const configPath = join20(codexDir, "config.toml");
-  if (existsSync12(configPath)) {
+  if (existsSync11(configPath)) {
     try {
       const configContent = readFileSync8(configPath, "utf8");
       const modelMatch = configContent.match(/^model\s*=\s*"([^"]+)"/m);
@@ -10374,28 +9953,28 @@ function aggregateGeminiSessionUsageFromJson(content) {
 }
 function collectGeminiSessionUsages() {
   const geminiTmp = join20(homedir2(), ".gemini", "tmp");
-  if (!existsSync12(geminiTmp)) return [];
+  if (!existsSync11(geminiTmp)) return [];
   const usages = [];
   let entries = [];
   try {
-    entries = readdirSync4(geminiTmp, { withFileTypes: true });
+    entries = readdirSync5(geminiTmp, { withFileTypes: true });
   } catch {
     return usages;
   }
   for (const profile of entries) {
     if (!profile.isDirectory()) continue;
     const chatsDir = join20(geminiTmp, profile.name, "chats");
-    if (!existsSync12(chatsDir)) continue;
+    if (!existsSync11(chatsDir)) continue;
     let sessions = [];
     try {
-      sessions = readdirSync4(chatsDir).filter((name) => name.startsWith("session-") && (name.endsWith(".json") || name.endsWith(".jsonl")));
+      sessions = readdirSync5(chatsDir).filter((name) => name.startsWith("session-") && (name.endsWith(".json") || name.endsWith(".jsonl")));
     } catch {
       continue;
     }
     for (const sessionFile of sessions) {
-      const sessionPath = join20(chatsDir, sessionFile);
+      const sessionPath2 = join20(chatsDir, sessionFile);
       try {
-        const usage = aggregateGeminiSessionUsageFromJson(readFileSync8(sessionPath, "utf8"));
+        const usage = aggregateGeminiSessionUsageFromJson(readFileSync8(sessionPath2, "utf8"));
         if (usage.totalTokens > 0) usages.push(usage);
       } catch {
       }
@@ -10415,7 +9994,7 @@ async function collectGeminiUsage() {
   }
   let account = null;
   const accountsPath = join20(homedir2(), ".gemini", "google_accounts.json");
-  if (existsSync12(accountsPath)) {
+  if (existsSync11(accountsPath)) {
     try {
       const data = JSON.parse(readFileSync8(accountsPath, "utf8"));
       if (typeof data.active === "string" && data.active.includes("@")) {
@@ -10433,7 +10012,7 @@ async function collectGeminiUsage() {
     const { stdout: binPath } = await execFileAsync("which", ["gemini"], { encoding: "utf8", timeout: 3e3 });
     const realBin = realpathSync(binPath.trim());
     const modelsPath = join20(dirname2(dirname2(realBin)), "node_modules", "@google", "gemini-cli-core", "dist", "src", "config", "models.js");
-    if (existsSync12(modelsPath)) {
+    if (existsSync11(modelsPath)) {
       const content = readFileSync8(modelsPath, "utf8");
       const regex = /export const ([A-Z0-9_]+)\s*=\s*'(gemini-[^']+)';/g;
       const seen = /* @__PURE__ */ new Set();
@@ -10453,7 +10032,7 @@ async function collectGeminiUsage() {
   }
   let currentModel = "";
   const settingsPath = join20(homedir2(), ".gemini", "settings.json");
-  if (existsSync12(settingsPath)) {
+  if (existsSync11(settingsPath)) {
     try {
       const settings = JSON.parse(readFileSync8(settingsPath, "utf8"));
       if (typeof settings.model === "string" && settings.model.trim()) {
@@ -10594,26 +10173,29 @@ function listServiceStatuses(entries, fifonyDir) {
 function getManagedServiceLogPath(id, fifonyDir) {
   return serviceLogPath(fifonyDir, id);
 }
-function startManagedService(entry, targetRoot, fifonyDir, globalEnv) {
-  return cmdStart(entry, targetRoot, fifonyDir, globalEnv);
+async function startManagedService(id) {
+  await sendServiceEvent(id, "START");
 }
-function stopManagedService(id, fifonyDir) {
-  return cmdStop(id, fifonyDir);
+async function stopManagedService(id) {
+  await sendServiceEvent(id, "STOP");
 }
-function startAutoConfiguredServices(entries, targetRoot, fifonyDir, globalEnv) {
-  const transitions = [];
+async function startAutoConfiguredServices(entries) {
+  const started = [];
   for (const entry of entries) {
     if (!entry.autoStart) continue;
-    transitions.push(startManagedService(entry, targetRoot, fifonyDir, globalEnv));
+    try {
+      await sendServiceEvent(entry.id, "START");
+      started.push(entry.id);
+    } catch (err) {
+      const { logger: logger2 } = await import("./logger-IFLXTQPS.js");
+      logger2.warn({ err, id: entry.id }, "[Service] Auto-start failed");
+    }
   }
-  return transitions;
+  return started;
 }
 function reconcileManagedServiceStates(entries, fifonyDir) {
   reconcileServiceStates(entries, fifonyDir);
 }
-function initManagedServiceWatcher(getEntries, getGlobalEnv, fifonyDir, targetRoot, onTransition) {
-  return initServiceWatcher(getEntries, getGlobalEnv, fifonyDir, targetRoot, onTransition);
-}
 
 // src/domains/runtime-diagnostics.ts
 function findConfiguredCapabilities(configuredProvider, providers) {
@@ -10899,8 +10481,8 @@ function registerStateRoutes(app, state) {
 
 // src/agents/planning/issue-enhancer.ts
 import { env as env2 } from "process";
-import { existsSync as existsSync13, mkdtempSync as mkdtempSync4, readFileSync as readFileSync9, rmSync as rmSync6, writeFileSync as writeFileSync15 } from "fs";
-import { spawn as spawn3 } from "child_process";
+import { existsSync as existsSync12, mkdtempSync as mkdtempSync4, readFileSync as readFileSync9, rmSync as rmSync5, writeFileSync as writeFileSync14 } from "fs";
+import { spawn as spawn2 } from "child_process";
 import { tmpdir as tmpdir4 } from "os";
 import { join as join21 } from "path";
 async function buildPrompt2(field, title, description, issueType, images) {
@@ -10985,7 +10567,7 @@ function parseCandidate(raw, expectedField) {
   return "";
 }
 function readProviderOutput(resultFile, fallback) {
-  if (existsSync13(resultFile)) {
+  if (existsSync12(resultFile)) {
     try {
       return readFileSync9(resultFile, "utf8").trim();
     } catch {
@@ -10998,9 +10580,9 @@ async function runProviderCommand(command, provider, prompt, title, description,
   const promptFile = join21(tempDir, "fifony-enhance-prompt.md");
   const issuePayloadFile = join21(tempDir, "fifony-issue.json");
   const resultFile = join21(tempDir, "fifony-result.txt");
-  writeFileSync15(promptFile, `${prompt}
+  writeFileSync14(promptFile, `${prompt}
 `, "utf8");
-  writeFileSync15(issuePayloadFile, JSON.stringify({ title, description, field }, null, 2), "utf8");
+  writeFileSync14(issuePayloadFile, JSON.stringify({ title, description, field }, null, 2), "utf8");
   const effectiveCommand = command;
   const spawnEnv = {
     ...env2,
@@ -11018,7 +10600,7 @@ async function runProviderCommand(command, provider, prompt, title, description,
     const startedAt = Date.now();
     let output = "";
     let timeout = false;
-    const child = spawn3(effectiveCommand, {
+    const child = spawn2(effectiveCommand, {
       shell: true,
       cwd: TARGET_ROOT,
       env: spawnEnv
@@ -11036,18 +10618,18 @@ async function runProviderCommand(command, provider, prompt, title, description,
     }, Math.max(timeoutMs, 1e3));
     child.on("error", () => {
       clearTimeout(timer);
-      rmSync6(tempDir, { recursive: true, force: true });
+      rmSync5(tempDir, { recursive: true, force: true });
       reject(new Error("Could not execute AI command."));
     });
     child.on("close", (code) => {
       clearTimeout(timer);
       if (timeout) {
-        rmSync6(tempDir, { recursive: true, force: true });
+        rmSync5(tempDir, { recursive: true, force: true });
         reject(new Error(`Enhance command timeout after ${Date.now() - startedAt}ms.`));
         return;
       }
       const commandOutput = readProviderOutput(resultFile, output);
-      rmSync6(tempDir, { recursive: true, force: true });
+      rmSync5(tempDir, { recursive: true, force: true });
       if (code !== 0) {
         if (commandOutput.trim()) {
           logger.warn({ exitCode: code, provider }, `[Enhance] Provider exited ${code} but produced output \u2014 attempting to use it`);
@@ -11067,7 +10649,7 @@ async function enhanceIssueField(payload, config, _workflowDefinition) {
   const description = typeof payload.description === "string" ? payload.description.trim() : "";
   const issueType = typeof payload.issueType === "string" ? payload.issueType.trim() : void 0;
   const images = Array.isArray(payload.images) ? payload.images.filter((p) => typeof p === "string") : void 0;
-  const { provider: selectedProvider, model: selectedModel } = await resolvePlanStageConfig(config);
+  const { provider: selectedProvider, model: selectedModel } = await resolveEnhanceStageConfig(config);
   const providers = detectAvailableProviders();
   const isAvailable = providers.some((p) => p.name === selectedProvider && p.available);
   if (!isAvailable) {
@@ -11115,6 +10697,175 @@ async function enhanceIssueField(payload, config, _workflowDefinition) {
   return { field, value, provider: selectedProvider };
 }
 
+// src/agents/planning/issue-chat.ts
+import { env as env3 } from "process";
+import { existsSync as existsSync13, mkdtempSync as mkdtempSync5, readFileSync as readFileSync10, rmSync as rmSync6, writeFileSync as writeFileSync15 } from "fs";
+import { spawn as spawn3 } from "child_process";
+import { tmpdir as tmpdir5 } from "os";
+import { join as join22 } from "path";
+function readProviderOutput2(resultFile, fallback) {
+  if (existsSync13(resultFile)) {
+    try {
+      return readFileSync10(resultFile, "utf8").trim();
+    } catch {
+    }
+  }
+  return fallback;
+}
+async function runOneShot(command, provider, prompt, timeoutMs) {
+  const tempDir = mkdtempSync5(join22(tmpdir5(), "fifony-chat-"));
+  const promptFile = join22(tempDir, "prompt.md");
+  const resultFile = join22(tempDir, "result.txt");
+  writeFileSync15(promptFile, `${prompt}
+`, "utf8");
+  const spawnEnv = {
+    ...env3,
+    FIFONY_PROMPT_FILE: promptFile,
+    FIFONY_PROMPT: prompt,
+    FIFONY_AGENT_PROVIDER: provider,
+    FIFONY_RESULT_FILE: resultFile
+  };
+  return await new Promise((resolve5, reject) => {
+    const startedAt = Date.now();
+    let output = "";
+    let timedOut = false;
+    const child = spawn3(command, { shell: true, cwd: TARGET_ROOT, env: spawnEnv });
+    if (child.stdin) child.stdin.end();
+    child.stdout?.on("data", (chunk) => {
+      output = appendFileTail(output, String(chunk), 12e3);
+    });
+    child.stderr?.on("data", (chunk) => {
+      output = appendFileTail(output, String(chunk), 12e3);
+    });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+    }, Math.max(timeoutMs, 1e3));
+    child.on("error", () => {
+      clearTimeout(timer);
+      rmSync6(tempDir, { recursive: true, force: true });
+      reject(new Error("Could not execute AI command."));
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      const commandOutput = readProviderOutput2(resultFile, output);
+      rmSync6(tempDir, { recursive: true, force: true });
+      if (timedOut) {
+        reject(new Error(`Chat command timed out after ${Date.now() - startedAt}ms.`));
+        return;
+      }
+      if (code !== 0 && !commandOutput.trim()) {
+        reject(new Error(`Chat command failed (exit ${code ?? "unknown"}) with no output.`));
+        return;
+      }
+      if (code !== 0) {
+        logger.warn({ exitCode: code, provider }, "[Chat] Provider exited non-zero but produced output \u2014 attempting to use it");
+      }
+      resolve5(commandOutput);
+    });
+  });
+}
+function buildChatPrompt(payload) {
+  const { title, description, plan, message, history } = payload;
+  const planSection = plan ? `Plan summary: ${plan.summary ?? "(none)"}
+Steps: ${plan.steps?.map((s) => s.action || s.title || "").filter(Boolean).join(", ") ?? "(none)"}` : "No plan yet.";
+  const historySection = history?.length ? history.map((m) => `${m.role}: ${m.content}`).join("\n") : "";
+  return `You are a helpful assistant discussing issue "${title}".
+
+## Issue Context
+Title: ${title}
+Description: ${description || "(none provided)"}
+${planSection}
+
+${historySection ? `## Conversation
+${historySection}
+` : ""}user: ${message}
+
+Respond concisely and helpfully. Focus on the issue context.`;
+}
+function stripProviderChrome(raw, provider) {
+  let text = raw;
+  if (provider === "codex") {
+    const codexMarker = text.lastIndexOf("\ncodex\n");
+    if (codexMarker >= 0) {
+      text = text.slice(codexMarker + "\ncodex\n".length);
+    } else {
+      const altMarker = text.lastIndexOf("codex\n");
+      if (altMarker >= 0) {
+        text = text.slice(altMarker + "codex\n".length);
+      }
+    }
+    text = text.replace(/tokens used[\s\d,]+/gi, "");
+    text = text.replace(/^Reading prompt from stdin.*$/gm, "");
+    text = text.replace(/^OpenAI Codex v[\d.]+.*$/gm, "");
+    text = text.replace(/^-+$/gm, "");
+    text = text.replace(/^workdir:.*$/gm, "");
+    text = text.replace(/^model:.*$/gm, "");
+    text = text.replace(/^provider:.*$/gm, "");
+    text = text.replace(/^approval:.*$/gm, "");
+    text = text.replace(/^sandbox:.*$/gm, "");
+    text = text.replace(/^reasoning effort:.*$/gm, "");
+    text = text.replace(/^reasoning summaries:.*$/gm, "");
+    text = text.replace(/^session id:.*$/gm, "");
+    text = text.replace(/^user\n/gm, "");
+    const trimmed = text.trim();
+    const half = Math.floor(trimmed.length / 2);
+    if (half > 50) {
+      const first = trimmed.slice(0, half).trim();
+      const second = trimmed.slice(half).trim();
+      if (first === second) {
+        text = first;
+      }
+    }
+  }
+  if (provider === "claude") {
+    try {
+      const parsed = JSON.parse(text.trim());
+      if (parsed && typeof parsed === "object" && typeof parsed.result === "string") {
+        return parsed.result;
+      }
+    } catch {
+    }
+  }
+  if (provider === "gemini") {
+    const lines = text.split("\n");
+    const contentStart = lines.findIndex(
+      (l) => l.trim() && !l.startsWith("Model:") && !l.startsWith("Thinking") && !l.startsWith("\u2500")
+    );
+    if (contentStart > 0) {
+      text = lines.slice(contentStart).join("\n");
+    }
+  }
+  text = text.replace(/\x1b\[[0-9;]*m/g, "");
+  return text.trim();
+}
+async function chatWithIssue(payload, config) {
+  const { provider: selectedProvider, model: selectedModel } = await resolveChatStageConfig(config);
+  const providers = detectAvailableProviders();
+  const isAvailable = providers.some((p) => p.name === selectedProvider && p.available);
+  if (!isAvailable) {
+    const known = providers.map((e) => `${e.name}:${e.available ? "ok" : "missing"}`).join(", ");
+    throw new Error(`Chat provider "${selectedProvider}" is not available. Detected: ${known}`);
+  }
+  const adapter = ADAPTERS[selectedProvider];
+  if (!adapter) throw new Error(`No adapter for provider "${selectedProvider}".`);
+  const caps = resolveProviderCapabilities(selectedProvider);
+  const command = adapter.buildCommand({
+    model: selectedModel,
+    readOnly: caps.readOnlyExecution !== "none"
+  });
+  const prompt = buildChatPrompt(payload);
+  const timeoutMs = config.commandTimeoutMs ?? 6e4;
+  logger.debug({ provider: selectedProvider, issueId: payload.issueId }, "[Chat] Running chat command");
+  const raw = await runOneShot(command, selectedProvider, prompt, timeoutMs);
+  const response = stripProviderChrome(raw, selectedProvider).trim();
+  if (!response) {
+    throw new Error("AI provider returned an empty response.");
+  }
+  logger.info({ provider: selectedProvider, model: selectedModel, issueId: payload.issueId, responseLength: response.length }, "[Chat] Chat response received");
+  return { response, provider: selectedProvider };
+}
+
 // src/routes/plan.ts
 function registerPlanRoutes(app, state) {
   app.get("/api/planning/session", async (c) => {
@@ -11223,12 +10974,44 @@ function registerPlanRoutes(app, state) {
       );
     }
   });
+  app.post("/api/issues/:id/chat", async (c) => {
+    const issueId = c.req.param("id");
+    const issue = state.issues.find((i) => i.id === issueId || i.identifier === issueId);
+    if (!issue) {
+      return c.json({ ok: false, error: "Issue not found." }, 404);
+    }
+    try {
+      const body = await c.req.json();
+      const message = typeof body.message === "string" ? body.message.trim() : "";
+      if (!message) {
+        return c.json({ ok: false, error: "Message is required." }, 400);
+      }
+      const history = Array.isArray(body.history) ? body.history.filter(
+        (m) => typeof m === "object" && m !== null && (m.role === "user" || m.role === "assistant") && typeof m.content === "string"
+      ) : void 0;
+      const result = await chatWithIssue(
+        {
+          issueId: issue.id,
+          title: issue.title,
+          description: issue.description ?? "",
+          plan: issue.plan ?? null,
+          message,
+          history
+        },
+        state.config
+      );
+      return c.json({ ok: true, response: result.response, provider: result.provider });
+    } catch (error) {
+      logger.error({ err: error, issueId }, `Issue chat failed: ${String(error)}`);
+      return c.json({ ok: false, error: error instanceof Error ? error.message : String(error) }, 500);
+    }
+  });
 }
 
 // src/routes/settings.ts
 function registerSettingsRoutes(app, state) {
   app.post("/api/settings/:id", async (c) => {
-    const { updateSetting: updateSetting2 } = await import("./settings.resource-5CW456AZ.js");
+    const { updateSetting: updateSetting2 } = await import("./settings.resource-JMD3JQOS.js");
     return updateSetting2(c);
   });
   app.post("/api/config/concurrency", async (c) => {
@@ -11285,11 +11068,19 @@ function registerSettingsRoutes(app, state) {
       const payload = await c.req.json();
       const workflow = payload.workflow;
       if (!workflow?.plan?.provider || !workflow?.execute?.provider || !workflow?.review?.provider) {
-        return c.json({ ok: false, error: "Invalid workflow config. Each stage needs provider, model, and effort." }, 400);
+        return c.json({ ok: false, error: "Invalid workflow config. plan, execute, and review stages are required with a provider." }, 400);
       }
-      await persistWorkflowConfig(workflow);
-      addEvent(state, void 0, "manual", `Workflow config updated: plan=${workflow.plan.provider}/${workflow.plan.model}, execute=${workflow.execute.provider}/${workflow.execute.model}, review=${workflow.review.provider}/${workflow.review.model}.`);
-      return c.json({ ok: true, workflow });
+      const config = {
+        plan: workflow.plan,
+        execute: workflow.execute,
+        review: workflow.review
+      };
+      if (workflow.enhance?.provider) config.enhance = workflow.enhance;
+      if (workflow.chat?.provider) config.chat = workflow.chat;
+      if (workflow.services?.provider) config.services = workflow.services;
+      await persistWorkflowConfig(config);
+      addEvent(state, void 0, "manual", `Workflow config updated: plan=${config.plan.provider}/${config.plan.model}, execute=${config.execute.provider}/${config.execute.model}, review=${config.review.provider}/${config.review.model}.`);
+      return c.json({ ok: true, workflow: config });
     } catch (error) {
       return c.json({ ok: false, error: error instanceof Error ? error.message : String(error) }, 500);
     }
@@ -11417,8 +11208,8 @@ function registerScanningRoutes(app, _state) {
 }
 
 // src/agents/claude-md-manager.ts
-import { existsSync as existsSync14, readFileSync as readFileSync10, writeFileSync as writeFileSync16 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync11, writeFileSync as writeFileSync16 } from "fs";
+import { join as join23 } from "path";
 var BLOCK_START = "<!-- FIFONY:START \u2014 managed by fifony, do not edit manually -->";
 var BLOCK_END = "<!-- FIFONY:END -->";
 var BLOCK_PATTERN = /<!-- FIFONY:START[^>]*-->[\s\S]*?<!-- FIFONY:END -->/;
@@ -11449,11 +11240,11 @@ function buildManagedBlock(skills, agents, commands) {
 }
 function updateClaudeMdManagedBlock(targetRoot, skills, agents, commands) {
   if (skills.length === 0 && agents.length === 0 && commands.length === 0) return;
-  const claudeMdPath = join22(targetRoot, "CLAUDE.md");
+  const claudeMdPath = join23(targetRoot, "CLAUDE.md");
   const newBlock = buildManagedBlock(skills, agents, commands);
   let existing = "";
   if (existsSync14(claudeMdPath)) {
-    existing = readFileSync10(claudeMdPath, "utf8");
+    existing = readFileSync11(claudeMdPath, "utf8");
   }
   let updated;
   if (BLOCK_PATTERN.test(existing)) {
@@ -11602,14 +11393,14 @@ import {
   appendFileSync,
   existsSync as existsSync15,
   mkdirSync as mkdirSync11,
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync12,
   writeFileSync as writeFileSync17
 } from "fs";
 import { randomUUID as randomUUID3 } from "crypto";
-import { extname as extname3, join as join23 } from "path";
+import { extname as extname3, join as join24 } from "path";
 function registerMiscRoutes(app, state) {
   app.get("/api/queue/stats", async (c) => {
-    const { getQueueStats: getQueueStats2 } = await import("./queue-workers-XFZK3TT5.js");
+    const { getQueueStats: getQueueStats2 } = await import("./queue-workers-V57BYXAY.js");
     return c.json(await getQueueStats2());
   });
   app.get("/api/live/:id/stream", async (c) => {
@@ -11691,11 +11482,11 @@ function registerMiscRoutes(app, state) {
   });
   app.get("/api/gitignore/status", async (c) => {
     try {
-      const gitignorePath = join23(TARGET_ROOT, ".gitignore");
+      const gitignorePath = join24(TARGET_ROOT, ".gitignore");
       if (!existsSync15(gitignorePath)) {
         return c.json({ exists: false, hasFifony: false });
       }
-      const content = readFileSync11(gitignorePath, "utf-8");
+      const content = readFileSync12(gitignorePath, "utf-8");
       const lines = content.split("\n").map((l) => l.trim());
       const hasFifony = lines.some((l) => l === ".fifony" || l === ".fifony/" || l === "/.fifony" || l === "/.fifony/");
       return c.json({ exists: true, hasFifony });
@@ -11706,12 +11497,12 @@ function registerMiscRoutes(app, state) {
   });
   app.post("/api/gitignore/add", async (c) => {
     try {
-      const gitignorePath = join23(TARGET_ROOT, ".gitignore");
+      const gitignorePath = join24(TARGET_ROOT, ".gitignore");
       if (!existsSync15(gitignorePath)) {
         writeFileSync17(gitignorePath, "# Fifony state directory\n.fifony/\n", "utf-8");
         return c.json({ ok: true, created: true });
       }
-      const content = readFileSync11(gitignorePath, "utf-8");
+      const content = readFileSync12(gitignorePath, "utf-8");
       const lines = content.split("\n").map((l) => l.trim());
       const hasFifony = lines.some((l) => l === ".fifony" || l === ".fifony/" || l === "/.fifony" || l === "/.fifony/");
       if (hasFifony) {
@@ -11735,14 +11526,14 @@ function registerMiscRoutes(app, state) {
         return c.json({ ok: false, error: "No files provided." }, 400);
       }
       const uploadId = randomUUID3();
-      const uploadDir = join23(ATTACHMENTS_ROOT, "temp", uploadId);
+      const uploadDir = join24(ATTACHMENTS_ROOT, "temp", uploadId);
       mkdirSync11(uploadDir, { recursive: true });
       const paths = [];
       for (const file of payload.files) {
         if (typeof file.data !== "string" || !file.name) continue;
         const safeExt = extname3(file.name).replace(/[^a-z0-9.]/gi, "").slice(0, 10) || ".bin";
         const safeName = `${randomUUID3()}${safeExt}`;
-        const dest = join23(uploadDir, safeName);
+        const dest = join24(uploadDir, safeName);
         writeFileSync17(dest, Buffer.from(file.data, "base64"));
         paths.push(dest);
       }
@@ -11756,26 +11547,26 @@ function registerMiscRoutes(app, state) {
 
 // src/routes/services.ts
 import {
-  closeSync as closeSync4,
+  closeSync as closeSync2,
   existsSync as existsSync16,
-  openSync as openSync4,
-  readFileSync as readFileSync12,
-  readSync as readSync4,
-  readdirSync as readdirSync5,
-  statSync as statSync5
+  openSync as openSync2,
+  readFileSync as readFileSync13,
+  readSync as readSync2,
+  readdirSync as readdirSync6,
+  statSync as statSync3
 } from "fs";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 function detectServices(targetRoot) {
   const suggestions = [];
-  if (existsSync16(join24(targetRoot, "turbo.json"))) {
+  if (existsSync16(join25(targetRoot, "turbo.json"))) {
     suggestions.push({ label: "All (turbo dev)", command: "pnpm turbo dev", isRoot: true });
   }
-  const pnpmWorkspaceFile = join24(targetRoot, "pnpm-workspace.yaml");
-  const rootPkgFile = join24(targetRoot, "package.json");
+  const pnpmWorkspaceFile = join25(targetRoot, "pnpm-workspace.yaml");
+  const rootPkgFile = join25(targetRoot, "package.json");
   const workspaceParentDirs = [];
   if (existsSync16(pnpmWorkspaceFile)) {
     try {
-      const content = readFileSync12(pnpmWorkspaceFile, "utf8");
+      const content = readFileSync13(pnpmWorkspaceFile, "utf8");
       for (const match of content.matchAll(/^\s+-\s+["']?([^"'\n]+)["']?/gm)) {
         const glob = match[1].trim();
         const parent = glob.replace(/\/\*.*$/, "");
@@ -11787,7 +11578,7 @@ function detectServices(targetRoot) {
     }
   } else if (existsSync16(rootPkgFile)) {
     try {
-      const pkg = JSON.parse(readFileSync12(rootPkgFile, "utf8"));
+      const pkg = JSON.parse(readFileSync13(rootPkgFile, "utf8"));
       if (Array.isArray(pkg.workspaces)) {
         for (const glob of pkg.workspaces) {
           const parent = String(glob).replace(/\/\*.*$/, "");
@@ -11800,16 +11591,16 @@ function detectServices(targetRoot) {
     }
   }
   for (const parent of workspaceParentDirs) {
-    const parentAbs = join24(targetRoot, parent);
+    const parentAbs = join25(targetRoot, parent);
     if (!existsSync16(parentAbs)) continue;
     try {
-      const children = readdirSync5(parentAbs, { withFileTypes: true });
+      const children = readdirSync6(parentAbs, { withFileTypes: true });
       for (const child of children) {
         if (!child.isDirectory()) continue;
-        const childPkg = join24(parentAbs, child.name, "package.json");
+        const childPkg = join25(parentAbs, child.name, "package.json");
         if (!existsSync16(childPkg)) continue;
         try {
-          const pkg = JSON.parse(readFileSync12(childPkg, "utf8"));
+          const pkg = JSON.parse(readFileSync13(childPkg, "utf8"));
           const pkgName = typeof pkg.name === "string" ? pkg.name : child.name;
           const scripts = pkg.scripts ?? {};
           const preferred = ["dev", "start", "serve"];
@@ -11830,10 +11621,10 @@ function detectServices(targetRoot) {
     } catch {
     }
   }
-  const makefile = join24(targetRoot, "Makefile");
+  const makefile = join25(targetRoot, "Makefile");
   if (existsSync16(makefile)) {
     try {
-      const content = readFileSync12(makefile, "utf8");
+      const content = readFileSync13(makefile, "utf8");
       for (const target of ["dev", "start", "serve"]) {
         if (new RegExp(`^${target}:`, "m").test(content)) {
           suggestions.push({ label: `make ${target}`, command: `make ${target}`, isRoot: true });
@@ -11845,7 +11636,7 @@ function detectServices(targetRoot) {
   }
   if (workspaceParentDirs.length === 0 && existsSync16(rootPkgFile)) {
     try {
-      const pkg = JSON.parse(readFileSync12(rootPkgFile, "utf8"));
+      const pkg = JSON.parse(readFileSync13(rootPkgFile, "utf8"));
       const scripts = pkg.scripts ?? {};
       for (const script of ["dev", "start", "serve"]) {
         if (scripts[script]) {
@@ -11856,20 +11647,11 @@ function detectServices(targetRoot) {
     } catch {
     }
   }
-  if (existsSync16(join24(targetRoot, "docker-compose.yml")) || existsSync16(join24(targetRoot, "docker-compose.yaml"))) {
+  if (existsSync16(join25(targetRoot, "docker-compose.yml")) || existsSync16(join25(targetRoot, "docker-compose.yaml"))) {
     suggestions.push({ label: "docker compose up", command: "docker compose up", isRoot: true });
   }
   return suggestions;
 }
-function broadcastTransition(t) {
-  broadcastToWebSocketClients({
-    type: "service",
-    id: t.id,
-    state: t.to,
-    running: t.to === "starting" || t.to === "running",
-    pid: t.pid ?? null
-  });
-}
 function registerServiceRoutes(app, state) {
   app.get("/api/services", (c) => {
     const entries = state.config.services ?? [];
@@ -11891,35 +11673,71 @@ function registerServiceRoutes(app, state) {
     if (!entry) return c.json({ ok: false, error: "Service not found." }, 404);
     return c.json({ ok: true, ...getServiceRuntimeStatus(entry, STATE_ROOT) });
   });
-  app.post("/api/services/:id/start", (c) => {
+  app.post("/api/services/:id/start", async (c) => {
     const id = c.req.param("id");
     const entry = (state.config.services ?? []).find((e) => e.id === id);
     if (!entry) return c.json({ ok: false, error: "Service not found." }, 404);
     try {
-      const globalVars = Object.fromEntries(
-        (state.variables ?? []).filter((v) => v.scope === "global").map((v) => [v.key, v.value])
-      );
-      const serviceVars = Object.fromEntries(
-        (state.variables ?? []).filter((v) => v.scope === entry.id).map((v) => [v.key, v.value])
-      );
-      const mergedEnv = { ...entry.env, ...globalVars, ...serviceVars };
-      const t = startManagedService(entry, TARGET_ROOT, STATE_ROOT, mergedEnv);
-      broadcastTransition(t);
-      startServiceLogBroadcasting(entry.id, STATE_ROOT);
-      return c.json({ ok: true, pid: t.pid, state: t.to });
+      await startManagedService(id);
+      const status = getServiceRuntimeStatus(entry, STATE_ROOT);
+      return c.json({ ok: true, pid: status.pid, state: status.state });
     } catch (err) {
       logger.error({ err }, `[Service] Failed to start ${id}`);
       return c.json({ ok: false, error: String(err) }, 500);
     }
   });
-  app.post("/api/services/:id/stop", (c) => {
+  app.post("/api/services/:id/restart", async (c) => {
+    const id = c.req.param("id");
+    const entry = (state.config.services ?? []).find((e) => e.id === id);
+    if (!entry) return c.json({ ok: false, error: "Service not found." }, 404);
+    try {
+      try {
+        await stopManagedService(id);
+      } catch {
+      }
+      await startManagedService(id);
+      const status = getServiceRuntimeStatus(entry, STATE_ROOT);
+      return c.json({ ok: true, pid: status.pid, state: status.state });
+    } catch (err) {
+      logger.error({ err }, `[Service] Failed to restart ${id}`);
+      return c.json({ ok: false, error: String(err) }, 500);
+    }
+  });
+  app.post("/api/services/:id/stop", async (c) => {
     const id = c.req.param("id");
     const entry = (state.config.services ?? []).find((e) => e.id === id);
     if (!entry) return c.json({ ok: false, error: "Service not found." }, 404);
-    const t = stopManagedService(id, STATE_ROOT);
-    if (t) broadcastTransition(t);
-    stopServiceLogBroadcasting(id);
-    return c.json({ ok: true, state: t?.to ?? "stopped" });
+    try {
+      await stopManagedService(id);
+    } catch {
+    }
+    const status = getServiceRuntimeStatus(entry, STATE_ROOT);
+    return c.json({ ok: true, state: status.state });
+  });
+  app.get("/api/services/:id/health", async (c) => {
+    const id = c.req.param("id");
+    const entry = (state.config.services ?? []).find((e) => e.id === id);
+    if (!entry) return c.json({ ok: false, error: "Service not found." }, 404);
+    const status = getServiceRuntimeStatus(entry, STATE_ROOT);
+    if (!status.running) {
+      return c.json({ ok: false, error: "Service is not running." });
+    }
+    const port = entry.port;
+    if (!port) {
+      return c.json({ ok: false, error: "No port configured." });
+    }
+    const url = entry.healthcheck?.endpoint ?? `http://localhost:${port}`;
+    const start = Date.now();
+    try {
+      const res = await fetch(url, {
+        signal: AbortSignal.timeout(3e3)
+      });
+      const latencyMs = Date.now() - start;
+      return c.json({ ok: true, healthy: res.ok, latencyMs, status: res.status });
+    } catch (err) {
+      const latencyMs = Date.now() - start;
+      return c.json({ ok: true, healthy: false, latencyMs, error: String(err) });
+    }
   });
   app.get("/api/services/:id/log", (c) => {
     const id = c.req.param("id");
@@ -11929,7 +11747,7 @@ function registerServiceRoutes(app, state) {
     let logSize = 0;
     if (existsSync16(logFile)) {
       try {
-        logSize = statSync5(logFile).size;
+        logSize = statSync3(logFile).size;
       } catch {
       }
     }
@@ -11938,10 +11756,10 @@ function registerServiceRoutes(app, state) {
     if (after !== null && !isNaN(after) && after >= 0 && logSize > after) {
       const readSize = logSize - after;
       try {
-        const fd = openSync4(logFile, "r");
+        const fd = openSync2(logFile, "r");
         const buf = Buffer.alloc(readSize);
-        readSync4(fd, buf, 0, readSize, after);
-        closeSync4(fd);
+        readSync2(fd, buf, 0, readSize, after);
+        closeSync2(fd);
         return c.json({ ok: true, text: buf.toString("utf8"), logSize, truncated: false });
       } catch {
         return c.json({ ok: true, text: "", logSize, truncated: false });
@@ -11969,13 +11787,13 @@ function registerServiceRoutes(app, state) {
         let lastSize = 0;
         if (existsSync16(logFile)) {
           try {
-            const stat = statSync5(logFile);
+            const stat = statSync3(logFile);
             lastSize = stat.size;
             const readSize = Math.min(lastSize, 16384);
-            const fd = openSync4(logFile, "r");
+            const fd = openSync2(logFile, "r");
             const buf = Buffer.alloc(readSize);
-            readSync4(fd, buf, 0, readSize, Math.max(0, lastSize - readSize));
-            closeSync4(fd);
+            readSync2(fd, buf, 0, readSize, Math.max(0, lastSize - readSize));
+            closeSync2(fd);
             ctrl.enqueue(sseMsg({ type: "init", text: buf.toString("utf8"), size: lastSize }));
           } catch {
           }
@@ -11985,26 +11803,26 @@ function registerServiceRoutes(app, state) {
         chunkIntervalId = setInterval(() => {
           if (!existsSync16(logFile)) return;
           try {
-            const stat = statSync5(logFile);
+            const stat = statSync3(logFile);
             if (stat.size < lastSize) {
               lastSize = 0;
               const readSize = Math.min(stat.size, 16384);
               let text = "";
               if (readSize > 0) {
-                const fd = openSync4(logFile, "r");
+                const fd = openSync2(logFile, "r");
                 const buf = Buffer.alloc(readSize);
-                readSync4(fd, buf, 0, readSize, 0);
-                closeSync4(fd);
+                readSync2(fd, buf, 0, readSize, 0);
+                closeSync2(fd);
                 text = buf.toString("utf8");
                 lastSize = stat.size;
               }
               ctrl.enqueue(sseMsg({ type: "init", text, size: lastSize }));
             } else if (stat.size > lastSize) {
               const readSize = stat.size - lastSize;
-              const fd = openSync4(logFile, "r");
+              const fd = openSync2(logFile, "r");
               const buf = Buffer.alloc(readSize);
-              readSync4(fd, buf, 0, readSize, lastSize);
-              closeSync4(fd);
+              readSync2(fd, buf, 0, readSize, lastSize);
+              closeSync2(fd);
               lastSize = stat.size;
               ctrl.enqueue(sseMsg({ type: "chunk", text: buf.toString("utf8"), size: lastSize }));
             }
@@ -12045,7 +11863,7 @@ function registerServiceRoutes(app, state) {
   app.post("/api/services/config", async (c) => {
     return replaceServiceConfigs(c, {
       replaceAllServices: async (entries) => {
-        const { replaceAllServices: replaceAllServices2 } = await import("./store-M6NCKMZY.js");
+        const { replaceAllServices: replaceAllServices2 } = await import("./store-S3NAYZ3S.js");
         await replaceAllServices2(entries);
       },
       replacePersistedService: async () => {
@@ -12057,13 +11875,12 @@ function registerServiceRoutes(app, state) {
   app.delete("/api/services/:id", async (c) => {
     const id = c.req.param("id");
     try {
-      const t = stopManagedService(id, STATE_ROOT);
-      if (t) broadcastTransition(t);
+      await stopManagedService(id);
     } catch {
     }
     return deleteServiceConfig(c, {
       deletePersistedService: async (serviceId) => {
-        const { deletePersistedService: deletePersistedService2 } = await import("./store-M6NCKMZY.js");
+        const { deletePersistedService: deletePersistedService2 } = await import("./store-S3NAYZ3S.js");
         await deletePersistedService2(serviceId);
       },
       replacePersistedService: async () => {
@@ -12075,7 +11892,7 @@ function registerServiceRoutes(app, state) {
   app.put("/api/services/:id", async (c) => {
     return upsertServiceConfig(c, {
       replacePersistedService: async (entry) => {
-        const { replacePersistedService: replacePersistedService2 } = await import("./store-M6NCKMZY.js");
+        const { replacePersistedService: replacePersistedService2 } = await import("./store-S3NAYZ3S.js");
         await replacePersistedService2(entry);
       },
       deletePersistedService: async () => {
@@ -12093,13 +11910,13 @@ function registerServiceRoutes(app, state) {
       if (!logTail.trim()) {
         return c.json({ ok: false, error: "Service log is empty \u2014 start the service first." }, 400);
       }
-      const { analyzeLogForHealthcheck } = await import("./log-analyzer-K7MXQB4T.js");
+      const { analyzeLogForHealthcheck } = await import("./log-analyzer-EIX6R6PP.js");
       const healthcheck = await analyzeLogForHealthcheck(logTail, entry.name, state.config);
       if (!healthcheck) {
         return c.json({ ok: true, found: false, healthcheck: null });
       }
       entry.healthcheck = healthcheck;
-      const { replacePersistedService: replacePersistedService2 } = await import("./store-M6NCKMZY.js");
+      const { replacePersistedService: replacePersistedService2 } = await import("./store-S3NAYZ3S.js");
       await replacePersistedService2(entry);
       return c.json({ ok: true, found: true, healthcheck, saved: true });
     } catch (err) {
@@ -12116,7 +11933,7 @@ function registerServiceRoutes(app, state) {
       if (!logTail.trim()) {
         return c.json({ ok: false, error: "Service log is empty \u2014 start the service first." }, 400);
       }
-      const { analyzeLogForFix } = await import("./log-analyzer-K7MXQB4T.js");
+      const { analyzeLogForFix } = await import("./log-analyzer-EIX6R6PP.js");
       const suggestion = await analyzeLogForFix(logTail, entry.name, state.config);
       if (!suggestion) {
         return c.json({ ok: false, error: "Could not parse AI response." }, 422);
@@ -12130,6 +11947,142 @@ function registerServiceRoutes(app, state) {
       return c.json({ ok: false, error: String(err) }, 500);
     }
   });
+  app.post("/api/services/:id/insights", async (c) => {
+    const id = c.req.param("id");
+    const entry = (state.config.services ?? []).find((e) => e.id === id);
+    if (!entry) return c.json({ ok: false, error: "Service not found." }, 404);
+    try {
+      const logTail = readServiceLogTail(id, STATE_ROOT, 16384);
+      if (!logTail.trim()) {
+        return c.json({ ok: false, error: "Service log is empty \u2014 start the service first." }, 400);
+      }
+      const { analyzeLogForInsights } = await import("./log-analyzer-EIX6R6PP.js");
+      const insights = await analyzeLogForInsights(logTail, entry.name, state.config);
+      if (!insights) {
+        return c.json({ ok: false, error: "Could not parse AI response." }, 422);
+      }
+      return c.json({ ok: true, insights });
+    } catch (err) {
+      logger.error({ err, id }, "[Service] insights analysis failed");
+      return c.json({ ok: false, error: String(err) }, 500);
+    }
+  });
+}
+
+// src/routes/traffic.ts
+var MESH_VAR_KEYS = ["HTTP_PROXY", "http_proxy", "NO_PROXY", "no_proxy"];
+function registerTrafficRoutes(collector, state) {
+  collector.get("/api/mesh", (c) => {
+    const graph = getServiceGraph();
+    if (!graph) return c.json({ ok: false, error: "Mesh proxy not running" }, 503);
+    const entries = state.config.services ?? [];
+    const services = listServiceStatuses(entries, STATE_ROOT);
+    return c.json({ ok: true, graph: graph.getGraph(services) });
+  });
+  collector.get("/api/mesh/traffic", (c) => {
+    const buf = getTrafficBuffer();
+    if (!buf) return c.json({ ok: false, error: "Mesh proxy not running" }, 503);
+    const limit = Number(c.req.query("limit") ?? 100);
+    return c.json({ ok: true, entries: buf.getRecent(limit) });
+  });
+  collector.get("/api/mesh/stats", (c) => {
+    const stats = getTrafficProxyStats();
+    if (!stats) return c.json({ ok: false, error: "Mesh proxy not running" }, 503);
+    return c.json({ ok: true, stats });
+  });
+  collector.post("/api/mesh/clear", (c) => {
+    getTrafficBuffer()?.clear();
+    getServiceGraph()?.reset();
+    return c.json({ ok: true });
+  });
+  collector.get("/api/mesh/status", (c) => {
+    return c.json({
+      ok: true,
+      enabled: state.config.meshEnabled ?? false,
+      running: isTrafficProxyRunning(),
+      port: getTrafficProxyPort()
+    });
+  });
+  collector.post("/api/mesh/toggle", async (c) => {
+    const body = await c.req.json();
+    const enabled = body.enabled === true;
+    const { persistSetting: persistSetting2 } = await import("./settings-SOTIS6ZD.js");
+    await persistSetting2("runtime.meshEnabled", enabled, { scope: "runtime", source: "user" });
+    state.config.meshEnabled = enabled;
+    if (enabled && !isTrafficProxyRunning()) {
+      try {
+        setServicesAccessor(() => listServiceStatuses(state.config.services ?? [], STATE_ROOT));
+        const port = await startTrafficProxy({
+          port: state.config.meshProxyPort ?? 0,
+          bufferSize: state.config.meshBufferSize ?? 1e3,
+          onEntry: (entry) => sendToMeshRoom({ type: "mesh:entry", entry })
+        });
+        const dashPort = Number(state.config.dashboardPort ?? 4e3);
+        const servicePorts = (state.config.services ?? []).filter((s) => s.port).map((s) => `localhost:${s.port}`);
+        const noProxyList = [`localhost:${dashPort}`, ...servicePorts].join(",");
+        const proxyUrl = `http://localhost:${port}`;
+        const vars = state.variables ?? [];
+        const ts = (/* @__PURE__ */ new Date()).toISOString();
+        const globalVars = {
+          HTTP_PROXY: proxyUrl,
+          http_proxy: proxyUrl,
+          NO_PROXY: noProxyList,
+          no_proxy: noProxyList
+        };
+        for (const [key, value] of Object.entries(globalVars)) {
+          const id = `global:${key}`;
+          const idx = vars.findIndex((v) => v.id === id);
+          const entry = { id, key, value, scope: "global", updatedAt: ts };
+          if (idx >= 0) vars[idx] = entry;
+          else vars.push(entry);
+        }
+        state.variables = vars;
+        logger.info({ port }, "[Mesh] Proxy started + global env vars injected");
+        const runningServices = (state.config.services ?? []).filter((s) => {
+          const status = getServiceRuntimeStatus(s, STATE_ROOT);
+          return status.running;
+        });
+        for (const svc of runningServices) {
+          try {
+            const { sendServiceEvent: sendServiceEvent2 } = await import("./fsm-service-7O4AJG2R.js");
+            await sendServiceEvent2(svc.id, "STOP");
+            await new Promise((r) => setTimeout(r, 500));
+            await sendServiceEvent2(svc.id, "START");
+            logger.info({ id: svc.id }, "[Mesh] Restarted service to apply proxy env");
+          } catch (err) {
+            logger.warn({ err, id: svc.id }, "[Mesh] Failed to restart service for proxy");
+          }
+        }
+        return c.json({ ok: true, running: true, port, restarted: runningServices.map((s) => s.id) });
+      } catch (err) {
+        logger.error({ err }, "[Mesh] Failed to start proxy");
+        return c.json({ ok: false, error: String(err) }, 500);
+      }
+    }
+    if (!enabled && isTrafficProxyRunning()) {
+      await stopTrafficProxy();
+      state.variables = (state.variables ?? []).filter(
+        (v) => v.scope !== "global" || !MESH_VAR_KEYS.includes(v.key)
+      );
+      logger.info("[Mesh] Proxy stopped + global env vars removed");
+      const runningServices = (state.config.services ?? []).filter((s) => {
+        const status = getServiceRuntimeStatus(s, STATE_ROOT);
+        return status.running;
+      });
+      for (const svc of runningServices) {
+        try {
+          const { sendServiceEvent: sendServiceEvent2 } = await import("./fsm-service-7O4AJG2R.js");
+          await sendServiceEvent2(svc.id, "STOP");
+          await new Promise((r) => setTimeout(r, 500));
+          await sendServiceEvent2(svc.id, "START");
+          logger.info({ id: svc.id }, "[Mesh] Restarted service to remove proxy env");
+        } catch (err) {
+          logger.warn({ err, id: svc.id }, "[Mesh] Failed to restart service after proxy disable");
+        }
+      }
+    }
+    return c.json({ ok: true, running: isTrafficProxyRunning(), port: getTrafficProxyPort() });
+  });
 }
 
 // src/routes/variables.ts
@@ -12141,7 +12094,7 @@ function registerVariableRoutes(app, state) {
   app.put("/api/variables/:id", async (c) => {
     const result = await upsertVariable(c, {
       upsertPersistedVariable: async (entry) => {
-        const { upsertPersistedVariable: upsertPersistedVariable2 } = await import("./store-M6NCKMZY.js");
+        const { upsertPersistedVariable: upsertPersistedVariable2 } = await import("./store-S3NAYZ3S.js");
         await upsertPersistedVariable2(entry);
       }
     });
@@ -12154,7 +12107,7 @@ function registerVariableRoutes(app, state) {
     const id = c.req.param("id");
     const result = await deleteVariable(c, {
       deletePersistedVariable: async (varId) => {
-        const { deletePersistedVariable: deletePersistedVariable2 } = await import("./store-M6NCKMZY.js");
+        const { deletePersistedVariable: deletePersistedVariable2 } = await import("./store-S3NAYZ3S.js");
         await deletePersistedVariable2(varId);
       }
     });
@@ -12170,29 +12123,29 @@ import {
   cpSync as cpSync2,
   existsSync as existsSync17,
   mkdirSync as mkdirSync12,
-  readFileSync as readFileSync13,
-  readdirSync as readdirSync6,
+  readFileSync as readFileSync14,
+  readdirSync as readdirSync7,
   renameSync as renameSync2,
   rmSync as rmSync7,
-  statSync as statSync6,
+  statSync as statSync4,
   writeFileSync as writeFileSync18
 } from "fs";
 import { execSync as execSync8 } from "child_process";
-import { join as join25, resolve as resolve4 } from "path";
+import { join as join26, resolve as resolve3 } from "path";
 var DEV_PROFILE_DEFAULT_PORT = 4100;
 var CLI_CONFIG_DIRS = [".claude", ".codex", ".gemini"];
 var CLI_CONFIG_FILES = ["CLAUDE.md"];
 function resolvePaths(stateRoot, profileName = "dev") {
-  const profileRoot = join25(stateRoot, "profiles", profileName);
+  const profileRoot = join26(stateRoot, "profiles", profileName);
   return {
     profileName,
     profileRoot,
-    workspaceRoot: join25(profileRoot, "workspace"),
-    persistenceRoot: join25(profileRoot, ".fifony"),
-    trashRoot: join25(stateRoot, "trash", "dev-profiles"),
-    runbooksRoot: join25(profileRoot, "runbooks"),
-    bootstrapRoot: join25(profileRoot, "bootstrap"),
-    metadataFile: join25(profileRoot, "profile.json")
+    workspaceRoot: join26(profileRoot, "workspace"),
+    persistenceRoot: join26(profileRoot, ".fifony"),
+    trashRoot: join26(stateRoot, "trash", "dev-profiles"),
+    runbooksRoot: join26(profileRoot, "runbooks"),
+    bootstrapRoot: join26(profileRoot, "bootstrap"),
+    metadataFile: join26(profileRoot, "profile.json")
   };
 }
 function branchNameFor(profileName) {
@@ -12200,7 +12153,7 @@ function branchNameFor(profileName) {
 }
 function readProfileMetadata(paths) {
   try {
-    return existsSync17(paths.metadataFile) ? JSON.parse(readFileSync13(paths.metadataFile, "utf8")) : {};
+    return existsSync17(paths.metadataFile) ? JSON.parse(readFileSync14(paths.metadataFile, "utf8")) : {};
   } catch {
     return {};
   }
@@ -12210,26 +12163,26 @@ function ensureDir(path) {
 }
 function copyCliConfigArtifacts(sourceRoot, workspaceRoot) {
   for (const dir of CLI_CONFIG_DIRS) {
-    const source = join25(sourceRoot, dir);
-    const target = join25(workspaceRoot, dir);
-    if (!existsSync17(source) || existsSync17(target) || !statSync6(source).isDirectory()) continue;
+    const source = join26(sourceRoot, dir);
+    const target = join26(workspaceRoot, dir);
+    if (!existsSync17(source) || existsSync17(target) || !statSync4(source).isDirectory()) continue;
     cpSync2(source, target, { recursive: true });
   }
   for (const file of CLI_CONFIG_FILES) {
-    const source = join25(sourceRoot, file);
-    const target = join25(workspaceRoot, file);
+    const source = join26(sourceRoot, file);
+    const target = join26(workspaceRoot, file);
     if (!existsSync17(source) || existsSync17(target)) continue;
-    writeFileSync18(target, readFileSync13(source));
+    writeFileSync18(target, readFileSync14(source));
   }
 }
 function ensureWorktreeLocalExcludes(workspaceRoot) {
   try {
-    const gitFile = readFileSync13(join25(workspaceRoot, ".git"), "utf8").trim();
+    const gitFile = readFileSync14(join26(workspaceRoot, ".git"), "utf8").trim();
     const gitDirPath = gitFile.replace(/^gitdir:\s*/, "").trim();
-    const resolvedGitDir = resolve4(workspaceRoot, gitDirPath);
-    const excludePath = join25(resolvedGitDir, "info", "exclude");
-    ensureDir(join25(resolvedGitDir, "info"));
-    const current = existsSync17(excludePath) ? readFileSync13(excludePath, "utf8") : "";
+    const resolvedGitDir = resolve3(workspaceRoot, gitDirPath);
+    const excludePath = join26(resolvedGitDir, "info", "exclude");
+    ensureDir(join26(resolvedGitDir, "info"));
+    const current = existsSync17(excludePath) ? readFileSync14(excludePath, "utf8") : "";
     const entries = [
       "WORKFLOW.local.md",
       "FIFONY.md",
@@ -12250,7 +12203,7 @@ function seedProfileFiles(targetRoot, paths, branchName) {
   ensureDir(paths.profileRoot);
   ensureDir(paths.runbooksRoot);
   ensureDir(paths.bootstrapRoot);
-  ensureDir(join25(paths.workspaceRoot, ".fifony-dev"));
+  ensureDir(join26(paths.workspaceRoot, ".fifony-dev"));
   const workflowLocal = [
     "# Dev Workflow",
     "",
@@ -12310,15 +12263,15 @@ function seedProfileFiles(targetRoot, paths, branchName) {
     "- Use analytics to inspect memory/context coverage and layer hit mix.",
     ""
   ].join("\n");
-  writeFileSync18(join25(paths.workspaceRoot, "WORKFLOW.local.md"), `${workflowLocal}
+  writeFileSync18(join26(paths.workspaceRoot, "WORKFLOW.local.md"), `${workflowLocal}
 `, "utf8");
-  writeFileSync18(join25(paths.workspaceRoot, "FIFONY.md"), `${fifonyMd}
+  writeFileSync18(join26(paths.workspaceRoot, "FIFONY.md"), `${fifonyMd}
 `, "utf8");
-  writeFileSync18(join25(paths.runbooksRoot, "doctor.md"), `${doctorRunbook}
+  writeFileSync18(join26(paths.runbooksRoot, "doctor.md"), `${doctorRunbook}
 `, "utf8");
-  writeFileSync18(join25(paths.runbooksRoot, "services.md"), `${servicesRunbook}
+  writeFileSync18(join26(paths.runbooksRoot, "services.md"), `${servicesRunbook}
 `, "utf8");
-  writeFileSync18(join25(paths.runbooksRoot, "context.md"), `${contextRunbook}
+  writeFileSync18(join26(paths.runbooksRoot, "context.md"), `${contextRunbook}
 `, "utf8");
   writeFileSync18(paths.metadataFile, JSON.stringify({
     profileName: paths.profileName,
@@ -12344,7 +12297,7 @@ function getDevProfileStatus(targetRoot, stateRoot, profileName = "dev") {
   const paths = resolvePaths(stateRoot, profileName);
   const metadata = readProfileMetadata(paths);
   const branchName = branchNameFor(profileName);
-  const trashEntries = existsSync17(paths.trashRoot) ? readdirSync6(paths.trashRoot).filter((entry) => entry.startsWith(`${profileName}-`)).sort().reverse() : [];
+  const trashEntries = existsSync17(paths.trashRoot) ? readdirSync7(paths.trashRoot).filter((entry) => entry.startsWith(`${profileName}-`)).sort().reverse() : [];
   return {
     profileName,
     profileRoot: paths.profileRoot,
@@ -12355,12 +12308,12 @@ function getDevProfileStatus(targetRoot, stateRoot, profileName = "dev") {
     dashboardPort: DEV_PROFILE_DEFAULT_PORT,
     workspaceExists: existsSync17(paths.workspaceRoot),
     persistenceExists: existsSync17(paths.persistenceRoot),
-    bootstrapped: existsSync17(join25(paths.workspaceRoot, "WORKFLOW.local.md")) && existsSync17(join25(paths.workspaceRoot, "FIFONY.md")),
+    bootstrapped: existsSync17(join26(paths.workspaceRoot, "WORKFLOW.local.md")) && existsSync17(join26(paths.workspaceRoot, "FIFONY.md")),
     worktreeAttached: isWorktreeAttached(targetRoot, paths.workspaceRoot),
     bootstrapFiles: {
-      workflowLocal: existsSync17(join25(paths.workspaceRoot, "WORKFLOW.local.md")),
-      fifony: existsSync17(join25(paths.workspaceRoot, "FIFONY.md")),
-      runbooks: existsSync17(paths.runbooksRoot) ? readdirSync6(paths.runbooksRoot).sort() : []
+      workflowLocal: existsSync17(join26(paths.workspaceRoot, "WORKFLOW.local.md")),
+      fifony: existsSync17(join26(paths.workspaceRoot, "FIFONY.md")),
+      runbooks: existsSync17(paths.runbooksRoot) ? readdirSync7(paths.runbooksRoot).sort() : []
     },
     trashEntries,
     launchCommand: `fifony dev run --workspace "${targetRoot}" --port ${DEV_PROFILE_DEFAULT_PORT}`,
@@ -12414,7 +12367,7 @@ function resetDevProfile(targetRoot, stateRoot, profileName = "dev") {
     };
   }
   ensureDir(paths.trashRoot);
-  const trashPath = join25(paths.trashRoot, `${profileName}-${Date.now()}`);
+  const trashPath = join26(paths.trashRoot, `${profileName}-${Date.now()}`);
   const metadata = readProfileMetadata(paths);
   writeFileSync18(paths.metadataFile, JSON.stringify({
     ...metadata,
@@ -12468,6 +12421,430 @@ function registerDevProfileRoutes(app) {
   });
 }
 
+// src/agents/chat/chat-session.ts
+import { existsSync as existsSync18, mkdirSync as mkdirSync13, readFileSync as readFileSync15, writeFileSync as writeFileSync19, rmSync as rmSync8, readdirSync as readdirSync8 } from "fs";
+import { join as join27 } from "path";
+var CHAT_DIR = join27(STATE_ROOT, "chat-sessions");
+function ensureChatDir() {
+  mkdirSync13(CHAT_DIR, { recursive: true });
+}
+function sessionPath(issueId) {
+  return join27(CHAT_DIR, `issue-${issueId}.json`);
+}
+async function loadChatSession(issueId) {
+  const path = sessionPath(issueId);
+  if (!existsSync18(path)) return null;
+  try {
+    return JSON.parse(readFileSync15(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function persistChatSession(session) {
+  ensureChatDir();
+  session.updatedAt = now();
+  writeFileSync19(sessionPath(session.issueId), JSON.stringify(session, null, 2), "utf8");
+}
+async function createIssueChat(issueId, cli, existingTurns) {
+  const ts = now();
+  const session = {
+    issueId,
+    cli,
+    turns: existingTurns ?? [],
+    createdAt: ts,
+    updatedAt: ts
+  };
+  await persistChatSession(session);
+  logger.debug({ issueId, provider: cli.provider }, "[Chat] Issue chat created");
+  return session;
+}
+async function deleteChatSession(issueId) {
+  try {
+    rmSync8(sessionPath(issueId), { force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listChatSessions() {
+  ensureChatDir();
+  try {
+    const files = readdirSync8(CHAT_DIR).filter((f) => f.startsWith("issue-") && f.endsWith(".json"));
+    const sessions = [];
+    for (const file of files) {
+      try {
+        const raw = readFileSync15(join27(CHAT_DIR, file), "utf8");
+        sessions.push(JSON.parse(raw));
+      } catch {
+      }
+    }
+    return sessions.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  } catch (err) {
+    logger.warn({ err }, "[Chat] Failed to list sessions");
+    return [];
+  }
+}
+function appendTurn(session, turn) {
+  session.turns.push({ ...turn, timestamp: now() });
+}
+function sessionFileToMeta(session) {
+  return {
+    id: session.issueId,
+    name: `Issue ${session.issueId}`,
+    status: "active",
+    provider: session.cli.provider,
+    turns: session.turns,
+    createdAt: session.createdAt,
+    updatedAt: session.updatedAt
+  };
+}
+
+// src/agents/chat/chat-prompt.ts
+function buildGlobalChatPrompt(state) {
+  const projectName = state.projectName || state.detectedProjectName || "unnamed project";
+  const issueRows = state.issues.slice(0, 20).map(
+    (i) => `| ${i.identifier} | ${i.title.slice(0, 50)} | ${i.state} |`
+  );
+  const issuesSection = issueRows.length ? `## Current Issues
+| ID | Title | State |
+|---|---|---|
+${issueRows.join("\n")}` : "## Current Issues\nNo issues.";
+  const services = state.config.services ?? [];
+  const serviceRows = services.slice(0, 10).map(
+    (s) => `| ${s.name} | ${s.port ?? "-"} |`
+  );
+  const servicesSection = serviceRows.length ? `## Services
+| Name | Port |
+|---|---|
+${serviceRows.join("\n")}` : "## Services\nNo services configured.";
+  return `You are Spark, an AI assistant for the project "${projectName}".
+You can discuss the project, answer questions, and perform operations.
+
+${issuesSection}
+
+${servicesSection}
+
+## Available Actions
+
+To perform an operation, emit a fenced code block with the \`action\` language tag containing valid JSON:
+
+\`\`\`action
+{ "type": "<action-type>", "payload": { ... } }
+\`\`\`
+
+### Action types:
+
+**Issue operations:**
+- \`create-issue\` \u2014 payload: \`{ "title": string, "description"?: string }\`
+- \`retry-issue\` \u2014 payload: \`{ "issueId": string, "feedback"?: string }\`
+- \`replan-issue\` \u2014 payload: \`{ "issueId": string }\`
+- \`approve-issue\` \u2014 payload: \`{ "issueId": string }\`
+- \`merge-issue\` \u2014 payload: \`{ "issueId": string }\`
+
+**Service operations:**
+- \`start-service\` \u2014 payload: \`{ "id": string }\`
+- \`stop-service\` \u2014 payload: \`{ "id": string }\`
+- \`restart-service\` \u2014 payload: \`{ "id": string }\`
+
+**Read operations:**
+- \`read-file\` \u2014 payload: \`{ "path": string }\`
+- \`read-service-log\` \u2014 payload: \`{ "id": string, "bytes"?: number }\`
+- \`list-issues\` \u2014 payload: \`{}\`
+- \`list-services\` \u2014 payload: \`{}\`
+
+You may emit multiple action blocks in one response. Only emit actions when the user explicitly asks for an operation.
+
+## Response format
+Always respond in **Markdown**. Use headings, bullet lists, numbered lists, bold, inline code, and code blocks to structure your answers. Keep responses concise and well-formatted.`;
+}
+
+// src/agents/chat/action-parser.ts
+var VALID_ACTION_TYPES = /* @__PURE__ */ new Set([
+  "create-issue",
+  "retry-issue",
+  "replan-issue",
+  "approve-issue",
+  "merge-issue",
+  "start-service",
+  "stop-service",
+  "restart-service",
+  "read-file",
+  "read-service-log",
+  "list-issues",
+  "list-services"
+]);
+var ACTION_BLOCK_RE = /```action\n([\s\S]*?)```/g;
+function parseActionsFromResponse(text) {
+  const actions = [];
+  for (const match of text.matchAll(ACTION_BLOCK_RE)) {
+    const raw = match[1]?.trim();
+    if (!raw) continue;
+    try {
+      const parsed = JSON.parse(raw);
+      const type = parsed.type;
+      if (!VALID_ACTION_TYPES.has(type)) continue;
+      actions.push({
+        type,
+        payload: parsed.payload ?? {}
+      });
+    } catch {
+    }
+  }
+  return actions;
+}
+
+// src/agents/chat/action-executor.ts
+import { readFileSync as readFileSync16 } from "fs";
+import { resolve as resolve4, normalize } from "path";
+async function executeChatAction(action, state) {
+  try {
+    switch (action.type) {
+      case "list-issues":
+        return {
+          ok: true,
+          result: state.issues.map((i) => ({
+            id: i.id,
+            identifier: i.identifier,
+            title: i.title,
+            state: i.state
+          }))
+        };
+      case "list-services": {
+        const fifonyDir = resolve4(TARGET_ROOT, ".fifony");
+        const statuses = listServiceStatuses(state.config.services ?? [], fifonyDir);
+        return {
+          ok: true,
+          result: statuses.map((s) => ({
+            id: s.id,
+            name: s.name,
+            state: s.state,
+            port: s.port,
+            running: s.running
+          }))
+        };
+      }
+      case "read-file": {
+        const rawPath = String(action.payload.path ?? "");
+        const absPath = normalize(resolve4(TARGET_ROOT, rawPath));
+        if (!absPath.startsWith(TARGET_ROOT)) {
+          return { ok: false, result: null, error: "Path is outside the project root." };
+        }
+        const content = readFileSync16(absPath, "utf8");
+        return { ok: true, result: content.length > 8e3 ? content.slice(0, 8e3) + "\n...(truncated)" : content };
+      }
+      case "read-service-log": {
+        const id = String(action.payload.id ?? "");
+        if (!id) return { ok: false, result: null, error: "Service id is required." };
+        const fifonyDir = resolve4(TARGET_ROOT, ".fifony");
+        const bytes = typeof action.payload.bytes === "number" ? action.payload.bytes : 8192;
+        const log = readServiceLogTail(id, fifonyDir, bytes);
+        return { ok: true, result: log || "(no log output)" };
+      }
+      case "start-service": {
+        const id = String(action.payload.id ?? "");
+        if (!id) return { ok: false, result: null, error: "Service id is required." };
+        await startManagedService(id);
+        return { ok: true, result: `Service ${id} start requested.` };
+      }
+      case "stop-service": {
+        const id = String(action.payload.id ?? "");
+        if (!id) return { ok: false, result: null, error: "Service id is required." };
+        await stopManagedService(id);
+        return { ok: true, result: `Service ${id} stop requested.` };
+      }
+      case "restart-service": {
+        const id = String(action.payload.id ?? "");
+        if (!id) return { ok: false, result: null, error: "Service id is required." };
+        await stopManagedService(id);
+        await new Promise((r) => setTimeout(r, 500));
+        await startManagedService(id);
+        return { ok: true, result: `Service ${id} restart requested.` };
+      }
+      case "create-issue": {
+        const { createIssueCommand: createIssueCommand2 } = await import("./create-issue.command-VAKYRECC.js");
+        const container = getContainer();
+        const payload = {
+          title: String(action.payload.title ?? ""),
+          description: String(action.payload.description ?? "")
+        };
+        if (!payload.title) return { ok: false, result: null, error: "Title is required." };
+        const { issue } = await createIssueCommand2({ payload, state }, container);
+        await persistState(state);
+        return { ok: true, result: { id: issue.id, identifier: issue.identifier, title: issue.title, state: issue.state } };
+      }
+      case "retry-issue": {
+        const { retryIssueCommand: retryIssueCommand2 } = await import("./retry-issue.command-GJBUUYDJ.js");
+        const container = getContainer();
+        const issue = findIssue3(state, String(action.payload.issueId ?? ""));
+        if (!issue) return { ok: false, result: null, error: "Issue not found." };
+        const feedback = action.payload.feedback ? String(action.payload.feedback) : void 0;
+        await retryIssueCommand2({ issue, feedback }, container);
+        await persistState(state);
+        return { ok: true, result: `Retry requested for ${issue.identifier}.` };
+      }
+      case "replan-issue": {
+        const { replanIssueCommand: replanIssueCommand2 } = await import("./replan-issue.command-2GQ3QXCR.js");
+        const container = getContainer();
+        const issue = findIssue3(state, String(action.payload.issueId ?? ""));
+        if (!issue) return { ok: false, result: null, error: "Issue not found." };
+        await replanIssueCommand2({ issue }, container);
+        await persistState(state);
+        return { ok: true, result: `Replan requested for ${issue.identifier}.` };
+      }
+      case "approve-issue": {
+        const { approvePlanCommand: approvePlanCommand2 } = await import("./approve-plan.command-QGQZZXTQ.js");
+        const container = getContainer();
+        const issue = findIssue3(state, String(action.payload.issueId ?? ""));
+        if (!issue) return { ok: false, result: null, error: "Issue not found." };
+        await approvePlanCommand2({ issue }, container);
+        await persistState(state);
+        return { ok: true, result: `Plan approved for ${issue.identifier}.` };
+      }
+      case "merge-issue": {
+        const { mergeWorkspaceCommand: mergeWorkspaceCommand2 } = await import("./merge-workspace.command-T2NIGR4M.js");
+        const container = getContainer();
+        const issue = findIssue3(state, String(action.payload.issueId ?? ""));
+        if (!issue) return { ok: false, result: null, error: "Issue not found." };
+        const result = await mergeWorkspaceCommand2({ issue, state }, container);
+        await persistState(state);
+        return { ok: true, result: { merged: true, conflicts: result.conflicts.length } };
+      }
+      default:
+        return { ok: false, result: null, error: `Unknown action type: ${action.type}` };
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.error({ err, action: action.type }, "[Chat] Action execution failed");
+    return { ok: false, result: null, error: msg };
+  }
+}
+function findIssue3(state, issueId) {
+  return state.issues.find((i) => i.id === issueId || i.identifier === issueId);
+}
+
+// src/routes/chat.ts
+function registerChatRoutes(app, state) {
+  app.get("/api/chat/sessions", async (c) => {
+    try {
+      const sessions = await listChatSessions();
+      return c.json({ ok: true, sessions: sessions.map(sessionFileToMeta) });
+    } catch (err) {
+      return c.json({ ok: false, error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+  app.get("/api/chat/sessions/:id", async (c) => {
+    const id = c.req.param("id");
+    if (!id) return c.json({ ok: false, error: "Issue id is required." }, 400);
+    try {
+      const session = await loadChatSession(id);
+      if (!session) return c.json({ ok: false, error: "No chat session for this issue." }, 404);
+      return c.json({ ok: true, session: sessionFileToMeta(session) });
+    } catch (err) {
+      return c.json({ ok: false, error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+  app.delete("/api/chat/sessions/:id", async (c) => {
+    const id = c.req.param("id");
+    if (!id) return c.json({ ok: false, error: "Issue id is required." }, 400);
+    try {
+      await deleteChatSession(id);
+      return c.json({ ok: true });
+    } catch (err) {
+      return c.json({ ok: false, error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+  app.post("/api/chat", async (c) => {
+    try {
+      const body = await c.req.json();
+      const message = toStringValue(body.message, "").trim();
+      if (!message) return c.json({ ok: false, error: "Message is required." }, 400);
+      const issueId = typeof body.issueId === "string" ? body.issueId : void 0;
+      const historyRaw = Array.isArray(body.history) ? body.history : [];
+      const history = historyRaw.filter((t) => (t.role === "user" || t.role === "assistant") && typeof t.content === "string").map((t) => ({ role: t.role, content: t.content }));
+      let session = null;
+      if (issueId) {
+        session = await loadChatSession(issueId);
+        if (session) {
+          const persistedHistory = session.turns.filter((t) => t.role === "user" || t.role === "assistant").map((t) => ({ role: t.role, content: t.content }));
+          history.length = 0;
+          history.push(...persistedHistory);
+        }
+      }
+      const systemPrompt = buildGlobalChatPrompt(state);
+      const issue = issueId ? state.issues.find((i) => i.id === issueId) : null;
+      const result = await chatWithIssue(
+        {
+          issueId: issueId || "global-chat",
+          title: issue?.title || "Global Chat",
+          description: issue ? `${issue.description}
+
+---
+
+${systemPrompt}` : systemPrompt,
+          plan: issue?.plan ?? null,
+          message,
+          history
+        },
+        state.config
+      );
+      const actions = parseActionsFromResponse(result.response);
+      if (issueId) {
+        if (!session) {
+          session = await createIssueChat(issueId, { provider: result.provider });
+        }
+        appendTurn(session, { role: "user", content: message });
+        appendTurn(session, {
+          role: "assistant",
+          content: result.response,
+          actions: actions.length > 0 ? actions : void 0
+        });
+        session.cli = { provider: result.provider };
+        await persistChatSession(session);
+      }
+      logger.info(
+        { issueId: issueId || "temporary", provider: result.provider, actions: actions.length },
+        "[Chat] Message processed"
+      );
+      return c.json({
+        ok: true,
+        response: result.response,
+        actions,
+        issueId: issueId || null,
+        provider: result.provider
+      });
+    } catch (err) {
+      logger.error({ err }, "[Chat] POST /api/chat failed");
+      return c.json({ ok: false, error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+  app.post("/api/chat/link", async (c) => {
+    try {
+      const body = await c.req.json();
+      const issueId = typeof body.issueId === "string" ? body.issueId : "";
+      if (!issueId) return c.json({ ok: false, error: "issueId is required." }, 400);
+      const turns = Array.isArray(body.turns) ? body.turns : [];
+      const provider = typeof body.provider === "string" ? body.provider : state.config.agentProvider;
+      const session = await createIssueChat(issueId, { provider }, turns);
+      logger.info({ issueId, turns: turns.length }, "[Chat] Linked temporary chat to issue");
+      return c.json({ ok: true, session: sessionFileToMeta(session) });
+    } catch (err) {
+      return c.json({ ok: false, error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+  app.post("/api/chat/action", async (c) => {
+    try {
+      const body = await c.req.json();
+      const action = body.action;
+      if (!action?.type) return c.json({ ok: false, error: "Action is required." }, 400);
+      const result = await executeChatAction(action, state);
+      return c.json(result);
+    } catch (err) {
+      logger.error({ err }, "[Chat] Action execution failed");
+      return c.json({ ok: false, error: err instanceof Error ? err.message : String(err) }, 500);
+    }
+  });
+}
+
 // src/persistence/plugins/api-server.ts
 var RouteCollector = class {
   routes = {};
@@ -12512,10 +12889,10 @@ async function startApiServer(state, port, _options) {
   }
   setApiRuntimeContext(state);
   const serveTextFile = (filePath, contentType, cacheControl = "no-cache") => {
-    if (!existsSync18(filePath)) {
+    if (!existsSync19(filePath)) {
       return new Response("Not found", { status: 404 });
     }
-    return new Response(readFileSync14(filePath), {
+    return new Response(readFileSync17(filePath), {
       headers: {
         "content-type": contentType,
         "cache-control": cacheControl
@@ -12530,17 +12907,41 @@ async function startApiServer(state, port, _options) {
         headers: { location: `http://localhost:${devPort}${path ?? "/"}` }
       });
     }
-    if (!existsSync18(FRONTEND_INDEX)) {
+    if (!existsSync19(FRONTEND_INDEX)) {
       return new Response("Not found", { status: 404 });
     }
-    const html = readFileSync14(FRONTEND_INDEX, "utf8").replace('href="/assets/manifest.webmanifest"', 'href="/manifest.webmanifest"').replaceAll('href="/assets/icon.svg"', 'href="/icon.svg"');
-    return new Response(html, {
+    return new Response(readFileSync17(FRONTEND_INDEX, "utf8"), {
       headers: {
         "content-type": "text/html; charset=utf-8",
         "cache-control": "no-cache"
       }
     });
   };
+  const rootStaticAssets = Object.fromEntries(
+    [
+      "favicon.png",
+      "apple-touch-icon.png",
+      "og-image.png",
+      "dinofffaur.png",
+      "dinofffaur.webp",
+      "icon-16.png",
+      "icon-32.png",
+      "icon-48.png",
+      "icon-72.png",
+      "icon-96.png",
+      "icon-128.png",
+      "icon-144.png",
+      "icon-152.png",
+      "icon-192.png",
+      "icon-384.png",
+      "icon-512.png",
+      "icon-maskable-192.png",
+      "icon-maskable-512.png"
+    ].map((file) => [
+      `GET /${file}`,
+      () => serveTextFile(`${FRONTEND_DIR}/${file}`, "image/png", "public, max-age=604800, immutable")
+    ])
+  );
   const appShellRoutes = Object.fromEntries(
     APP_SHELL_ROUTES.map((path) => [`GET ${path}`, () => serveAppShell(path)])
   );
@@ -12554,8 +12955,10 @@ async function startApiServer(state, port, _options) {
   registerReferenceRepositoryRoutes(collector);
   registerMiscRoutes(collector, state);
   registerServiceRoutes(collector, state);
+  registerTrafficRoutes(collector, state);
   registerVariableRoutes(collector, state);
   registerDevProfileRoutes(collector);
+  registerChatRoutes(collector, state);
   const apiPlugin = new ApiPlugin({
     port,
     host: "0.0.0.0",
@@ -12577,7 +12980,7 @@ async function startApiServer(state, port, _options) {
     static: [{
       driver: "filesystem",
       path: "/assets",
-      root: FRONTEND_DIR,
+      root: `${FRONTEND_DIR}/assets`,
       pwa: false,
       config: { etag: true }
     }],
@@ -12602,6 +13005,7 @@ async function startApiServer(state, port, _options) {
       "GET /offline.html": () => serveTextFile(FRONTEND_OFFLINE_HTML, "text/html; charset=utf-8"),
       "GET /icon.svg": () => serveTextFile(FRONTEND_ICON_SVG, "image/svg+xml", "public, max-age=604800, immutable"),
       "GET /icon-maskable.svg": () => serveTextFile(FRONTEND_MASKABLE_ICON_SVG, "image/svg+xml", "public, max-age=604800, immutable"),
+      ...rootStaticAssets,
       ...appShellRoutes,
       "GET /api/health": (c) => c.json({ status: state.booting ? "booting" : "ready" })
     }
@@ -12631,6 +13035,7 @@ var variablesResource = null;
 var contextFragmentResource = null;
 var activeApiPlugin = null;
 var activeStateMachinePlugin = null;
+var activeServiceStateMachinePlugin = null;
 var activeEcPlugin = null;
 function getStateDb() {
   return stateDb;
@@ -12792,6 +13197,18 @@ async function initStateStore() {
   } else {
     logger.warn("StateMachinePlugin not available. Issue transitions will use local logic only.");
   }
+  if (StateMachinePlugin) {
+    try {
+      const serviceSmPlugin = await stateDb.usePlugin(
+        new StateMachinePlugin(serviceStateMachineConfig),
+        "service-state-machine"
+      );
+      activeServiceStateMachinePlugin = serviceSmPlugin;
+      logger.info("Service StateMachinePlugin installed.");
+    } catch (error) {
+      logger.warn(`Service StateMachinePlugin failed to install: ${String(error)}`);
+    }
+  }
   const { EventualConsistencyPlugin } = await loadS3dbModule();
   if (EventualConsistencyPlugin) {
     try {
@@ -12867,6 +13284,15 @@ async function initStateStore() {
     });
     debugBoot("initStateStore:resource-state-api-bound");
   }
+  if (serviceResource && serviceResource.state) {
+    const svcStateApi = serviceResource.state;
+    setServiceResourceStateApi({
+      send: svcStateApi.send?.bind(svcStateApi),
+      get: svcStateApi.get?.bind(svcStateApi),
+      initialize: svcStateApi.initialize?.bind(svcStateApi)
+    });
+    debugBoot("initStateStore:service-resource-state-api-bound");
+  }
   debugBoot("initStateStore:resources-ready");
 }
 function isStateNotFoundError(error) {
@@ -13183,7 +13609,7 @@ async function closeStateStore() {
   logger.info("[Store] Closing state store and plugins");
   clearApiRuntimeContext();
   try {
-    const { stopQueueWorkers: stopQueueWorkers2 } = await import("./queue-workers-XFZK3TT5.js");
+    const { stopQueueWorkers: stopQueueWorkers2 } = await import("./queue-workers-V57BYXAY.js");
     await stopQueueWorkers2();
   } catch (error) {
     logger.warn(`Failed to stop queue workers: ${String(error)}`);
@@ -13197,6 +13623,15 @@ async function closeStateStore() {
       activeEcPlugin = null;
     }
   }
+  if (activeServiceStateMachinePlugin?.stop) {
+    try {
+      await activeServiceStateMachinePlugin.stop();
+    } catch (error) {
+      logger.warn(`Failed to stop Service StateMachine plugin: ${String(error)}`);
+    } finally {
+      activeServiceStateMachinePlugin = null;
+    }
+  }
   if (activeStateMachinePlugin?.stop) {
     try {
       await activeStateMachinePlugin.stop();
@@ -13275,6 +13710,13 @@ var SETTING_ID_ADAPTIVE_HARNESS_SELECTION = "runtime.adaptiveHarnessSelection";
 var SETTING_ID_ADAPTIVE_REVIEW_ROUTING = "runtime.adaptiveReviewRouting";
 var SETTING_ID_ADAPTIVE_POLICY_MIN_SAMPLES = "runtime.adaptivePolicyMinSamples";
 var SETTING_ID_SERVICE_ENV = "runtime.serviceEnv";
+var SETTING_ID_MESH_ENABLED = "runtime.meshEnabled";
+var SETTING_ID_MESH_PROXY_PORT = "runtime.meshProxyPort";
+var SETTING_ID_MESH_BUFFER_SIZE = "runtime.meshBufferSize";
+var SETTING_ID_AUTO_APPROVE_TRIVIAL_PLANS = "runtime.autoApproveTrivialPlans";
+var SETTING_ID_AUTO_COMMIT_BEFORE_MERGE = "runtime.autoCommitBeforeMerge";
+var SETTING_ID_AUTO_RESOLVE_CONFLICTS = "runtime.autoResolveConflicts";
+var SETTING_ID_SANDBOX_EXECUTION = "runtime.sandboxExecution";
 async function loadRuntimeSettings() {
   return loadPersistedSettings();
 }
@@ -13304,7 +13746,14 @@ var RUNTIME_CONFIG_SETTING_IDS = /* @__PURE__ */ new Set([
   SETTING_ID_ADAPTIVE_HARNESS_SELECTION,
   SETTING_ID_ADAPTIVE_REVIEW_ROUTING,
   SETTING_ID_ADAPTIVE_POLICY_MIN_SAMPLES,
-  SETTING_ID_SERVICE_ENV
+  SETTING_ID_SERVICE_ENV,
+  SETTING_ID_MESH_ENABLED,
+  SETTING_ID_MESH_PROXY_PORT,
+  SETTING_ID_MESH_BUFFER_SIZE,
+  SETTING_ID_AUTO_APPROVE_TRIVIAL_PLANS,
+  SETTING_ID_AUTO_COMMIT_BEFORE_MERGE,
+  SETTING_ID_AUTO_RESOLVE_CONFLICTS,
+  SETTING_ID_SANDBOX_EXECUTION
 ]);
 var VALID_REASONING_EFFORTS = /* @__PURE__ */ new Set(["low", "medium", "high", "extra-high"]);
 function parseIntegerSetting(value) {
@@ -13377,7 +13826,14 @@ function buildRuntimeConfigSettings(config, source) {
     { id: SETTING_ID_ADAPTIVE_HARNESS_SELECTION, scope: "runtime", value: config.adaptiveHarnessSelection !== false, source, updatedAt },
     { id: SETTING_ID_ADAPTIVE_REVIEW_ROUTING, scope: "runtime", value: config.adaptiveReviewRouting !== false, source, updatedAt },
     { id: SETTING_ID_ADAPTIVE_POLICY_MIN_SAMPLES, scope: "runtime", value: config.adaptivePolicyMinSamples ?? DEFAULT_ADAPTIVE_POLICY_MIN_SAMPLES, source, updatedAt },
-    { id: SETTING_ID_SERVICE_ENV, scope: "runtime", value: config.serviceEnv ?? {}, source, updatedAt }
+    { id: SETTING_ID_SERVICE_ENV, scope: "runtime", value: config.serviceEnv ?? {}, source, updatedAt },
+    { id: SETTING_ID_MESH_ENABLED, scope: "runtime", value: config.meshEnabled ?? false, source, updatedAt },
+    { id: SETTING_ID_MESH_PROXY_PORT, scope: "runtime", value: config.meshProxyPort ?? 0, source, updatedAt },
+    { id: SETTING_ID_MESH_BUFFER_SIZE, scope: "runtime", value: config.meshBufferSize ?? 1e3, source, updatedAt },
+    { id: SETTING_ID_AUTO_APPROVE_TRIVIAL_PLANS, scope: "runtime", value: config.autoApproveTrivialPlans ?? true, source, updatedAt },
+    { id: SETTING_ID_AUTO_COMMIT_BEFORE_MERGE, scope: "runtime", value: config.autoCommitBeforeMerge ?? true, source, updatedAt },
+    { id: SETTING_ID_AUTO_RESOLVE_CONFLICTS, scope: "runtime", value: config.autoResolveConflicts ?? false, source, updatedAt },
+    { id: SETTING_ID_SANDBOX_EXECUTION, scope: "runtime", value: config.sandboxExecution ?? false, source, updatedAt }
   ];
 }
 function applyPersistedSettings(config, settings) {
@@ -13544,6 +14000,40 @@ function applyPersistedSettings(config, settings) {
         }
         break;
       }
+      case SETTING_ID_MESH_ENABLED: {
+        nextConfig.meshEnabled = setting.value === true || setting.value === "true";
+        break;
+      }
+      case SETTING_ID_MESH_PROXY_PORT: {
+        const parsed = Number(setting.value);
+        if (!Number.isNaN(parsed) && parsed >= 0 && parsed <= 65535) {
+          nextConfig.meshProxyPort = parsed;
+        }
+        break;
+      }
+      case SETTING_ID_MESH_BUFFER_SIZE: {
+        const parsed = Number(setting.value);
+        if (!Number.isNaN(parsed) && parsed >= 100 && parsed <= 1e4) {
+          nextConfig.meshBufferSize = parsed;
+        }
+        break;
+      }
+      case SETTING_ID_AUTO_APPROVE_TRIVIAL_PLANS: {
+        nextConfig.autoApproveTrivialPlans = toBooleanValue(setting.value, true);
+        break;
+      }
+      case SETTING_ID_AUTO_COMMIT_BEFORE_MERGE: {
+        nextConfig.autoCommitBeforeMerge = toBooleanValue(setting.value, true);
+        break;
+      }
+      case SETTING_ID_AUTO_RESOLVE_CONFLICTS: {
+        nextConfig.autoResolveConflicts = toBooleanValue(setting.value, false);
+        break;
+      }
+      case SETTING_ID_SANDBOX_EXECUTION: {
+        nextConfig.sandboxExecution = toBooleanValue(setting.value, false);
+        break;
+      }
       default:
         break;
     }
@@ -13619,26 +14109,62 @@ function buildDefaultWorkflowConfig(detectedProviders, discoveredModels) {
   const claudeDefault = { provider: "claude", model: claudeModel, effort: "medium" };
   const codexDefault = { provider: "codex", model: codexModel, effort: codexEffort };
   if (hasClaude && hasCodex) {
+    const planConfig2 = { ...claudeDefault, effort: "high" };
     return {
-      plan: { ...claudeDefault, effort: "high" },
+      enhance: { ...planConfig2 },
+      chat: { ...planConfig2, effort: "medium" },
+      plan: planConfig2,
       execute: { ...codexDefault },
-      review: { ...claudeDefault }
+      review: { ...claudeDefault },
+      services: { ...planConfig2, effort: "medium" }
     };
   }
   if (hasClaude) {
-    return { plan: { ...claudeDefault, effort: "high" }, execute: claudeDefault, review: claudeDefault };
+    const planConfig2 = { ...claudeDefault, effort: "high" };
+    return {
+      enhance: { ...planConfig2 },
+      chat: { ...planConfig2, effort: "medium" },
+      plan: planConfig2,
+      execute: claudeDefault,
+      review: claudeDefault,
+      services: { ...planConfig2, effort: "medium" }
+    };
   }
   if (hasCodex) {
-    return { plan: { ...codexDefault, effort: "high" }, execute: codexDefault, review: codexDefault };
+    const planConfig2 = { ...codexDefault, effort: "high" };
+    return {
+      enhance: { ...planConfig2 },
+      chat: { ...planConfig2, effort: "medium" },
+      plan: planConfig2,
+      execute: codexDefault,
+      review: codexDefault,
+      services: { ...planConfig2, effort: "medium" }
+    };
   }
-  return { plan: claudeDefault, execute: codexDefault, review: claudeDefault };
+  const planConfig = { ...claudeDefault };
+  return {
+    enhance: { ...planConfig },
+    chat: { ...planConfig, effort: "medium" },
+    plan: planConfig,
+    execute: codexDefault,
+    review: claudeDefault,
+    services: { ...planConfig, effort: "medium" }
+  };
 }
 function getWorkflowConfig(settings) {
   const setting = settings.find((s) => s.id === SETTING_ID_WORKFLOW_CONFIG);
   if (!setting?.value || typeof setting.value !== "object") return null;
   const wf = setting.value;
   if (isValidStage(wf.plan) && isValidStage(wf.execute) && isValidStage(wf.review)) {
-    return wf;
+    const config = {
+      plan: wf.plan,
+      execute: wf.execute,
+      review: wf.review
+    };
+    if (isValidStage(wf.enhance)) config.enhance = wf.enhance;
+    if (isValidStage(wf.chat)) config.chat = wf.chat;
+    if (isValidStage(wf.services)) config.services = wf.services;
+    return config;
   }
   return null;
 }
@@ -13685,6 +14211,13 @@ export {
   SETTING_ID_ADAPTIVE_REVIEW_ROUTING,
   SETTING_ID_ADAPTIVE_POLICY_MIN_SAMPLES,
   SETTING_ID_SERVICE_ENV,
+  SETTING_ID_MESH_ENABLED,
+  SETTING_ID_MESH_PROXY_PORT,
+  SETTING_ID_MESH_BUFFER_SIZE,
+  SETTING_ID_AUTO_APPROVE_TRIVIAL_PLANS,
+  SETTING_ID_AUTO_COMMIT_BEFORE_MERGE,
+  SETTING_ID_AUTO_RESOLVE_CONFLICTS,
+  SETTING_ID_SANDBOX_EXECUTION,
   loadRuntimeSettings,
   RUNTIME_CONFIG_SETTING_IDS,
   applyPersistedSettings,
@@ -13696,22 +14229,13 @@ export {
   buildDefaultWorkflowConfig,
   getWorkflowConfig,
   persistWorkflowConfig,
-  resolvePlanStageConfig,
+  resolveServicesStageConfig,
   reconcileAgentStateTransitions,
   startManagedAgentWatcher,
   canDispatchManagedAgent,
   runPlanningJob,
   runManagedExecuteJob,
   runManagedReviewJob,
-  startServiceLogBroadcasting,
-  stopServiceLogBroadcasting,
-  wsClients,
-  setAnalyticsOnSubscribeFn,
-  analyticsRoomHasSubscribers,
-  sendToAnalyticsRoom,
-  issueLogRoomSize,
-  sendToIssueLogRoom,
-  broadcastToWebSocketClients,
   isShuttingDown,
   installGracefulShutdown,
   analyzeParallelizability,
@@ -13730,6 +14254,8 @@ export {
   runAgentSession,
   runAgentPipeline,
   issueHasResumableSession,
+  createIssueCommand,
+  mergeWorkspaceCommand,
   listSettings,
   getSetting,
   updateSetting,
@@ -13737,7 +14263,6 @@ export {
   listServiceStatuses,
   startAutoConfiguredServices,
   reconcileManagedServiceStates,
-  initManagedServiceWatcher,
   collectRuntimeHealthSnapshot,
   runDoctorChecks,
   buildProbeResult,
@@ -13781,4 +14306,4 @@ export {
   getEcDailyLines,
   closeStateStore
 };
-//# sourceMappingURL=chunk-YRSH2CLW.js.map
+//# sourceMappingURL=chunk-K36BWMUV.js.map