fifony 0.1.26 → 0.1.27-next.84df008

package/dist/{chunk-2F3Q2MAG.js → chunk-HSGUPFTV.js}

@@ -1,36 +1,13 @@
 import {
-  areQueueWorkersActive,
-  enqueueForExecution,
-  enqueueForPlanning,
-  enqueueForReview
-} from "./chunk-IA7IMQ5F.js";
-import {
-  ADAPTERS,
   ISSUE_STATE_MACHINE_ID,
-  applyCapabilityMetadata,
-  buildExecutionPayload,
-  buildFullPlanPrompt,
-  buildProviderBasePrompt,
-  buildTurnPrompt,
-  cleanWorkspace,
-  computeCapabilityCounts,
-  computeDiffStats,
   computeMetrics,
-  describeRoutingSignals,
-  detectAvailableProviders,
-  discoverModels,
-  ensureWorktreeCommitted,
   executeTransition,
   findIssueStateMachineTransitionPath,
-  getCapabilityRoutingOptions,
   getDirtyEventIds,
   getDirtyIssueIds,
-  getEffectiveAgentProviders,
   getIssueStateMachinePlugin,
   getMetrics,
-  getProviderDefaultCommand,
   hasDirtyState,
-  hydrateIssuePathsFromWorkspace,
   issueStateMachineConfig,
   markAllEventsDirty,
   markAllIssuePlansDirty,
@@ -38,22 +15,65 @@ import {
   markEventDirty,
   markIssueDirty,
   markIssuePlanDirty,
+  setFsmEventEmitter,
+  setIssueResourceStateApi,
+  setIssueStateMachinePlugin,
+  snapshotAndClearDirtyEventIds,
+  snapshotAndClearDirtyIssueIds,
+  snapshotAndClearDirtyIssuePlanIds
+} from "./chunk-FJR4ALEN.js";
+import {
+  ADAPTERS,
+  buildExecutionPayload,
+  buildFullPlanPrompt,
+  buildProviderBasePrompt,
+  buildRetryContext,
+  buildTurnPrompt,
+  cleanWorkspace,
+  computeDiffStats,
+  detectAvailableProviders,
+  discoverModels,
+  ensureWorktreeCommitted,
+  getEffectiveAgentProviders,
+  getProviderDefaultCommand,
+  hydrateIssuePathsFromWorkspace,
   mergeWorkspace,
   normalizeAgentProvider,
   parseDiffStats,
   prepareWorkspace,
-  pushWorktreeBranch,
   readCodexConfig,
   resolveAgentCommand,
   runCommandWithTimeout,
-  runHook,
-  setFsmEventEmitter,
-  setIssueResourceStateApi,
-  setIssueStateMachinePlugin,
-  snapshotAndClearDirtyEventIds,
-  snapshotAndClearDirtyIssueIds,
-  snapshotAndClearDirtyIssuePlanIds
-} from "./chunk-NFHVAIPW.js";
+  runHook
+} from "./chunk-UYCDOH6S.js";
+import {
+  appendFileTail,
+  clamp,
+  debugBoot,
+  extractJsonObjects,
+  fail,
+  idToSafePath,
+  isoWeek,
+  normalizeState,
+  now,
+  parseEnvNumber,
+  parseIntArg,
+  parseIssueState,
+  parsePositiveIntEnv,
+  renderPrompt,
+  repairTruncatedJson,
+  toBooleanValue,
+  toNumberValue,
+  toStringArray,
+  toStringValue,
+  withRetryBackoff
+} from "./chunk-O5AEQXUV.js";
+import {
+  enqueue
+} from "./chunk-XENKNHFS.js";
+import {
+  logger
+} from "./chunk-DVU3CXWA.js";
 import {
   ALLOWED_STATES,
   ATTACHMENTS_ROOT,
@@ -81,42 +101,18 @@ import {
   STATE_ROOT,
   TARGET_ROOT,
   TERMINAL_STATES,
-  WORKSPACE_ROOT,
-  appendFileTail,
-  clamp,
-  debugBoot,
-  extractJsonObjects,
-  fail,
-  idToSafePath,
-  inferCapabilityPaths,
-  isoWeek,
-  normalizeState,
-  now,
-  parseEnvNumber,
-  parseIntArg,
-  parseIssueState,
-  parsePositiveIntEnv,
-  renderPrompt,
-  repairTruncatedJson,
-  resolveTaskCapabilities,
-  toNumberValue,
-  toStringArray,
-  toStringValue,
-  withRetryBackoff
-} from "./chunk-AMOGDOM7.js";
-import {
-  logger
-} from "./chunk-DVU3CXWA.js";
+  WORKSPACE_ROOT
+} from "./chunk-OONOOWNC.js";
 
 // src/agents/issue-runner.ts
 import {
-  existsSync as existsSync13,
-  mkdirSync as mkdirSync7,
-  readFileSync as readFileSync10,
-  writeFileSync as writeFileSync11
+  existsSync as existsSync14,
+  mkdirSync as mkdirSync8,
+  readFileSync as readFileSync11,
+  writeFileSync as writeFileSync12
 } from "fs";
-import { join as join16 } from "path";
-import { execSync as execSync4 } from "child_process";
+import { join as join17 } from "path";
+import { execSync as execSync5 } from "child_process";
 
 // src/domains/tokens.ts
 var EMPTY = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
@@ -290,19 +286,19 @@ function getAnalytics(topN = 20) {
 }
 
 // src/domains/project.ts
-import { execFileSync, spawn as spawn3 } from "child_process";
+import { execFileSync as execFileSync2, spawn as spawn3 } from "child_process";
 import { createHash } from "crypto";
 import {
-  existsSync as existsSync12,
-  mkdirSync as mkdirSync6,
+  existsSync as existsSync13,
+  mkdirSync as mkdirSync7,
   mkdtempSync as mkdtempSync4,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync9,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync10,
   rmSync as rmSync5,
-  writeFileSync as writeFileSync10
+  writeFileSync as writeFileSync11
 } from "fs";
 import { homedir as homedir3, tmpdir as tmpdir4 } from "os";
-import { basename as basename4, dirname as dirname2, join as join15, relative as relativePath, resolve as resolve2 } from "path";
+import { basename as basename4, dirname as dirname2, join as join16, relative as relativePath, resolve as resolve2 } from "path";
 import { env as env3 } from "process";
 
 // src/persistence/plugins/api-runtime-context.ts
@@ -322,8 +318,8 @@ function getApiRuntimeContextOrThrow() {
 
 // src/persistence/plugins/api-server.ts
 import {
-  existsSync as existsSync11,
-  readFileSync as readFileSync8
+  existsSync as existsSync12,
+  readFileSync as readFileSync9
 } from "fs";
 
 // src/persistence/resources/runtime-state.resource.ts
@@ -417,6 +413,31 @@ function extractTokenUsage(output, jsonObj) {
         };
       }
     }
+    const stats = jsonObj.stats;
+    const geminiModels = stats?.models ?? null;
+    if (geminiModels && typeof geminiModels === "object") {
+      let totalInput = 0, totalOutput = 0, primaryModel = "", maxTokens = 0;
+      for (const [model, data] of Object.entries(geminiModels)) {
+        const tokens = data?.tokens;
+        if (!tokens) continue;
+        const inp = Number(tokens.input || 0) + Number(tokens.cached || 0);
+        const out = Number(tokens.candidates || 0);
+        totalInput += inp;
+        totalOutput += out;
+        if (inp + out > maxTokens) {
+          maxTokens = inp + out;
+          primaryModel = model;
+        }
+      }
+      if (totalInput > 0 || totalOutput > 0) {
+        return {
+          inputTokens: totalInput,
+          outputTokens: totalOutput,
+          totalTokens: totalInput + totalOutput,
+          model: primaryModel || void 0
+        };
+      }
+    }
     const usage = jsonObj.usage;
     if (usage && typeof usage === "object") {
       const inp = Number(usage.input_tokens) || 0;
@@ -466,6 +487,15 @@ function tryParseJsonOutput(output) {
         }
       }
       if (obj.status) return obj;
+      if (typeof obj.response === "string") {
+        try {
+          const inner = JSON.parse(obj.response);
+          if (inner && typeof inner === "object" && !Array.isArray(inner)) {
+            return inner;
+          }
+        } catch {
+        }
+      }
     }
   } catch {
   }
@@ -764,24 +794,25 @@ async function loadAgentSessionSnapshotsForIssue(issue, providers, pipeline, _wo
 
 // src/agents/agent-pipeline.ts
 import {
-  writeFileSync as writeFileSync2
+  mkdirSync as mkdirSync2,
+  writeFileSync as writeFileSync3
 } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // src/agents/adapters/index.ts
 import { writeFileSync } from "fs";
 import { join as join3 } from "path";
-async function compileExecution(issue, provider, config, workspacePath, skillContext) {
+async function compileExecution(issue, provider, config, workspacePath, skillContext, capabilitiesManifest) {
   const plan = issue.plan;
   if (!plan?.steps?.length) return null;
   const adapter = ADAPTERS[provider.provider];
   if (!adapter) return null;
   const payload = buildExecutionPayload(issue, provider, plan, workspacePath);
-  const compiled = await adapter.compile(issue, provider, plan, config, workspacePath, skillContext);
+  const compiled = await adapter.compile(issue, provider, plan, config, workspacePath, skillContext, capabilitiesManifest);
   compiled.payload = payload;
   return compiled;
 }
-async function compileReview(issue, reviewer, workspacePath, diffSummary) {
+async function compileReview(issue, reviewer, workspacePath, diffSummary, config) {
   const plan = issue.plan;
   const prompt = await renderPrompt("compile-review", {
     issueIdentifier: issue.identifier,
@@ -794,7 +825,7 @@ async function compileReview(issue, reviewer, workspacePath, diffSummary) {
     diffSummary
   });
   const adapter = ADAPTERS[reviewer.provider];
-  const command = adapter ? adapter.buildReviewCommand(reviewer) : reviewer.command;
+  const command = adapter ? adapter.buildReviewCommand(reviewer, config) : reviewer.command;
   return { prompt, command };
 }
 function buildExecutionAudit(provider, compiled, issue, durationMs, result) {
@@ -863,32 +894,186 @@ function persistExecutionAudit(workspacePath, audit) {
 }
 
 // src/agents/skills.ts
-import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync4 } from "fs";
 import { homedir } from "os";
-import { join as join4, resolve } from "path";
+import { join as join5, resolve } from "path";
+
+// src/agents/catalog.ts
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
+function parseFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return {};
+  const result = {};
+  for (const line of match[1].split("\n")) {
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    const key = line.slice(0, idx).trim();
+    const value = line.slice(idx + 1).trim().replace(/^["']|["']$/g, "");
+    if (key) result[key] = value;
+  }
+  return result;
+}
+function loadAgentCatalog() {
+  const entries = [];
+  try {
+    const repos = listReferenceRepositories();
+    for (const repo of repos) {
+      if (!repo.present || !repo.synced) continue;
+      const artifacts = collectArtifacts(repo.path, repo.id).filter((a) => a.kind === "agent");
+      for (const artifact of artifacts) {
+        try {
+          const content = readFileSync3(artifact.sourcePath, "utf8");
+          const fm = parseFrontmatter(content);
+          entries.push({
+            name: artifact.targetName,
+            displayName: fm.name || artifact.targetName,
+            description: fm.description || "",
+            emoji: fm.emoji || "\u{1F916}",
+            domains: fm.domains ? fm.domains.split(",").map((d) => d.trim()).filter(Boolean) : [],
+            source: repo.id,
+            content
+          });
+        } catch (err) {
+          logger.warn({ err, path: artifact.sourcePath }, "Failed to read agent file");
+        }
+      }
+    }
+  } catch (error) {
+    logger.error({ err: error }, "Failed to load agent catalog from repositories");
+  }
+  return entries;
+}
+function loadSkillCatalog() {
+  return [];
+}
+function filterByDomains(catalog, domains) {
+  const domainSet = new Set(domains.map((d) => d.toLowerCase().trim()));
+  if (domainSet.size === 0) return catalog;
+  const scored = catalog.map((entry) => {
+    const matchCount = entry.domains.filter((d) => domainSet.has(d.toLowerCase())).length;
+    return { entry, matchCount };
+  });
+  return scored.filter((item) => item.matchCount > 0).sort((a, b) => b.matchCount - a.matchCount).map((item) => item.entry);
+}
+function installAgents(targetRoot, agentNames, catalog) {
+  const result = { installed: [], skipped: [], errors: [] };
+  const catalogMap = new Map(catalog.map((entry) => [entry.name, entry]));
+  const agentsDir = join4(targetRoot, ".claude", "agents");
+  try {
+    mkdirSync(agentsDir, { recursive: true });
+  } catch (error) {
+    logger.error({ err: error, path: agentsDir }, "Failed to create agents directory");
+    result.errors.push({ name: "_directory", error: `Failed to create ${agentsDir}` });
+    return result;
+  }
+  for (const name of agentNames) {
+    const entry = catalogMap.get(name);
+    if (!entry) {
+      result.errors.push({ name, error: "Agent not found in catalog" });
+      continue;
+    }
+    const filePath = join4(agentsDir, `${name}.md`);
+    if (existsSync3(filePath)) {
+      result.skipped.push(name);
+      continue;
+    }
+    try {
+      writeFileSync2(filePath, entry.content, "utf8");
+      result.installed.push(name);
+      logger.info({ agent: name, path: filePath }, "Agent installed");
+    } catch (error) {
+      result.errors.push({
+        name,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return result;
+}
+function installSkills(targetRoot, skillNames, catalog) {
+  const result = { installed: [], skipped: [], errors: [] };
+  const catalogMap = new Map(catalog.map((entry) => [entry.name, entry]));
+  const skillsDir = join4(targetRoot, ".claude", "skills");
+  try {
+    mkdirSync(skillsDir, { recursive: true });
+  } catch (error) {
+    logger.error({ err: error, path: skillsDir }, "Failed to create skills directory");
+    result.errors.push({ name: "_directory", error: `Failed to create ${skillsDir}` });
+    return result;
+  }
+  for (const name of skillNames) {
+    const entry = catalogMap.get(name);
+    if (!entry) {
+      result.errors.push({ name, error: "Skill not found in catalog" });
+      continue;
+    }
+    const skillDir = join4(skillsDir, name);
+    const filePath = join4(skillDir, "SKILL.md");
+    if (existsSync3(filePath)) {
+      result.skipped.push(name);
+      continue;
+    }
+    try {
+      mkdirSync(skillDir, { recursive: true });
+      if (entry.installType === "bundled" && entry.content) {
+        writeFileSync2(filePath, entry.content, "utf8");
+      } else {
+        const referenceContent = [
+          `# ${entry.displayName}`,
+          "",
+          entry.description,
+          "",
+          `**Source**: ${entry.source}`,
+          entry.url ? `**URL**: ${entry.url}` : "",
+          "",
+          `> This skill references an external resource. Install it from the source above.`
+        ].filter(Boolean).join("\n");
+        writeFileSync2(filePath, referenceContent, "utf8");
+      }
+      result.installed.push(name);
+      logger.info({ skill: name, path: filePath, type: entry.installType }, "Skill installed");
+    } catch (error) {
+      result.errors.push({
+        name,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return result;
+}
+
+// src/agents/skills.ts
 function discoverSkills(workspacePath) {
   const home = homedir();
-  const codePath = existsSync3(join4(workspacePath, "worktree")) ? join4(workspacePath, "worktree") : workspacePath;
+  const codePath = existsSync4(join5(workspacePath, "worktree")) ? join5(workspacePath, "worktree") : workspacePath;
   const searchPaths = [
     resolve(codePath, ".codex", "skills"),
     resolve(codePath, ".claude", "skills"),
-    join4(home, ".codex", "skills"),
-    join4(home, ".claude", "skills")
+    join5(home, ".codex", "skills"),
+    join5(home, ".claude", "skills")
   ];
   const seen = /* @__PURE__ */ new Set();
   const skills = [];
   for (const basePath of searchPaths) {
-    if (!existsSync3(basePath)) continue;
+    if (!existsSync4(basePath)) continue;
     for (const entry of readdirSync(basePath, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
       if (seen.has(entry.name)) continue;
-      const skillFile = join4(basePath, entry.name, "SKILL.md");
-      if (!existsSync3(skillFile)) continue;
+      const skillFile = join5(basePath, entry.name, "SKILL.md");
+      if (!existsSync4(skillFile)) continue;
       try {
-        const content = readFileSync3(skillFile, "utf8").trim();
+        const content = readFileSync4(skillFile, "utf8").trim();
         if (content) {
           seen.add(entry.name);
-          skills.push({ name: entry.name, content });
+          const fm = parseFrontmatter(content);
+          skills.push({
+            name: entry.name,
+            content,
+            description: fm.description || void 0,
+            whenToUse: fm.when_to_use || fm.whenToUse || void 0,
+            avoidIf: fm.avoid_if || fm.avoidIf || void 0
+          });
         }
       } catch {
       }
@@ -906,8 +1091,141 @@ ${skill.content}`
 
 ${sections.join("\n\n")}`;
 }
+function extractFirstLine(content) {
+  for (const line of content.split("\n")) {
+    const trimmed = line.replace(/^#+\s*/, "").trim();
+    if (trimmed && !trimmed.startsWith("---")) return trimmed;
+  }
+  return "";
+}
+function discoverAgents(workspacePath) {
+  const home = homedir();
+  const codePath = existsSync4(join5(workspacePath, "worktree")) ? join5(workspacePath, "worktree") : workspacePath;
+  const searchPaths = [
+    resolve(codePath, ".claude", "agents"),
+    resolve(codePath, ".codex", "agents"),
+    join5(home, ".claude", "agents"),
+    join5(home, ".codex", "agents")
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const agents = [];
+  for (const basePath of searchPaths) {
+    if (!existsSync4(basePath)) continue;
+    for (const entry of readdirSync(basePath, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+      const name = entry.name.replace(/\.md$/, "");
+      if (seen.has(name)) continue;
+      try {
+        const content = readFileSync4(join5(basePath, entry.name), "utf8").trim();
+        if (content) {
+          seen.add(name);
+          const fm = parseFrontmatter(content);
+          agents.push({
+            name,
+            description: fm.description || extractFirstLine(content),
+            whenToUse: fm.when_to_use || fm.whenToUse || void 0,
+            avoidIf: fm.avoid_if || fm.avoidIf || void 0
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  return agents;
+}
+function discoverCommands(workspacePath) {
+  const home = homedir();
+  const codePath = existsSync4(join5(workspacePath, "worktree")) ? join5(workspacePath, "worktree") : workspacePath;
+  const searchPaths = [
+    resolve(codePath, ".claude", "commands"),
+    resolve(codePath, ".codex", "commands"),
+    join5(home, ".claude", "commands"),
+    join5(home, ".codex", "commands")
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const commands = [];
+  for (const basePath of searchPaths) {
+    if (!existsSync4(basePath)) continue;
+    for (const entry of readdirSync(basePath, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+      const name = entry.name.replace(/\.md$/, "");
+      if (seen.has(name)) continue;
+      try {
+        const content = readFileSync4(join5(basePath, entry.name), "utf8").trim();
+        if (content) {
+          seen.add(name);
+          commands.push({ name, description: extractFirstLine(content) });
+        }
+      } catch {
+      }
+    }
+  }
+  return commands;
+}
+var MAX_CAPABILITIES_ITEMS = 40;
+function buildCapabilitiesManifest(skills, agents, commands) {
+  if (skills.length === 0 && agents.length === 0 && commands.length === 0) return "";
+  const sections = ["## Your Capabilities"];
+  let itemCount = 0;
+  if (commands.length > 0) {
+    sections.push("");
+    sections.push("### Slash Commands");
+    sections.push("You have these commands available. Invoke with `/command-name`:");
+    const show = commands.slice(0, MAX_CAPABILITIES_ITEMS);
+    for (const cmd of show) {
+      sections.push(`- \`/${cmd.name}\`${cmd.description ? ` \u2014 ${cmd.description}` : ""}`);
+      itemCount++;
+    }
+    if (commands.length > show.length) {
+      sections.push(`- ...and ${commands.length - show.length} more available`);
+    }
+  }
+  if (skills.length > 0) {
+    const remaining = Math.max(5, MAX_CAPABILITIES_ITEMS - itemCount);
+    sections.push("");
+    sections.push("### Skills");
+    sections.push("Specialized procedures available for this workspace:");
+    const show = skills.slice(0, remaining);
+    for (const skill of show) {
+      let line = `- **${skill.name}**`;
+      if (skill.description) line += ` \u2014 ${skill.description}`;
+      if (skill.whenToUse) line += ` (Use when: ${skill.whenToUse})`;
+      sections.push(line);
+      itemCount++;
+    }
+    if (skills.length > show.length) {
+      sections.push(`- ...and ${skills.length - show.length} more available`);
+    }
+  }
+  if (agents.length > 0) {
+    const remaining = Math.max(5, MAX_CAPABILITIES_ITEMS - itemCount);
+    sections.push("");
+    sections.push("### Subagents");
+    sections.push("You can delegate to these specialist agents via the Agent tool:");
+    const show = agents.slice(0, remaining);
+    for (const agent of show) {
+      let line = `- **${agent.name}**`;
+      if (agent.description) line += ` \u2014 ${agent.description}`;
+      if (agent.whenToUse) line += ` (Use when: ${agent.whenToUse})`;
+      if (agent.avoidIf) line += ` (Avoid if: ${agent.avoidIf})`;
+      sections.push(line);
+    }
+    if (agents.length > show.length) {
+      sections.push(`- ...and ${agents.length - show.length} more available`);
+    }
+  }
+  sections.push("");
+  sections.push("When a task matches a capability above, USE IT instead of doing everything manually.");
+  return sections.join("\n");
+}
 
 // src/agents/agent-pipeline.ts
+function resolveOutputFileName(role, planVersion, attempt, turn) {
+  if (role === "planner") {
+    return `plan.v${planVersion}.t${turn}.stdout.log`;
+  }
+  return `${role === "reviewer" ? "review" : "execute"}.v${planVersion}a${attempt}.t${turn}.stdout.log`;
+}
 async function runAgentSession(state, issue, provider, cycle, workspacePath, basePromptText, basePromptFile) {
   const maxTurns = clamp(state.config.maxTurns, 1, 16);
   const attempt = issue.attempts + 1;
@@ -919,7 +1237,7 @@ async function runAgentSession(state, issue, provider, cycle, workspacePath, bas
   let nextPrompt = session.nextPrompt;
   let lastCode = session.lastCode;
   let lastOutput = session.lastOutput;
-  const resultFile = join5(workspacePath, `result-${provider.role}-${provider.provider}.json`);
+  const resultFile = join6(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 };
@@ -936,14 +1254,23 @@ Agent requested additional turns beyond configured limit (${maxTurns}).`;
   const compactedOutput = previousOutput.length > maxOutputChars ? `[...${previousOutput.length - maxOutputChars} chars truncated...]
 ${previousOutput.slice(-maxOutputChars)}` : previousOutput;
   const turnPrompt = await buildTurnPrompt(issue, basePromptText, compactedOutput, turnIndex, maxTurns, nextPrompt);
-  const turnPromptFile = turnIndex === 1 ? basePromptFile : join5(workspacePath, `turn-${String(turnIndex).padStart(2, "0")}.md`);
-  if (turnIndex > 1) writeFileSync2(turnPromptFile, `${turnPrompt}
+  const turnPromptFile = turnIndex === 1 ? basePromptFile : join6(workspacePath, `turn-${String(turnIndex).padStart(2, "0")}.md`);
+  if (turnIndex > 1) writeFileSync3(turnPromptFile, `${turnPrompt}
 `, "utf8");
   session.status = "running";
   session.lastPrompt = turnPrompt;
   session.lastPromptFile = turnPromptFile;
   session.maxTurns = maxTurns;
   await persistAgentSessionState(sessionKey, issue, provider, cycle, session);
+  const outputsDir = join6(workspacePath, "outputs");
+  mkdirSync2(outputsDir, { recursive: true });
+  const outputFileName = resolveOutputFileName(
+    provider.role,
+    issue.planVersion ?? 1,
+    provider.role === "planner" ? 0 : issue.executeAttempt ?? 1,
+    turnIndex
+  );
+  const outputFilePath = join6(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 = {
@@ -967,7 +1294,7 @@ ${previousOutput.slice(-maxOutputChars)}` : previousOutput;
     await runHook(state.config.beforeRunHook, workspacePath, issue, "before_run", turnEnv);
   }
   addEvent(state, issue.id, "runner", `Turn ${turnIndex}/${maxTurns} started for ${issue.identifier}.`);
-  const turnResult = await runCommandWithTimeout(provider.command, workspacePath, issue, state.config, turnPrompt, turnPromptFile, turnEnv);
+  const turnResult = await runCommandWithTimeout(provider.command, workspacePath, issue, state.config, turnPrompt, turnPromptFile, turnEnv, outputFilePath);
   if (state.config.afterRunHook) {
     await runHook(state.config.afterRunHook, workspacePath, issue, "after_run", {
       ...turnEnv,
@@ -1056,10 +1383,13 @@ async function runAgentPipeline(state, issue, workspacePath, basePromptText, bas
   const executorIndex = providers.findIndex((provider) => provider.role === "executor");
   const skills = discoverSkills(workspacePath);
   const skillContext = buildSkillContext(skills);
+  const agents = discoverAgents(workspacePath);
+  const commands = discoverCommands(workspacePath);
+  const capabilitiesManifest = buildCapabilitiesManifest(skills, agents, commands);
   if (skillContext) {
-    writeFileSync2(join5(workspacePath, "skills.md"), skillContext, "utf8");
+    writeFileSync3(join6(workspacePath, "skills.md"), skillContext, "utf8");
   }
-  const compiled = await compileExecution(issue, activeProvider, state.config, workspacePath, skillContext);
+  const compiled = await compileExecution(issue, activeProvider, state.config, workspacePath, skillContext, capabilitiesManifest);
   let providerPrompt;
   let effectiveProvider = activeProvider;
   if (compiled) {
@@ -1073,16 +1403,24 @@ 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 = join5(workspacePath, ".compiled-env.sh");
+      const envFile = join6(workspacePath, ".compiled-env.sh");
       const envLines = Object.entries(compiled.env).map(([k, v]) => `export ${k}=${JSON.stringify(v)}`).join("\n");
-      writeFileSync2(envFile, envLines, "utf8");
+      writeFileSync3(envFile, envLines, "utf8");
     }
   } else {
-    providerPrompt = await buildProviderBasePrompt(activeProvider, issue, basePromptText, workspacePath, skillContext);
+    providerPrompt = await buildProviderBasePrompt(activeProvider, issue, basePromptText, workspacePath, skillContext, capabilitiesManifest);
   }
   if (!effectiveProvider.command.trim()) {
     throw new Error(`No command configured for provider ${effectiveProvider.provider} (${effectiveProvider.role}).`);
   }
+  if (issue.attempts > 0) {
+    const retryCtx = buildRetryContext(issue);
+    if (retryCtx) {
+      providerPrompt = `${providerPrompt}
+
+${retryCtx}`;
+    }
+  }
   pipeline.history.push(`[${now()}] Running ${effectiveProvider.role}:${effectiveProvider.provider} in cycle ${pipeline.cycle}${compiled ? ` [${compiled.meta.adapter} adapter]` : ""}.`);
   await persistAgentPipelineState(pipelineFile, pipeline);
   const result = await runAgentSession(state, issue, effectiveProvider, pipeline.cycle, workspacePath, providerPrompt, basePromptFile);
@@ -1206,7 +1544,6 @@ function applyPlanUsage(issue, usage) {
 }
 function applyPlanSuggestions(issue, plan) {
   if (plan.suggestedPaths?.length && !issue.paths?.length) issue.paths = plan.suggestedPaths;
-  if (plan.suggestedLabels?.length && !issue.labels?.length) issue.labels = plan.suggestedLabels;
   if (plan.suggestedEffort && !issue.effort) issue.effort = plan.suggestedEffort;
 }
 async function mutateIssueState(state, c, updater) {
@@ -1240,30 +1577,11 @@ function createS3dbEventStore(state) {
   };
 }
 
-// src/persistence/s3queue-adapter.ts
-function createS3QueueAdapter() {
-  return {
-    async enqueueForPlanning(issue) {
-      return enqueueForPlanning(issue);
-    },
-    async enqueueForExecution(issue) {
-      return enqueueForExecution(issue);
-    },
-    async enqueueForReview(issue) {
-      return enqueueForReview(issue);
-    },
-    isActive() {
-      return areQueueWorkersActive();
-    }
-  };
-}
-
 // src/persistence/container.ts
 var _container = null;
 function createContainer(state) {
   const issueRepository = createS3dbIssueRepository(state);
   const eventStore = createS3dbEventStore(state);
-  const queuePort = createS3QueueAdapter();
   const persistencePort = {
     persistState: (s) => persistState(s),
     loadState: async () => null
@@ -1271,7 +1589,6 @@ function createContainer(state) {
   const container = {
     issueRepository,
     eventStore,
-    queuePort,
     persistencePort
   };
   _container = container;
@@ -1286,19 +1603,19 @@ function getContainer() {
 }
 
 // src/commands/create-issue.command.ts
-import { existsSync as existsSync4, mkdirSync, renameSync } from "fs";
-import { basename, join as join6 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, renameSync } from "fs";
+import { basename, join as join7 } 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 = join6(ATTACHMENTS_ROOT, issue.id);
-    mkdirSync(issueAttachDir, { recursive: true });
+    const issueAttachDir = join7(ATTACHMENTS_ROOT, issue.id);
+    mkdirSync3(issueAttachDir, { recursive: true });
     const finalPaths = [];
     for (const tempPath of tempImages) {
-      if (typeof tempPath === "string" && existsSync4(tempPath)) {
-        const dest = join6(issueAttachDir, basename(tempPath));
+      if (typeof tempPath === "string" && existsSync5(tempPath)) {
+        const dest = join7(issueAttachDir, basename(tempPath));
         try {
           renameSync(tempPath, dest);
           finalPaths.push(dest);
@@ -1317,13 +1634,13 @@ async function createIssueCommand(input, deps) {
   }
   await deps.persistencePort.persistState(state);
   if (issue.state === "Planning") {
-    deps.queuePort.enqueueForPlanning(issue).catch(() => {
+    enqueue(issue, "plan").catch(() => {
     });
   } else if (issue.state === "Queued" || issue.state === "Running") {
-    deps.queuePort.enqueueForExecution(issue).catch(() => {
+    enqueue(issue, "execute").catch(() => {
     });
   } else if (issue.state === "Reviewing") {
-    deps.queuePort.enqueueForReview(issue).catch(() => {
+    enqueue(issue, "review").catch(() => {
     });
   }
   return { issue };
@@ -1503,17 +1820,12 @@ var issues_resource_default = {
     identifier: "string|required",
     title: "string|required",
     description: "string|optional",
-    priority: "number|required",
     state: "string|required",
     branchName: "string|optional",
     url: "string|optional",
     assigneeId: "string|optional",
     labels: "json|required",
     paths: "json|optional",
-    inferredPaths: "json|optional",
-    capabilityCategory: "string|optional",
-    capabilityOverlays: "json|optional",
-    capabilityRationale: "json|optional",
     blockedBy: "json|required",
     assignedToWorker: "boolean|required",
     createdAt: "datetime|required",
@@ -1561,10 +1873,6 @@ var issues_resource_default = {
   },
   partitions: {
     byState: { fields: { state: "string" } },
-    byCapabilityCategory: { fields: { capabilityCategory: "string" } },
-    byStateAndCapability: {
-      fields: { state: "string", capabilityCategory: "string" }
-    },
     byTerminalWeek: { fields: { terminalWeek: "string" } }
   },
   asyncPartitions: true,
@@ -1801,7 +2109,6 @@ function broadcastToWebSocketClients(message) {
         type: "state:delta",
         seq: broadcastSeq,
         metrics: message.metrics,
-        capabilities: message.capabilities,
         updatedAt: message.updatedAt,
         issuesDelta: changedIssues,
         issuesRemoved: removedIds,
@@ -1835,7 +2142,6 @@ function makeWebSocketConfig(state) {
           seq: broadcastSeq,
           timestamp: now(),
           metrics: computeMetrics(state.issues),
-          capabilities: computeCapabilityCounts(state.issues),
           issues: state.issues,
           events: state.events.slice(0, 50)
         }));
@@ -1864,7 +2170,7 @@ var shuttingDown = false;
 function isShuttingDown() {
   return shuttingDown;
 }
-function installGracefulShutdown(state, running) {
+function installGracefulShutdown(state) {
   const handler = async (signal) => {
     if (shuttingDown) {
       logger.warn(`Received ${signal} again, forcing exit.`);
@@ -1875,7 +2181,7 @@ function installGracefulShutdown(state, running) {
     const container = getContainer();
     container.eventStore.addEvent(void 0, "info", `Graceful shutdown initiated (${signal}).`);
     for (const issue of state.issues) {
-      if (running.has(issue.id) && (issue.state === "Running" || issue.state === "Reviewing")) {
+      if (issue.state === "Running" || issue.state === "Reviewing") {
         try {
           await transitionIssueCommand({ issue, target: "Queued", note: `Interrupted by ${signal} \u2014 queued for resume on next start.`, fallbackToLocal: true }, container);
         } catch {
@@ -1907,7 +2213,7 @@ function installGracefulShutdown(state, running) {
 }
 function analyzeParallelizability(issues) {
   const todo = issues.filter(
-    (issue) => issue.state === "Planned" && issue.assignedToWorker && issue.blockedBy.length === 0
+    (issue) => issue.state === "PendingApproval" && issue.assignedToWorker && issue.blockedBy.length === 0
   );
   if (todo.length === 0) {
     return {
@@ -1917,7 +2223,7 @@ function analyzeParallelizability(issues) {
       groups: []
     };
   }
-  const getIssuePaths = (issue) => /* @__PURE__ */ new Set([...issue.paths ?? [], ...issue.inferredPaths ?? []]);
+  const getIssuePaths = (issue) => /* @__PURE__ */ new Set([...issue.paths ?? []]);
   const hasPathOverlap = (a, b) => {
     const pathsA = getIssuePaths(a);
     const pathsB = getIssuePaths(b);
@@ -1986,6 +2292,9 @@ async function ensureNotStale(state, staleTimeoutMs) {
     if (pidDead) {
       logger.info({ issueId: issue.id, identifier: issue.identifier, state: issue.state, pid: agentStatus.pid?.pid }, "[Scheduler] PID dead \u2014 silently recovering to Queued");
       issue.startedAt = void 0;
+      issue.lastError = `Agent process died unexpectedly (PID ${agentStatus.pid.pid}).`;
+      issue.lastFailedPhase = "crash";
+      issue.attempts = (issue.attempts ?? 0) + 1;
       container.issueRepository.markDirty(issue.id);
       await transitionIssueCommand({ issue, target: "Queued", note: `Agent process died (PID ${agentStatus.pid.pid}) \u2014 auto-recovering.` }, container);
       container.eventStore.addEvent(issue.id, "info", `Issue ${issue.identifier} agent process died (PID ${agentStatus.pid.pid}), silently recovered to Queued.`);
@@ -2011,8 +2320,8 @@ function hasTerminalQueue(state) {
 // src/agents/providers-usage.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
-import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync as readdirSync2, realpathSync } from "fs";
-import { join as join7, dirname } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync2, realpathSync } from "fs";
+import { join as join8, dirname } from "path";
 import { homedir as homedir2 } from "os";
 import { env } from "process";
 var execFileAsync = promisify(execFile);
@@ -2039,24 +2348,24 @@ function resolveCodexHomeCandidates() {
   ]);
   const candidates = [...homePaths, ...direct].filter(Boolean).flatMap((candidate) => {
     if (candidate.endsWith("/.codex") || candidate.endsWith("/codex")) return [candidate];
-    return [join7(candidate, ".codex"), join7(candidate, "codex")];
+    return [join8(candidate, ".codex"), join8(candidate, "codex")];
   });
   return [...new Set(candidates)];
 }
 function resolveCodexDir() {
   for (const candidate of resolveCodexHomeCandidates()) {
-    if (existsSync5(candidate)) {
+    if (existsSync6(candidate)) {
       return candidate;
     }
   }
   return null;
 }
 function findLatestCodexDb(codexDir) {
-  const explicit = join7(codexDir, "state_5.sqlite");
-  if (existsSync5(explicit)) return explicit;
+  const explicit = join8(codexDir, "state_5.sqlite");
+  if (existsSync6(explicit)) return explicit;
   const candidates = readdirSync2(codexDir).filter((name) => name.startsWith("state_") && name.endsWith(".sqlite")).sort().reverse();
   if (candidates.length === 0) return null;
-  return join7(codexDir, candidates[0]);
+  return join8(codexDir, candidates[0]);
 }
 function computeNextMonday() {
   const now2 = /* @__PURE__ */ new Date();
@@ -2093,10 +2402,10 @@ var CLAUDE_PLAN_LIMITS = {
 };
 async function collectClaudeUsage() {
   const home = homedir2();
-  const claudeDir = join7(home, ".claude");
-  if (!existsSync5(claudeDir)) return null;
+  const claudeDir = join8(home, ".claude");
+  if (!existsSync6(claudeDir)) return null;
   const available = await whichExists("claude");
-  const projectsDir = join7(claudeDir, "projects");
+  const projectsDir = join8(claudeDir, "projects");
   let totalInputTokens = 0;
   let totalOutputTokens = 0;
   let totalSessions = 0;
@@ -2110,12 +2419,12 @@ async function collectClaudeUsage() {
   const todayMs = todayStart.getTime();
   const weekStart = computeWeekStart();
   const weekMs = weekStart.getTime();
-  if (existsSync5(projectsDir)) {
+  if (existsSync6(projectsDir)) {
     try {
       const projectDirs = readdirSync2(projectsDir, { withFileTypes: true });
       for (const dir of projectDirs) {
         if (!dir.isDirectory()) continue;
-        const projectPath = join7(projectsDir, dir.name);
+        const projectPath = join8(projectsDir, dir.name);
         let sessionFiles;
         try {
           sessionFiles = readdirSync2(projectPath).filter((f) => f.endsWith(".jsonl"));
@@ -2123,10 +2432,10 @@ async function collectClaudeUsage() {
           continue;
         }
         for (const file of sessionFiles) {
-          const filePath = join7(projectPath, file);
+          const filePath = join8(projectPath, file);
           let content;
           try {
-            content = readFileSync4(filePath, "utf8");
+            content = readFileSync5(filePath, "utf8");
           } catch {
             continue;
           }
@@ -2181,10 +2490,10 @@ async function collectClaudeUsage() {
   let plan = "pro";
   let resetInfo = "Weekly reset (every Monday 00:00 UTC)";
   let currentModel = "";
-  const settingsPath = join7(claudeDir, "settings.json");
-  if (existsSync5(settingsPath)) {
+  const settingsPath = join8(claudeDir, "settings.json");
+  if (existsSync6(settingsPath)) {
     try {
-      const settings = JSON.parse(readFileSync4(settingsPath, "utf8"));
+      const settings = JSON.parse(readFileSync5(settingsPath, "utf8"));
       if (settings.plan === "max" || settings.plan === "max5x") {
         plan = settings.plan;
         resetInfo = `Plan: ${settings.plan.toUpperCase()} \u2014 Weekly token limit resets every Monday 00:00 UTC`;
@@ -2220,11 +2529,11 @@ async function collectCodexUsage() {
   if (!codexDir) return null;
   const available = await whichExists("codex");
   const models = [];
-  const modelsCachePath = join7(codexDir, "models_cache.json");
+  const modelsCachePath = join8(codexDir, "models_cache.json");
   let currentModel = "";
-  if (existsSync5(modelsCachePath)) {
+  if (existsSync6(modelsCachePath)) {
     try {
-      const cache = JSON.parse(readFileSync4(modelsCachePath, "utf8"));
+      const cache = JSON.parse(readFileSync5(modelsCachePath, "utf8"));
       for (const m of cache.models || []) {
         models.push({
           slug: m.slug,
@@ -2235,10 +2544,10 @@ async function collectCodexUsage() {
     } catch {
     }
   }
-  const configPath = join7(codexDir, "config.toml");
-  if (existsSync5(configPath)) {
+  const configPath = join8(codexDir, "config.toml");
+  if (existsSync6(configPath)) {
     try {
-      const configContent = readFileSync4(configPath, "utf8");
+      const configContent = readFileSync5(configPath, "utf8");
       const modelMatch = configContent.match(/^model\s*=\s*"([^"]+)"/m);
       if (modelMatch) currentModel = modelMatch[1];
     } catch {
@@ -2327,9 +2636,9 @@ async function collectGeminiUsage() {
   try {
     const { stdout: binPath } = await execFileAsync("which", ["gemini"], { encoding: "utf8", timeout: 3e3 });
     const realBin = realpathSync(binPath.trim());
-    const modelsPath = join7(dirname(dirname(realBin)), "node_modules", "@google", "gemini-cli-core", "dist", "src", "config", "models.js");
-    if (existsSync5(modelsPath)) {
-      const content = readFileSync4(modelsPath, "utf8");
+    const modelsPath = join8(dirname(dirname(realBin)), "node_modules", "@google", "gemini-cli-core", "dist", "src", "config", "models.js");
+    if (existsSync6(modelsPath)) {
+      const content = readFileSync5(modelsPath, "utf8");
       const regex = /export const ([A-Z0-9_]+)\s*=\s*'(gemini-[^']+)';/g;
       const seen = /* @__PURE__ */ new Set();
       let m;
@@ -2347,10 +2656,10 @@ async function collectGeminiUsage() {
   } catch {
   }
   let currentModel = "";
-  const settingsPath = join7(homedir2(), ".gemini", "settings.json");
-  if (existsSync5(settingsPath)) {
+  const settingsPath = join8(homedir2(), ".gemini", "settings.json");
+  if (existsSync6(settingsPath)) {
     try {
-      const settings = JSON.parse(readFileSync4(settingsPath, "utf8"));
+      const settings = JSON.parse(readFileSync5(settingsPath, "utf8"));
       if (typeof settings.model === "string" && settings.model.trim()) {
         currentModel = settings.model.trim();
       }
@@ -2394,10 +2703,10 @@ async function collectProvidersUsage() {
 }
 
 // src/routes/state.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
 import { randomUUID } from "crypto";
-import { execSync as execSync2 } from "child_process";
-import { basename as basename2, extname, join as join8 } from "path";
+import { execSync as execSync3 } from "child_process";
+import { basename as basename2, extname, join as join9 } from "path";
 
 // src/commands/approve-plan.command.ts
 async function approvePlanCommand(input, deps) {
@@ -2406,7 +2715,7 @@ async function approvePlanCommand(input, deps) {
     throw new Error(`Cannot approve issue in state ${issue.state}. Must be in Planning.`);
   }
   await transitionIssueCommand(
-    { issue, target: "Planned", note: `Plan approved for ${issue.identifier}. Ready for execution.` },
+    { issue, target: "PendingApproval", note: `Plan approved for ${issue.identifier}. Ready for execution.` },
     deps
   );
   await transitionIssueCommand(
@@ -2418,8 +2727,8 @@ async function approvePlanCommand(input, deps) {
 // src/commands/execute-issue.command.ts
 async function executeIssueCommand(input, deps) {
   const { issue } = input;
-  if (issue.state !== "Planned") {
-    throw new Error(`Cannot execute issue in state ${issue.state}. Must be in Planned.`);
+  if (issue.state !== "PendingApproval") {
+    throw new Error(`Cannot execute issue in state ${issue.state}. Must be in PendingApproval.`);
   }
   await transitionIssueCommand(
     { issue, target: "Queued", note: `Execution requested for ${issue.identifier}.` },
@@ -2460,21 +2769,63 @@ async function replanIssueCommand(input, deps) {
 }
 
 // src/commands/merge-workspace.command.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { execSync } from "child_process";
+
+// src/domains/validation.ts
+import { execFile as execFile2 } from "child_process";
+async function runValidationGate(issue, config) {
+  if (!config.testCommand) return null;
+  const cwd = issue.worktreePath ?? issue.workspacePath;
+  if (!cwd) {
+    logger.warn({ issueId: issue.id }, "[Validation] No workspace path \u2014 skipping gate");
+    return null;
+  }
+  const command = config.testCommand;
+  logger.info({ issueId: issue.id, command, cwd }, "[Validation] Running validation gate");
+  return new Promise((resolve3) => {
+    const child = execFile2("sh", ["-c", command], {
+      cwd,
+      encoding: "utf8",
+      timeout: 3e5,
+      maxBuffer: 2 * 1024 * 1024
+    }, (err, stdout, stderr) => {
+      const combined = (stdout || "") + (stderr || "");
+      if (!err) {
+        logger.info({ issueId: issue.id }, "[Validation] Gate passed");
+        resolve3({
+          passed: true,
+          output: combined.slice(-2048),
+          command,
+          ranAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return;
+      }
+      logger.warn({ issueId: issue.id, exitCode: err.code }, "[Validation] Gate failed");
+      resolve3({
+        passed: false,
+        output: combined.slice(-2048) || String(err).slice(0, 2048),
+        command,
+        ranAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    });
+  });
+}
+
+// src/commands/merge-workspace.command.ts
 async function mergeWorkspaceCommand(input, deps) {
   const { issue, state } = input;
-  if (!["Done", "Reviewing", "Reviewed"].includes(issue.state)) {
-    throw new Error(`Issue ${issue.identifier} is in state ${issue.state}. Merge is only allowed in Reviewing, Reviewed, or Done state.`);
+  if (!["Approved", "Reviewing", "PendingDecision"].includes(issue.state)) {
+    throw new Error(`Issue ${issue.identifier} is in state ${issue.state}. Merge is only allowed in Reviewing, PendingDecision, or Approved state.`);
   }
-  if (issue.state === "Reviewing" || issue.state === "Reviewed") {
+  if (issue.state === "Reviewing" || issue.state === "PendingDecision") {
     await transitionIssueCommand(
-      { issue, target: "Done", note: "Approved and merged by user." },
+      { issue, target: "Approved", note: "Approved and merged by user." },
       deps
     );
   }
   const wp = issue.worktreePath ?? issue.workspacePath;
-  if (!wp || !existsSync6(wp)) {
+  if (!wp || !existsSync7(wp)) {
     throw new Error("No workspace found for this issue.");
   }
   if (issue.branchName && issue.baseBranch) {
@@ -2498,12 +2849,20 @@ async function mergeWorkspaceCommand(input, deps) {
     }
   } catch {
   }
+  const validation = await runValidationGate(issue, state.config);
+  if (validation) {
+    issue.validationResult = validation;
+    if (!validation.passed) {
+      throw new Error(`Validation gate failed (${validation.command}): ${validation.output.slice(0, 500)}`);
+    }
+  }
   const result = mergeWorkspace(issue);
   issue.mergeResult = {
     copied: result.copied.length,
     deleted: result.deleted.length,
     skipped: result.skipped.length,
-    conflicts: result.conflicts.length
+    conflicts: result.conflicts.length,
+    conflictFiles: result.conflicts.length > 0 ? result.conflicts : void 0
   };
   if (result.conflicts.length > 0) {
     deps.eventStore.addEvent(issue.id, "error", `Merge conflicts: ${result.conflicts.join(", ")}`);
@@ -2527,6 +2886,139 @@ async function mergeWorkspaceCommand(input, deps) {
   return result;
 }
 
+// src/commands/push-workspace.command.ts
+import { execFileSync, execSync as execSync2 } from "child_process";
+function isGhAvailable() {
+  try {
+    execFileSync("gh", ["--version"], { stdio: "pipe", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getCompareUrl(branchName, baseBranch) {
+  try {
+    const remote = execSync2("git remote get-url origin", { cwd: TARGET_ROOT, encoding: "utf8", stdio: "pipe" }).trim();
+    const cleanRemote = remote.replace(/\.git$/, "");
+    return `${cleanRemote}/compare/${baseBranch}...${branchName}`;
+  } catch {
+    return `(branch pushed: ${branchName})`;
+  }
+}
+function findExistingPr(branchName) {
+  try {
+    const result = execFileSync(
+      "gh",
+      ["pr", "view", branchName, "--json", "url,state", "--jq", 'select(.state == "OPEN") | .url'],
+      { cwd: TARGET_ROOT, encoding: "utf8", stdio: "pipe", timeout: 15e3 }
+    ).trim();
+    return result || null;
+  } catch {
+    return null;
+  }
+}
+function createPr(branchName, baseBranch, title, body) {
+  return execFileSync(
+    "gh",
+    ["pr", "create", "--head", branchName, "--base", baseBranch, "--title", title, "--body", body],
+    { cwd: TARGET_ROOT, encoding: "utf8", stdio: "pipe", timeout: 3e4 }
+  ).trim();
+}
+async function pushWorkspaceCommand(input, deps) {
+  const { issue, state } = input;
+  if (!["Approved", "Reviewing", "PendingDecision"].includes(issue.state)) {
+    throw new Error(`Issue ${issue.identifier} is in state ${issue.state}. Push is only allowed in Reviewing, PendingDecision, or Approved state.`);
+  }
+  if (!issue.branchName || !issue.baseBranch || !issue.worktreePath) {
+    throw new Error(`Issue ${issue.identifier} has no git worktree \u2014 cannot push.`);
+  }
+  if (issue.state === "Reviewing" || issue.state === "PendingDecision") {
+    await transitionIssueCommand(
+      { issue, target: "Approved", note: "Approved and pushed by user." },
+      deps
+    );
+  }
+  ensureWorktreeCommitted(issue);
+  const validation = await runValidationGate(issue, state.config);
+  if (validation) {
+    issue.validationResult = validation;
+    if (!validation.passed) {
+      throw new Error(`Validation gate failed (${validation.command}): ${validation.output.slice(0, 500)}`);
+    }
+  }
+  computeDiffStats(issue);
+  const planSummary = issue.plan?.summary ?? issue.title;
+  let diffStat = "";
+  try {
+    diffStat = execSync2(
+      `git diff --stat "${issue.baseBranch}"..."${issue.branchName}"`,
+      { cwd: TARGET_ROOT, encoding: "utf8", maxBuffer: 512e3, timeout: 1e4, stdio: "pipe" }
+    ).trim();
+  } catch {
+  }
+  const body = `## Summary
+${planSummary}
+
+## Diff Stats
+\`\`\`
+${diffStat || "No diff stats available"}
+\`\`\`
+
+*Automated by fifony*`;
+  execSync2(`git push -u origin "${issue.branchName}"`, { cwd: TARGET_ROOT, stdio: "pipe" });
+  const prBase = state.config.prBaseBranch || issue.baseBranch;
+  const ghAvailable = isGhAvailable();
+  let prUrl;
+  if (!ghAvailable) {
+    prUrl = getCompareUrl(issue.branchName, prBase);
+    logger.info({ issueId: issue.id, prUrl }, "[Push] gh CLI not available \u2014 using compare URL");
+  } else {
+    const existingUrl = findExistingPr(issue.branchName);
+    if (existingUrl) {
+      prUrl = existingUrl;
+      logger.info({ issueId: issue.id, prUrl }, "[Push] Existing open PR found");
+    } else {
+      try {
+        prUrl = createPr(issue.branchName, prBase, issue.title, body);
+        logger.info({ issueId: issue.id, prUrl }, "[Push] PR created");
+      } catch (err) {
+        const ghError = (err.stderr || err.stdout || String(err)).toString().slice(0, 500);
+        logger.error({ issueId: issue.id, ghError }, "[Push] gh pr create failed");
+        prUrl = getCompareUrl(issue.branchName, prBase);
+        deps.eventStore.addEvent(issue.id, "error", `gh pr create failed: ${ghError}. Branch was pushed \u2014 use the compare URL to create the PR manually.`);
+      }
+    }
+  }
+  issue.prUrl = prUrl;
+  if (!issue.mergedReason) issue.mergedReason = "Pushed to origin and PR created.";
+  await transitionIssueCommand(
+    { issue, target: "Merged", note: `Branch ${issue.branchName} pushed. PR: ${prUrl}` },
+    deps
+  );
+  deps.eventStore.addEvent(issue.id, "merge", `PR created: ${prUrl}`);
+  await deps.persistencePort.persistState(state);
+  return { prUrl, ghAvailable };
+}
+
+// src/commands/retry-execution.command.ts
+async function retryExecutionCommand(input, deps) {
+  const { issue, note } = input;
+  if (issue.state !== "Blocked") {
+    throw new Error(
+      `retryExecutionCommand requires Blocked state, got ${issue.state}. Use replanIssueCommand for re-planning or the generic /retry endpoint for other states.`
+    );
+  }
+  await transitionIssueCommand(
+    { issue, target: "Queued", note: note ?? `Retry execution for ${issue.identifier} (attempt ${issue.attempts + 1}).` },
+    deps
+  );
+  deps.eventStore.addEvent(
+    issue.id,
+    "manual",
+    `Execution retry requested for ${issue.identifier} \u2014 re-queued from Blocked.`
+  );
+}
+
 // src/routes/state.ts
 function getStateQuery(state, showAll = false) {
   let issues = state.issues;
@@ -2544,7 +3036,6 @@ function getStateQuery(state, showAll = false) {
   return {
     ...state,
     issues,
-    capabilities: computeCapabilityCounts(issues),
     metrics: computeMetrics(issues),
     _filter: showAll ? "all" : "recent",
     _totalIssues: state.issues.length
@@ -2629,7 +3120,7 @@ function registerStateRoutes(app, state) {
         );
         if (issue.plan?.steps?.length) {
           await transitionIssueCommand(
-            { issue, target: "Planned", note: "Existing plan found." },
+            { issue, target: "PendingApproval", note: "Existing plan found." },
             container
           );
           await transitionIssueCommand(
@@ -2638,11 +3129,26 @@ function registerStateRoutes(app, state) {
           );
         }
       } else if (issue.state === "Blocked") {
+        await retryExecutionCommand(
+          { issue, note: "Manual retry from Blocked." },
+          container
+        );
+      } else if (issue.state === "Approved") {
         await transitionIssueCommand(
-          { issue, target: "Queued", note: "Manual retry from Blocked." },
+          { issue, target: "Planning", note: "Requeued for rework after merge conflicts." },
           container
         );
-      } else if (issue.state === "Planned") {
+        if (issue.plan?.steps?.length) {
+          await transitionIssueCommand(
+            { issue, target: "PendingApproval", note: "Existing plan found." },
+            container
+          );
+          await transitionIssueCommand(
+            { issue, target: "Queued", note: "Auto-queued for rework." },
+            container
+          );
+        }
+      } else if (issue.state === "PendingApproval") {
         await transitionIssueCommand(
           { issue, target: "Queued", note: "Manual retry \u2014 queued for execution." },
           container
@@ -2691,6 +3197,10 @@ function registerStateRoutes(app, state) {
       const issue = findIssue(state, issueId);
       if (!issue) return c.json({ ok: false, error: "Issue not found." }, 404);
       const container = getContainer();
+      if (state.config.mergeMode === "push-pr") {
+        const result2 = await pushWorkspaceCommand({ issue, state }, container);
+        return c.json({ ok: true, prUrl: result2.prUrl, ghAvailable: result2.ghAvailable });
+      }
       const result = await mergeWorkspaceCommand({ issue, state }, container);
       return c.json({ ok: true, ...result });
     } catch (error) {
@@ -2699,17 +3209,51 @@ function registerStateRoutes(app, state) {
       return c.json({ ok: false, error: String(error) }, 500);
     }
   });
+  app.get("/api/issues/:id/merge-preview", async (c) => {
+    logger.info({ issueId: parseIssue(c) }, "[API] GET /api/issues/:id/merge-preview");
+    try {
+      const issueId = parseIssue(c);
+      if (!issueId) return c.json({ ok: false, error: "Issue id is required." }, 400);
+      const issue = findIssue(state, issueId);
+      if (!issue) return c.json({ ok: false, error: "Issue not found." }, 404);
+      const { dryMerge } = await import("./workspace-474CCKTW.js");
+      const result = dryMerge(issue);
+      return c.json({ ok: true, ...result });
+    } catch (error) {
+      logger.error(`Failed to preview merge for ${parseIssue(c) || "<unknown>"}: ${String(error)}`);
+      return c.json({ ok: false, error: String(error) }, 500);
+    }
+  });
+  app.post("/api/issues/:id/rebase", async (c) => {
+    logger.info({ issueId: parseIssue(c) }, "[API] POST /api/issues/:id/rebase");
+    try {
+      const issueId = parseIssue(c);
+      if (!issueId) return c.json({ ok: false, error: "Issue id is required." }, 400);
+      const issue = findIssue(state, issueId);
+      if (!issue) return c.json({ ok: false, error: "Issue not found." }, 404);
+      const { rebaseWorktree } = await import("./workspace-474CCKTW.js");
+      const result = rebaseWorktree(issue);
+      if (result.success) {
+        addEvent(state, issue.id, "info", `Branch ${issue.branchName} rebased onto ${issue.baseBranch}.`);
+      }
+      await persistState(state);
+      return c.json({ ok: true, ...result });
+    } catch (error) {
+      logger.error(`Failed to rebase for ${parseIssue(c) || "<unknown>"}: ${String(error)}`);
+      return c.json({ ok: false, error: String(error) }, 500);
+    }
+  });
   app.post("/api/issues/:id/try", async (c) => {
     logger.info({ issueId: parseIssue(c) }, "[API] POST /api/issues/:id/try");
     return mutateIssueState(state, c, async (issue) => {
-      if (!["Reviewing", "Reviewed"].includes(issue.state)) {
+      if (!["Reviewing", "PendingDecision"].includes(issue.state)) {
         throw new Error(`Cannot apply test for issue in state ${issue.state}.`);
       }
       if (!issue.branchName) {
         throw new Error("No branch name found for this issue.");
       }
       try {
-        execSync2(
+        execSync3(
           `git merge --squash "${issue.branchName}"`,
           { encoding: "utf8", cwd: TARGET_ROOT, stdio: "pipe", timeout: 3e4 }
         );
@@ -2724,8 +3268,8 @@ function registerStateRoutes(app, state) {
     logger.info({ issueId: parseIssue(c) }, "[API] POST /api/issues/:id/revert-try");
     return mutateIssueState(state, c, async (issue) => {
       try {
-        execSync2("git reset --hard HEAD", { cwd: TARGET_ROOT, stdio: "pipe", timeout: 15e3 });
-        execSync2("git clean -fd", { cwd: TARGET_ROOT, stdio: "pipe", timeout: 15e3 });
+        execSync3("git reset --hard HEAD", { cwd: TARGET_ROOT, stdio: "pipe", timeout: 15e3 });
+        execSync3("git clean -fd", { cwd: TARGET_ROOT, stdio: "pipe", timeout: 15e3 });
       } catch (err) {
         const msg = err.stderr || err.stdout || String(err);
         throw new Error(`git reset/clean failed: ${msg}`);
@@ -2736,7 +3280,7 @@ function registerStateRoutes(app, state) {
   app.post("/api/issues/:id/rollback", async (c) => {
     logger.info({ issueId: parseIssue(c) }, "[API] POST /api/issues/:id/rollback");
     return mutateIssueState(state, c, async (issue) => {
-      if (!["Reviewing", "Reviewed", "Done"].includes(issue.state)) {
+      if (!["Reviewing", "PendingDecision", "Approved"].includes(issue.state)) {
         throw new Error(`Cannot rollback issue in state ${issue.state}. Must be in Reviewing, Reviewed, or Done.`);
       }
       if (issue.workspacePath) {
@@ -2766,15 +3310,15 @@ function registerStateRoutes(app, state) {
       if (!Array.isArray(payload.files) || payload.files.length === 0) {
         return c.json({ ok: false, error: "No files provided." }, 400);
       }
-      const issueAttachDir = join8(ATTACHMENTS_ROOT, issue.id);
-      mkdirSync2(issueAttachDir, { recursive: true });
+      const issueAttachDir = join9(ATTACHMENTS_ROOT, issue.id);
+      mkdirSync4(issueAttachDir, { recursive: true });
       const newPaths = [];
       for (const file of payload.files) {
         if (typeof file.data !== "string" || !file.name) continue;
         const safeExt = extname(file.name).replace(/[^a-z0-9.]/gi, "").slice(0, 10) || ".bin";
         const safeName = `${randomUUID()}${safeExt}`;
-        const dest = join8(issueAttachDir, safeName);
-        writeFileSync3(dest, Buffer.from(file.data, "base64"));
+        const dest = join9(issueAttachDir, safeName);
+        writeFileSync4(dest, Buffer.from(file.data, "base64"));
         newPaths.push(dest);
       }
       issue.images = [...issue.images ?? [], ...newPaths];
@@ -2794,8 +3338,8 @@ function registerStateRoutes(app, state) {
       const filename = c.req.param?.("filename") ?? c.req.params?.filename ?? "";
       if (!filename) return c.json({ ok: false, error: "Filename is required." }, 400);
       const safeName = basename2(filename);
-      const filePath = join8(ATTACHMENTS_ROOT, issueId, safeName);
-      if (!existsSync7(filePath)) return c.json({ ok: false, error: "Image not found." }, 404);
+      const filePath = join9(ATTACHMENTS_ROOT, issueId, safeName);
+      if (!existsSync8(filePath)) return c.json({ ok: false, error: "Image not found." }, 404);
       const ext = extname(safeName).toLowerCase();
       const mimeMap = {
         ".png": "image/png",
@@ -2806,8 +3350,8 @@ function registerStateRoutes(app, state) {
         ".svg": "image/svg+xml"
       };
       const mime = mimeMap[ext] ?? "application/octet-stream";
-      const { readFileSync: readFileSync11 } = await import("fs");
-      const data = readFileSync11(filePath);
+      const { readFileSync: readFileSync12 } = await import("fs");
+      const data = readFileSync12(filePath);
       return new Response(data, { headers: { "Content-Type": mime, "Cache-Control": "private, max-age=86400" } });
     } catch (error) {
       return c.json({ ok: false, error: error instanceof Error ? error.message : String(error) }, 500);
@@ -2819,7 +3363,7 @@ function registerStateRoutes(app, state) {
     const issue = findIssue(state, issueId);
     if (!issue) return c.json({ ok: false, error: "Issue not found." }, 404);
     try {
-      const { getIssueTransitionHistory } = await import("./issue-state-machine-OWABY5S2.js");
+      const { getIssueTransitionHistory } = await import("./issue-state-machine-ACMUJSXC.js");
       const limit = parseInt(c.req.query("limit") ?? "50", 10);
       const offset = parseInt(c.req.query("offset") ?? "0", 10);
       const transitions = await getIssueTransitionHistory(issue.id, { limit, offset });
@@ -2830,7 +3374,7 @@ function registerStateRoutes(app, state) {
   });
   app.get("/api/state-machine/transitions", async (c) => {
     try {
-      const { getStateMachineTransitions } = await import("./issue-state-machine-OWABY5S2.js");
+      const { getStateMachineTransitions } = await import("./issue-state-machine-ACMUJSXC.js");
       return c.json({ ok: true, transitions: getStateMachineTransitions() });
     } catch (error) {
       return c.json({ ok: false, error: error instanceof Error ? error.message : String(error) }, 500);
@@ -2838,7 +3382,7 @@ function registerStateRoutes(app, state) {
   });
   app.get("/api/state-machine/visualize", async (c) => {
     try {
-      const { visualizeStateMachine } = await import("./issue-state-machine-OWABY5S2.js");
+      const { visualizeStateMachine } = await import("./issue-state-machine-ACMUJSXC.js");
       const dot = visualizeStateMachine();
       if (!dot) return c.json({ ok: false, error: "Visualization not available." }, 404);
       return c.json({ ok: true, dot });
@@ -2923,8 +3467,8 @@ async function recoverPlanningSession() {
 }
 
 // src/agents/planning/plan-generator.ts
-import { writeFileSync as writeFileSync5 } from "fs";
-import { join as join10 } from "path";
+import { writeFileSync as writeFileSync6 } from "fs";
+import { join as join11 } from "path";
 import { mkdtempSync, rmSync as rmSync2 } from "fs";
 import { tmpdir } from "os";
 
@@ -2982,10 +3526,9 @@ function tryBuildPlan(parsed) {
     })) : void 0,
     validation: toStringArray(parsed.validation),
     deliverables: toStringArray(parsed.deliverables),
-    executionStrategy: parsed.executionStrategy || parsed.execution_strategy || void 0,
-    toolingDecision: parsed.toolingDecision || parsed.tooling_decision || void 0,
     suggestedPaths: toStringArray(parsed.suggestedPaths || parsed.suggested_paths || parsed.suggestedFilePaths || parsed.filePaths || parsed.file_paths || parsed.paths),
-    suggestedLabels: toStringArray(parsed.suggestedLabels || parsed.suggested_labels || parsed.labels),
+    suggestedSkills: toStringArray(parsed.suggestedSkills || parsed.suggested_skills),
+    suggestedAgents: toStringArray(parsed.suggestedAgents || parsed.suggested_agents),
     suggestedEffort: parsed.suggestedEffort || parsed.suggested_effort || parsed.effortSuggestion || parsed.effort_suggestion || parsed.effort || { default: "medium" },
     provider: "",
     createdAt: now()
@@ -3096,28 +3639,27 @@ function extractPlanTokenUsage(raw) {
 }
 
 // src/agents/planning/planning-prompts.ts
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
 import { spawn } from "child_process";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 
 // src/agents/planning/planning-schema.ts
 var STEP_SCHEMA = {
   type: "object",
   additionalProperties: false,
-  required: ["step", "action", "files", "details", "ownerType", "doneWhen"],
+  required: ["step", "action", "files", "details", "doneWhen"],
   properties: {
     step: { type: "number" },
     action: { type: "string" },
     files: { type: "array", items: { type: "string" } },
     details: { type: "string" },
-    ownerType: { type: "string", enum: ["human", "agent", "skill", "subagent", "tool"] },
     doneWhen: { type: "string" }
   }
 };
 var PLAN_JSON_SCHEMA = JSON.stringify({
   type: "object",
   additionalProperties: false,
-  required: ["summary", "steps", "phases", "estimatedComplexity", "suggestedPaths", "suggestedLabels", "assumptions", "constraints", "unknowns", "successCriteria", "executionStrategy", "toolingDecision", "risks", "validation", "deliverables", "suggestedEffort"],
+  required: ["summary", "steps", "estimatedComplexity", "suggestedPaths", "suggestedEffort"],
   properties: {
     summary: { type: "string" },
     estimatedComplexity: { type: "string", enum: ["trivial", "low", "medium", "high"] },
@@ -3125,16 +3667,8 @@ var PLAN_JSON_SCHEMA = JSON.stringify({
     constraints: { type: "array", items: { type: "string" } },
     unknowns: { type: "array", items: { type: "object", additionalProperties: false, properties: { question: { type: "string" }, whyItMatters: { type: "string" }, howToResolve: { type: "string" } }, required: ["question", "whyItMatters", "howToResolve"] } },
     successCriteria: { type: "array", items: { type: "string" } },
-    executionStrategy: { type: "object", additionalProperties: false, required: ["approach", "whyThisApproach", "alternativesConsidered"], properties: { approach: { type: "string" }, whyThisApproach: { type: "string" }, alternativesConsidered: { type: "array", items: { type: "string" } } } },
-    toolingDecision: { type: "object", additionalProperties: false, required: ["shouldUseSkills", "skillsToUse", "shouldUseSubagents", "subagentsToUse", "decisionSummary"], properties: {
-      shouldUseSkills: { type: "boolean" },
-      skillsToUse: { type: "array", items: { type: "object", additionalProperties: false, properties: { name: { type: "string" }, why: { type: "string" } }, required: ["name", "why"] } },
-      shouldUseSubagents: { type: "boolean" },
-      subagentsToUse: { type: "array", items: { type: "object", additionalProperties: false, properties: { name: { type: "string" }, role: { type: "string" }, why: { type: "string" } }, required: ["name", "role", "why"] } },
-      decisionSummary: { type: "string" }
-    } },
     steps: { type: "array", items: STEP_SCHEMA },
-    phases: { type: "array", items: { type: "object", additionalProperties: false, required: ["phaseName", "goal", "tasks", "dependencies", "outputs"], properties: {
+    phases: { type: "array", items: { type: "object", additionalProperties: false, required: ["phaseName", "goal", "tasks"], properties: {
       phaseName: { type: "string" },
       goal: { type: "string" },
       tasks: { type: "array", items: STEP_SCHEMA },
@@ -3145,8 +3679,9 @@ var PLAN_JSON_SCHEMA = JSON.stringify({
     validation: { type: "array", items: { type: "string" } },
     deliverables: { type: "array", items: { type: "string" } },
     suggestedPaths: { type: "array", items: { type: "string" } },
-    suggestedLabels: { type: "array", items: { type: "string" } },
-    suggestedEffort: { type: "object", additionalProperties: false, required: ["default", "planner", "executor", "reviewer"], properties: { default: { type: "string" }, planner: { type: "string" }, executor: { type: "string" }, reviewer: { type: "string" } } }
+    suggestedSkills: { type: "array", items: { type: "string" } },
+    suggestedAgents: { type: "array", items: { type: "string" } },
+    suggestedEffort: { type: "object", additionalProperties: false, required: ["default"], properties: { default: { type: "string" }, planner: { type: "string" }, executor: { type: "string" }, reviewer: { type: "string" } } }
   }
 });
 var PLAN_SCHEMA_OBJECT = JSON.parse(PLAN_JSON_SCHEMA);
@@ -3166,6 +3701,9 @@ var SETTING_ID_AGENT_COMMAND = "runtime.agentCommand";
 var SETTING_ID_DEFAULT_EFFORT = "runtime.defaultEffort";
 var SETTING_ID_DETECTED_PROVIDERS = "providers.detected";
 var SETTING_ID_WORKFLOW_CONFIG = "runtime.workflowConfig";
+var SETTING_ID_TEST_COMMAND = "runtime.testCommand";
+var SETTING_ID_MERGE_MODE = "runtime.mergeMode";
+var SETTING_ID_PR_BASE_BRANCH = "runtime.prBaseBranch";
 async function loadRuntimeSettings() {
   return loadPersistedSettings();
 }
@@ -3181,7 +3719,10 @@ var RUNTIME_CONFIG_SETTING_IDS = /* @__PURE__ */ new Set([
   SETTING_ID_MAX_CONCURRENT_BY_STATE,
   SETTING_ID_AGENT_PROVIDER,
   SETTING_ID_AGENT_COMMAND,
-  SETTING_ID_DEFAULT_EFFORT
+  SETTING_ID_DEFAULT_EFFORT,
+  SETTING_ID_TEST_COMMAND,
+  SETTING_ID_MERGE_MODE,
+  SETTING_ID_PR_BASE_BRANCH
 ]);
 var VALID_REASONING_EFFORTS = /* @__PURE__ */ new Set(["low", "medium", "high", "extra-high"]);
 function parseIntegerSetting(value) {
@@ -3240,7 +3781,10 @@ function buildRuntimeConfigSettings(config, source) {
     { id: SETTING_ID_MAX_CONCURRENT_BY_STATE, scope: "runtime", value: config.maxConcurrentByState, source, updatedAt },
     { id: SETTING_ID_AGENT_PROVIDER, scope: "runtime", value: config.agentProvider, source, updatedAt },
     { id: SETTING_ID_AGENT_COMMAND, scope: "runtime", value: config.agentCommand, source, updatedAt },
-    { id: SETTING_ID_DEFAULT_EFFORT, scope: "runtime", value: config.defaultEffort, source, updatedAt }
+    { id: SETTING_ID_DEFAULT_EFFORT, scope: "runtime", value: config.defaultEffort, source, updatedAt },
+    { id: SETTING_ID_TEST_COMMAND, scope: "runtime", value: config.testCommand ?? "", source, updatedAt },
+    { id: SETTING_ID_MERGE_MODE, scope: "runtime", value: config.mergeMode ?? "local", source, updatedAt },
+    { id: SETTING_ID_PR_BASE_BRANCH, scope: "runtime", value: config.prBaseBranch ?? "", source, updatedAt }
   ];
 }
 function applyPersistedSettings(config, settings) {
@@ -3324,10 +3868,28 @@ function applyPersistedSettings(config, settings) {
         agentCommandOverridden = true;
         break;
       }
-      case SETTING_ID_DEFAULT_EFFORT: {
-        const parsed = sanitizeDefaultEffort(setting.value);
-        if (parsed) {
-          nextConfig.defaultEffort = parsed;
+      case SETTING_ID_DEFAULT_EFFORT: {
+        const parsed = sanitizeDefaultEffort(setting.value);
+        if (parsed) {
+          nextConfig.defaultEffort = parsed;
+        }
+        break;
+      }
+      case SETTING_ID_TEST_COMMAND: {
+        if (typeof setting.value === "string") {
+          nextConfig.testCommand = setting.value.trim() || void 0;
+        }
+        break;
+      }
+      case SETTING_ID_MERGE_MODE: {
+        if (setting.value === "local" || setting.value === "push-pr") {
+          nextConfig.mergeMode = setting.value;
+        }
+        break;
+      }
+      case SETTING_ID_PR_BASE_BRANCH: {
+        if (typeof setting.value === "string" && setting.value.trim()) {
+          nextConfig.prBaseBranch = setting.value.trim();
         }
         break;
       }
@@ -3435,11 +3997,19 @@ async function persistWorkflowConfig(config) {
 
 // src/agents/planning/planning-prompts.ts
 async function buildPlanPrompt(title, description, fast = false, images) {
+  const skills = discoverSkills(TARGET_ROOT);
+  const agents = discoverAgents(TARGET_ROOT);
+  const commands = discoverCommands(TARGET_ROOT);
+  const hasCapabilities = skills.length > 0 || agents.length > 0 || commands.length > 0;
   return renderPrompt("issue-planner", {
     title,
     description: description || "(none provided)",
     fast,
-    images: images?.length ? images : void 0
+    images: images?.length ? images : void 0,
+    availableCapabilities: hasCapabilities,
+    availableSkills: skills.map((s) => ({ name: s.name, description: s.description || "", whenToUse: s.whenToUse || "" })),
+    availableAgents: agents.map((a) => ({ name: a.name, description: a.description || "", whenToUse: a.whenToUse || "", avoidIf: a.avoidIf || "" })),
+    availableCommands: commands.map((c) => ({ name: c.name }))
   });
 }
 async function buildRefinePrompt(title, description, currentPlan, feedback) {
@@ -3458,11 +4028,11 @@ function getPlanCommand(provider, model, imagePaths) {
 }
 function savePlanDebugFiles(slug, prompt, output) {
   try {
-    const debugDir = join9(STATE_ROOT, "debug");
-    mkdirSync3(debugDir, { recursive: true });
+    const debugDir = join10(STATE_ROOT, "debug");
+    mkdirSync5(debugDir, { recursive: true });
     const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-    writeFileSync4(join9(debugDir, `plan-${slug}-${ts}-prompt.md`), prompt, "utf8");
-    if (output) writeFileSync4(join9(debugDir, `plan-${slug}-${ts}-output.txt`), output, "utf8");
+    writeFileSync5(join10(debugDir, `plan-${slug}-${ts}-prompt.md`), prompt, "utf8");
+    if (output) writeFileSync5(join10(debugDir, `plan-${slug}-${ts}-output.txt`), output, "utf8");
   } catch {
   }
 }
@@ -3620,9 +4190,9 @@ async function generatePlan(title, description, config, _workflowDefinition, opt
     const command = getPlanCommand(preferred, planStageModel, images);
     if (!command) throw new Error(`No command configured for provider ${preferred}.`);
     logger.debug({ provider: preferred, model: planStageModel, command: command.slice(0, 120) }, "[Planner] Provider selected for plan generation");
-    const tempDir = mkdtempSync(join10(tmpdir(), "fifony-plan-"));
-    const promptFile = join10(tempDir, "fifony-plan-prompt.md");
-    writeFileSync5(promptFile, `${prompt}
+    const tempDir = mkdtempSync(join11(tmpdir(), "fifony-plan-"));
+    const promptFile = join11(tempDir, "fifony-plan-prompt.md");
+    writeFileSync6(promptFile, `${prompt}
 `, "utf8");
     let lastProgressPersist = 0;
     const PROGRESS_INTERVAL_MS = 2e3;
@@ -3699,8 +4269,8 @@ async function generatePlan(title, description, config, _workflowDefinition, opt
 }
 
 // src/agents/planning/plan-refiner.ts
-import { writeFileSync as writeFileSync6 } from "fs";
-import { join as join11 } from "path";
+import { writeFileSync as writeFileSync7 } from "fs";
+import { join as join12 } from "path";
 import { mkdtempSync as mkdtempSync2, rmSync as rmSync3 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 async function refinePlan(issue, feedback, config, _workflowDefinition) {
@@ -3713,9 +4283,9 @@ async function refinePlan(issue, feedback, config, _workflowDefinition) {
   {
     const command = getPlanCommand(preferred, planStageModel);
     if (!command) throw new Error(`No command configured for provider ${preferred}.`);
-    const tempDir = mkdtempSync2(join11(tmpdir2(), "fifony-refine-"));
-    const promptFile = join11(tempDir, "fifony-refine-prompt.md");
-    writeFileSync6(promptFile, `${prompt}
+    const tempDir = mkdtempSync2(join12(tmpdir2(), "fifony-refine-"));
+    const promptFile = join12(tempDir, "fifony-refine-prompt.md");
+    writeFileSync7(promptFile, `${prompt}
 `, "utf8");
     const output = await runPlanningProcess({
       command,
@@ -3836,10 +4406,10 @@ function refinePlanInBackground(issue, feedback, config, _workflowDefinition, ca
 
 // src/agents/planning/issue-enhancer.ts
 import { env as env2 } from "process";
-import { existsSync as existsSync8, mkdtempSync as mkdtempSync3, readFileSync as readFileSync5, rmSync as rmSync4, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync9, mkdtempSync as mkdtempSync3, readFileSync as readFileSync6, rmSync as rmSync4, writeFileSync as writeFileSync8 } from "fs";
 import { spawn as spawn2 } from "child_process";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 function getProviderCommand(provider, config) {
   return resolveAgentCommand(provider, config.agentCommand || "", "", "");
 }
@@ -3908,22 +4478,22 @@ function parseCandidate(raw, expectedField) {
   return "";
 }
 function readProviderOutput(resultFile, fallback) {
-  if (existsSync8(resultFile)) {
+  if (existsSync9(resultFile)) {
     try {
-      return readFileSync5(resultFile, "utf8").trim();
+      return readFileSync6(resultFile, "utf8").trim();
     } catch {
     }
   }
   return fallback;
 }
 async function runProviderCommand(command, provider, prompt, title, description, field, timeoutMs, images) {
-  const tempDir = mkdtempSync3(join12(tmpdir3(), "fifony-enhance-"));
-  const promptFile = join12(tempDir, "fifony-enhance-prompt.md");
-  const issuePayloadFile = join12(tempDir, "fifony-issue.json");
-  const resultFile = join12(tempDir, "fifony-result.txt");
-  writeFileSync7(promptFile, `${prompt}
+  const tempDir = mkdtempSync3(join13(tmpdir3(), "fifony-enhance-"));
+  const promptFile = join13(tempDir, "fifony-enhance-prompt.md");
+  const issuePayloadFile = join13(tempDir, "fifony-issue.json");
+  const resultFile = join13(tempDir, "fifony-result.txt");
+  writeFileSync8(promptFile, `${prompt}
 `, "utf8");
-  writeFileSync7(issuePayloadFile, JSON.stringify({ title, description, field }, null, 2), "utf8");
+  writeFileSync8(issuePayloadFile, JSON.stringify({ title, description, field }, null, 2), "utf8");
   let effectiveCommand = command;
   if (provider === "codex" && images?.length) {
     const imageFlags = images.map((p) => `--image "${p}"`).join(" ");
@@ -4140,7 +4710,6 @@ function registerPlanRoutes(app, state) {
         applyUsage: (iss, usage) => applyPlanUsage(iss, usage),
         applySuggestions: (iss, plan) => {
           if (plan.suggestedPaths?.length) iss.paths = plan.suggestedPaths;
-          if (plan.suggestedLabels?.length) iss.labels = plan.suggestedLabels;
           if (plan.suggestedEffort) iss.effort = plan.suggestedEffort;
         }
       });
@@ -4322,7 +4891,7 @@ function registerAnalyticsRoutes(app) {
     try {
       const context2 = getApiRuntimeContextOrThrow();
       const doneIssues = context2.state.issues.filter(
-        (i) => (i.state === "Done" || i.state === "Merged") && i.completedAt
+        (i) => (i.state === "Approved" || i.state === "Merged") && i.completedAt
       );
       const msToDay = (ms) => ms / (1e3 * 60 * 60 * 24);
       const avg = (arr) => arr.length ? arr.reduce((a, b) => a + b, 0) / arr.length : null;
@@ -4379,149 +4948,59 @@ function registerScanningRoutes(app, state) {
   });
 }
 
-// src/agents/catalog.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync8 } from "fs";
-import { join as join13 } from "path";
-function parseFrontmatter(content) {
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!match) return {};
-  const result = {};
-  for (const line of match[1].split("\n")) {
-    const idx = line.indexOf(":");
-    if (idx === -1) continue;
-    const key = line.slice(0, idx).trim();
-    const value = line.slice(idx + 1).trim().replace(/^["']|["']$/g, "");
-    if (key) result[key] = value;
-  }
-  return result;
-}
-function loadAgentCatalog() {
-  const entries = [];
-  try {
-    const repos = listReferenceRepositories();
-    for (const repo of repos) {
-      if (!repo.present || !repo.synced) continue;
-      const artifacts = collectArtifacts(repo.path, repo.id).filter((a) => a.kind === "agent");
-      for (const artifact of artifacts) {
-        try {
-          const content = readFileSync6(artifact.sourcePath, "utf8");
-          const fm = parseFrontmatter(content);
-          entries.push({
-            name: artifact.targetName,
-            displayName: fm.name || artifact.targetName,
-            description: fm.description || "",
-            emoji: fm.emoji || "\u{1F916}",
-            domains: fm.domains ? fm.domains.split(",").map((d) => d.trim()).filter(Boolean) : [],
-            source: repo.id,
-            content
-          });
-        } catch (err) {
-          logger.warn({ err, path: artifact.sourcePath }, "Failed to read agent file");
-        }
-      }
-    }
-  } catch (error) {
-    logger.error({ err: error }, "Failed to load agent catalog from repositories");
-  }
-  return entries;
-}
-function loadSkillCatalog() {
-  return [];
-}
-function filterByDomains(catalog, domains) {
-  const domainSet = new Set(domains.map((d) => d.toLowerCase().trim()));
-  if (domainSet.size === 0) return catalog;
-  const scored = catalog.map((entry) => {
-    const matchCount = entry.domains.filter((d) => domainSet.has(d.toLowerCase())).length;
-    return { entry, matchCount };
-  });
-  return scored.filter((item) => item.matchCount > 0).sort((a, b) => b.matchCount - a.matchCount).map((item) => item.entry);
-}
-function installAgents(targetRoot, agentNames, catalog) {
-  const result = { installed: [], skipped: [], errors: [] };
-  const catalogMap = new Map(catalog.map((entry) => [entry.name, entry]));
-  const agentsDir = join13(targetRoot, ".claude", "agents");
-  try {
-    mkdirSync4(agentsDir, { recursive: true });
-  } catch (error) {
-    logger.error({ err: error, path: agentsDir }, "Failed to create agents directory");
-    result.errors.push({ name: "_directory", error: `Failed to create ${agentsDir}` });
-    return result;
-  }
-  for (const name of agentNames) {
-    const entry = catalogMap.get(name);
-    if (!entry) {
-      result.errors.push({ name, error: "Agent not found in catalog" });
-      continue;
-    }
-    const filePath = join13(agentsDir, `${name}.md`);
-    if (existsSync9(filePath)) {
-      result.skipped.push(name);
-      continue;
-    }
-    try {
-      writeFileSync8(filePath, entry.content, "utf8");
-      result.installed.push(name);
-      logger.info({ agent: name, path: filePath }, "Agent installed");
-    } catch (error) {
-      result.errors.push({
-        name,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  return result;
-}
-function installSkills(targetRoot, skillNames, catalog) {
-  const result = { installed: [], skipped: [], errors: [] };
-  const catalogMap = new Map(catalog.map((entry) => [entry.name, entry]));
-  const skillsDir = join13(targetRoot, ".claude", "skills");
-  try {
-    mkdirSync4(skillsDir, { recursive: true });
-  } catch (error) {
-    logger.error({ err: error, path: skillsDir }, "Failed to create skills directory");
-    result.errors.push({ name: "_directory", error: `Failed to create ${skillsDir}` });
-    return result;
-  }
-  for (const name of skillNames) {
-    const entry = catalogMap.get(name);
-    if (!entry) {
-      result.errors.push({ name, error: "Skill not found in catalog" });
-      continue;
-    }
-    const skillDir = join13(skillsDir, name);
-    const filePath = join13(skillDir, "SKILL.md");
-    if (existsSync9(filePath)) {
-      result.skipped.push(name);
-      continue;
-    }
-    try {
-      mkdirSync4(skillDir, { recursive: true });
-      if (entry.installType === "bundled" && entry.content) {
-        writeFileSync8(filePath, entry.content, "utf8");
-      } else {
-        const referenceContent = [
-          `# ${entry.displayName}`,
-          "",
-          entry.description,
-          "",
-          `**Source**: ${entry.source}`,
-          entry.url ? `**URL**: ${entry.url}` : "",
-          "",
-          `> This skill references an external resource. Install it from the source above.`
-        ].filter(Boolean).join("\n");
-        writeFileSync8(filePath, referenceContent, "utf8");
-      }
-      result.installed.push(name);
-      logger.info({ skill: name, path: filePath, type: entry.installType }, "Skill installed");
-    } catch (error) {
-      result.errors.push({
-        name,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
+// src/agents/claude-md-manager.ts
+import { existsSync as existsSync10, readFileSync as readFileSync7, writeFileSync as writeFileSync9 } from "fs";
+import { join as join14 } 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 -->/;
+function buildManagedBlock(skills, agents, commands) {
+  const lines = [
+    BLOCK_START,
+    "## Fifony \u2014 Installed Capabilities",
+    "",
+    "This workspace has fifony-managed agents and skills installed.",
+    ""
+  ];
+  if (commands.length > 0) {
+    lines.push(`**Commands**: ${commands.map((c) => `/${c.name}`).join(", ")}`);
+  }
+  if (skills.length > 0) {
+    lines.push(`**Skills**: ${skills.map((s) => s.name).join(", ")}`);
+  }
+  if (agents.length > 0) {
+    lines.push(`**Agents**: ${agents.map((a) => a.name).join(", ")}`);
+  }
+  lines.push("");
+  lines.push("Use these capabilities when working on tasks. For details:");
+  lines.push("- Skills: `.claude/skills/*/SKILL.md`");
+  lines.push("- Agents: `.claude/agents/*.md`");
+  lines.push("- Commands: `.claude/commands/*.md`");
+  lines.push(BLOCK_END);
+  return lines.join("\n");
+}
+function updateClaudeMdManagedBlock(targetRoot, skills, agents, commands) {
+  if (skills.length === 0 && agents.length === 0 && commands.length === 0) return;
+  const claudeMdPath = join14(targetRoot, "CLAUDE.md");
+  const newBlock = buildManagedBlock(skills, agents, commands);
+  let existing = "";
+  if (existsSync10(claudeMdPath)) {
+    existing = readFileSync7(claudeMdPath, "utf8");
+  }
+  let updated;
+  if (BLOCK_PATTERN.test(existing)) {
+    updated = existing.replace(BLOCK_PATTERN, newBlock);
+  } else if (existing) {
+    updated = `${existing.trimEnd()}
+
+${newBlock}
+`;
+  } else {
+    updated = `${newBlock}
+`;
   }
-  return result;
+  if (updated === existing) return;
+  writeFileSync9(claudeMdPath, updated, "utf8");
 }
 
 // src/routes/catalog.ts
@@ -4545,6 +5024,10 @@ function registerCatalogRoutes(app) {
       }
       const catalog = loadAgentCatalog();
       const result = installAgents(TARGET_ROOT, agentNames, catalog);
+      try {
+        updateClaudeMdManagedBlock(TARGET_ROOT, discoverSkills(TARGET_ROOT), discoverAgents(TARGET_ROOT), discoverCommands(TARGET_ROOT));
+      } catch {
+      }
       return c.json({ ok: true, ...result });
     } catch (error) {
       logger.error({ err: error }, "Failed to install agents");
@@ -4560,6 +5043,10 @@ function registerCatalogRoutes(app) {
       }
       const catalog = loadSkillCatalog();
       const result = installSkills(TARGET_ROOT, skillNames, catalog);
+      try {
+        updateClaudeMdManagedBlock(TARGET_ROOT, discoverSkills(TARGET_ROOT), discoverAgents(TARGET_ROOT), discoverCommands(TARGET_ROOT));
+      } catch {
+      }
       return c.json({ ok: true, ...result });
     } catch (error) {
       logger.error({ err: error }, "Failed to install skills");
@@ -4622,6 +5109,12 @@ function registerReferenceRepositoryRoutes(app) {
         dryRun: payload?.dryRun === true,
         importToGlobal: payload?.global === true
       });
+      if (!payload?.dryRun) {
+        try {
+          updateClaudeMdManagedBlock(TARGET_ROOT, discoverSkills(TARGET_ROOT), discoverAgents(TARGET_ROOT), discoverCommands(TARGET_ROOT));
+        } catch {
+        }
+      }
       return c.json({
         ok: true,
         ...summary
@@ -4636,35 +5129,34 @@ function registerReferenceRepositoryRoutes(app) {
 }
 
 // src/routes/misc.ts
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 import {
   appendFileSync,
   closeSync,
-  existsSync as existsSync10,
-  mkdirSync as mkdirSync5,
+  existsSync as existsSync11,
+  mkdirSync as mkdirSync6,
   openSync,
-  readFileSync as readFileSync7,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync8,
   readSync,
   statSync,
-  writeFileSync as writeFileSync9
+  writeFileSync as writeFileSync10
 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
-import { extname as extname2, join as join14 } from "path";
+import { basename as basename3, extname as extname2, join as join15 } from "path";
 function registerMiscRoutes(app, state) {
   app.post("/api/issues/:id/push", async (c) => {
     const issueId = parseIssue(c);
     if (!issueId) return c.json({ ok: false, error: "Issue id is required." }, 400);
     const issue = findIssue(state, issueId);
     if (!issue) return c.json({ ok: false, error: "Issue not found." }, 404);
-    if (issue.state !== "Done") {
-      return c.json({ ok: false, error: `Issue ${issue.identifier} must be in Done state to push. Current state: ${issue.state}.` }, 409);
+    if (!["Approved", "Reviewing", "PendingDecision"].includes(issue.state)) {
+      return c.json({ ok: false, error: `Issue ${issue.identifier} must be in Approved, Reviewing, or PendingDecision state to push. Current state: ${issue.state}.` }, 409);
     }
     try {
-      const prUrl = pushWorktreeBranch(issue);
-      issue.mergedAt = (/* @__PURE__ */ new Date()).toISOString();
-      addEvent(state, issue.id, "merge", `Branch ${issue.branchName} pushed to origin. PR: ${prUrl}`);
-      await persistState(state);
-      return c.json({ ok: true, prUrl });
+      const container = getContainer();
+      const result = await pushWorkspaceCommand({ issue, state }, container);
+      return c.json({ ok: true, prUrl: result.prUrl, ghAvailable: result.ghAvailable });
     } catch (error) {
       logger.error({ err: error }, `[API] Failed to push branch for ${issueId}`);
       return c.json({ ok: false, error: error instanceof Error ? error.message : String(error) }, 500);
@@ -4687,7 +5179,7 @@ function registerMiscRoutes(app, state) {
         const wp = issue.workspacePath;
         const liveLog = wp ? `${wp}/live-output.log` : null;
         let lastSize = 0;
-        if (liveLog && existsSync10(liveLog)) {
+        if (liveLog && existsSync11(liveLog)) {
           try {
             const stat = statSync(liveLog);
             lastSize = stat.size;
@@ -4715,7 +5207,7 @@ function registerMiscRoutes(app, state) {
             return;
           }
           const logPath = currentIssue.workspacePath ? `${currentIssue.workspacePath}/live-output.log` : null;
-          if (logPath && existsSync10(logPath)) {
+          if (logPath && existsSync11(logPath)) {
             try {
               const stat = statSync(logPath);
               if (stat.size > lastSize) {
@@ -4770,7 +5262,7 @@ function registerMiscRoutes(app, state) {
       const liveLog = wp ? `${wp}/live-output.log` : null;
       let logTail = "";
       let logSize = 0;
-      if (liveLog && existsSync10(liveLog)) {
+      if (liveLog && existsSync11(liveLog)) {
         try {
           const stat = statSync(liveLog);
           logSize = stat.size;
@@ -4810,13 +5302,13 @@ function registerMiscRoutes(app, state) {
       const issue = findIssue(state, issueId);
       if (!issue) return c.json({ ok: false, error: "Issue not found." }, 404);
       const wp = issue.workspacePath;
-      if (!wp || !existsSync10(wp)) {
+      if (!wp || !existsSync11(wp)) {
         return c.json({ ok: true, files: [], diff: "", message: "No workspace found." });
       }
       let raw = "";
       if (issue.branchName && issue.baseBranch) {
         try {
-          raw = execSync3(
+          raw = execSync4(
             `git diff --no-color "${issue.baseBranch}"..."${issue.branchName}"`,
             { encoding: "utf8", maxBuffer: 4 * 1024 * 1024, timeout: 15e3, cwd: TARGET_ROOT, stdio: "pipe" }
           );
@@ -4824,11 +5316,11 @@ function registerMiscRoutes(app, state) {
           raw = err.stdout || "";
         }
       } else {
-        if (!existsSync10(SOURCE_ROOT)) {
+        if (!existsSync11(SOURCE_ROOT)) {
           return c.json({ ok: true, files: [], diff: "", message: "Source root not found." });
         }
         try {
-          raw = execSync3(
+          raw = execSync4(
             `git diff --no-index --no-color -- "${SOURCE_ROOT}" "${wp}"`,
             { encoding: "utf8", maxBuffer: 4 * 1024 * 1024, timeout: 15e3 }
           );
@@ -4878,7 +5370,7 @@ function registerMiscRoutes(app, state) {
     try {
       const isGit = (() => {
         try {
-          execSync3("git rev-parse --git-dir", { cwd: TARGET_ROOT, stdio: "pipe" });
+          execSync4("git rev-parse --git-dir", { cwd: TARGET_ROOT, stdio: "pipe" });
           return true;
         } catch {
           return false;
@@ -4887,14 +5379,14 @@ function registerMiscRoutes(app, state) {
       if (!isGit) return c.json({ isGit: false, branch: null, hasCommits: false });
       const branch = (() => {
         try {
-          return execSync3("git rev-parse --abbrev-ref HEAD", { cwd: TARGET_ROOT, encoding: "utf8", stdio: "pipe" }).trim();
+          return execSync4("git rev-parse --abbrev-ref HEAD", { cwd: TARGET_ROOT, encoding: "utf8", stdio: "pipe" }).trim();
         } catch {
           return null;
         }
       })();
       const hasCommits = (() => {
         try {
-          execSync3("git rev-parse HEAD", { cwd: TARGET_ROOT, stdio: "pipe" });
+          execSync4("git rev-parse HEAD", { cwd: TARGET_ROOT, stdio: "pipe" });
           return true;
         } catch {
           return false;
@@ -4907,9 +5399,9 @@ function registerMiscRoutes(app, state) {
   });
   app.post("/api/git/init", async (c) => {
     try {
-      execSync3("git init", { cwd: TARGET_ROOT, stdio: "pipe" });
-      execSync3('git commit --allow-empty -m "Initial commit"', { cwd: TARGET_ROOT, stdio: "pipe" });
-      const branch = execSync3("git rev-parse --abbrev-ref HEAD", { cwd: TARGET_ROOT, encoding: "utf8", stdio: "pipe" }).trim();
+      execSync4("git init", { cwd: TARGET_ROOT, stdio: "pipe" });
+      execSync4('git commit --allow-empty -m "Initial commit"', { cwd: TARGET_ROOT, stdio: "pipe" });
+      const branch = execSync4("git rev-parse --abbrev-ref HEAD", { cwd: TARGET_ROOT, encoding: "utf8", stdio: "pipe" }).trim();
       state.config.defaultBranch = branch;
       await persistState(state);
       return c.json({ ok: true, branch });
@@ -4923,7 +5415,7 @@ function registerMiscRoutes(app, state) {
       if (!branchName || !/^[a-zA-Z0-9/_.-]+$/.test(branchName)) {
         return c.json({ ok: false, error: "Invalid branch name." }, 400);
       }
-      execSync3(`git checkout -b "${branchName}"`, { cwd: TARGET_ROOT, stdio: "pipe" });
+      execSync4(`git checkout -b "${branchName}"`, { cwd: TARGET_ROOT, stdio: "pipe" });
       state.config.defaultBranch = branchName;
       await persistState(state);
       return c.json({ ok: true, defaultBranch: branchName });
@@ -4931,6 +5423,26 @@ function registerMiscRoutes(app, state) {
       return c.json({ ok: false, error: error instanceof Error ? error.message : String(error) }, 500);
     }
   });
+  app.post("/api/git/switch", async (c) => {
+    try {
+      const { branchName } = await c.req.json();
+      if (!branchName || !/^[a-zA-Z0-9/_.-]+$/.test(branchName)) {
+        return c.json({ ok: false, error: "Invalid branch name." }, 400);
+      }
+      let created = false;
+      try {
+        execSync4(`git checkout "${branchName}"`, { cwd: TARGET_ROOT, stdio: "pipe" });
+      } catch {
+        execSync4(`git checkout -b "${branchName}"`, { cwd: TARGET_ROOT, stdio: "pipe" });
+        created = true;
+      }
+      state.config.defaultBranch = branchName;
+      await persistState(state);
+      return c.json({ ok: true, defaultBranch: branchName, created });
+    } catch (error) {
+      return c.json({ ok: false, error: error instanceof Error ? error.message : String(error) }, 500);
+    }
+  });
   app.get("/api/events/feed", async (c) => {
     const since = c.req.query("since");
     const issueId = c.req.query("issueId");
@@ -4944,11 +5456,11 @@ function registerMiscRoutes(app, state) {
   });
   app.get("/api/gitignore/status", async (c) => {
     try {
-      const gitignorePath = join14(TARGET_ROOT, ".gitignore");
-      if (!existsSync10(gitignorePath)) {
+      const gitignorePath = join15(TARGET_ROOT, ".gitignore");
+      if (!existsSync11(gitignorePath)) {
         return c.json({ exists: false, hasFifony: false });
       }
-      const content = readFileSync7(gitignorePath, "utf-8");
+      const content = readFileSync8(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 });
@@ -4959,12 +5471,12 @@ function registerMiscRoutes(app, state) {
   });
   app.post("/api/gitignore/add", async (c) => {
     try {
-      const gitignorePath = join14(TARGET_ROOT, ".gitignore");
-      if (!existsSync10(gitignorePath)) {
-        writeFileSync9(gitignorePath, "# Fifony state directory\n.fifony/\n", "utf-8");
+      const gitignorePath = join15(TARGET_ROOT, ".gitignore");
+      if (!existsSync11(gitignorePath)) {
+        writeFileSync10(gitignorePath, "# Fifony state directory\n.fifony/\n", "utf-8");
         return c.json({ ok: true, created: true });
       }
-      const content = readFileSync7(gitignorePath, "utf-8");
+      const content = readFileSync8(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) {
@@ -4981,6 +5493,51 @@ function registerMiscRoutes(app, state) {
       return c.json({ ok: false, error: "Failed to update .gitignore" }, 500);
     }
   });
+  app.get("/api/issues/:id/outputs", async (c) => {
+    try {
+      const issueId = parseIssue(c);
+      if (!issueId) return c.json({ ok: false, error: "Issue id is required." }, 400);
+      const issue = findIssue(state, issueId);
+      if (!issue) return c.json({ ok: false, error: "Issue not found." }, 404);
+      const wp = issue.workspacePath;
+      if (!wp) return c.json({ ok: true, files: [] });
+      const outputsDir = join15(wp, "outputs");
+      if (!existsSync11(outputsDir)) return c.json({ ok: true, files: [] });
+      const entries = readdirSync3(outputsDir).filter((f) => f.endsWith(".stdout.log")).map((f) => {
+        try {
+          const s = statSync(join15(outputsDir, f));
+          return { name: f, size: s.size };
+        } catch {
+          return { name: f, size: 0 };
+        }
+      });
+      return c.json({ ok: true, files: entries });
+    } catch (error) {
+      return c.json({ ok: false, error: error instanceof Error ? error.message : String(error) }, 500);
+    }
+  });
+  app.get("/api/issues/:id/outputs/:filename", async (c) => {
+    try {
+      const issueId = parseIssue(c);
+      if (!issueId) return c.json({ ok: false, error: "Issue id is required." }, 400);
+      const issue = findIssue(state, issueId);
+      if (!issue) return c.json({ ok: false, error: "Issue not found." }, 404);
+      const filename = c.req.param?.("filename") ?? c.req.params?.filename ?? "";
+      if (!filename) return c.json({ ok: false, error: "Filename is required." }, 400);
+      const safeName = basename3(filename);
+      if (safeName !== filename || !safeName.endsWith(".stdout.log")) {
+        return c.json({ ok: false, error: "Invalid filename." }, 400);
+      }
+      const wp = issue.workspacePath;
+      if (!wp) return c.json({ ok: false, error: "No workspace found." }, 404);
+      const filePath = join15(wp, "outputs", safeName);
+      if (!existsSync11(filePath)) return c.json({ ok: false, error: "Output file not found." }, 404);
+      const content = readFileSync8(filePath, "utf8");
+      return new Response(content, { headers: { "Content-Type": "text/plain; charset=utf-8" } });
+    } catch (error) {
+      return c.json({ ok: false, error: error instanceof Error ? error.message : String(error) }, 500);
+    }
+  });
   app.post("/api/attachments/upload", async (c) => {
     try {
       const payload = await c.req.json();
@@ -4988,15 +5545,15 @@ function registerMiscRoutes(app, state) {
         return c.json({ ok: false, error: "No files provided." }, 400);
       }
       const uploadId = randomUUID2();
-      const uploadDir = join14(ATTACHMENTS_ROOT, "temp", uploadId);
-      mkdirSync5(uploadDir, { recursive: true });
+      const uploadDir = join15(ATTACHMENTS_ROOT, "temp", uploadId);
+      mkdirSync6(uploadDir, { recursive: true });
       const paths = [];
       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 = join14(uploadDir, safeName);
-        writeFileSync9(dest, Buffer.from(file.data, "base64"));
+        const dest = join15(uploadDir, safeName);
+        writeFileSync10(dest, Buffer.from(file.data, "base64"));
         paths.push(dest);
       }
       return c.json({ ok: true, paths, uploadId });
@@ -5051,10 +5608,10 @@ async function startApiServer(state, port) {
   }
   setApiRuntimeContext(state);
   const serveTextFile = (filePath, contentType, cacheControl = "no-cache") => {
-    if (!existsSync11(filePath)) {
+    if (!existsSync12(filePath)) {
       return new Response("Not found", { status: 404 });
     }
-    return new Response(readFileSync8(filePath), {
+    return new Response(readFileSync9(filePath), {
       headers: {
         "content-type": contentType,
         "cache-control": cacheControl
@@ -5062,10 +5619,10 @@ async function startApiServer(state, port) {
     });
   };
   const serveAppShell = () => {
-    if (!existsSync11(FRONTEND_INDEX)) {
+    if (!existsSync12(FRONTEND_INDEX)) {
       return new Response("Not found", { status: 404 });
     }
-    const html = readFileSync8(FRONTEND_INDEX, "utf8").replace('href="/assets/manifest.webmanifest"', 'href="/manifest.webmanifest"').replaceAll('href="/assets/icon.svg"', 'href="/icon.svg"');
+    const html = readFileSync9(FRONTEND_INDEX, "utf8").replace('href="/assets/manifest.webmanifest"', 'href="/manifest.webmanifest"').replaceAll('href="/assets/icon.svg"', 'href="/icon.svg"');
     return new Response(html, {
       headers: {
         "content-type": "text/html; charset=utf-8",
@@ -5086,6 +5643,9 @@ async function startApiServer(state, port) {
     port,
     host: "0.0.0.0",
     versionPrefix: false,
+    metrics: {
+      logLevel: "info"
+    },
     // HTTP + WebSocket on the same port via listeners
     listeners: [{
       bind: { host: "0.0.0.0", port },
@@ -5124,6 +5684,7 @@ async function startApiServer(state, port) {
       "GET /onboarding": () => serveAppShell(),
       "GET /kanban": () => serveAppShell(),
       "GET /issues": () => serveAppShell(),
+      "GET /analytics": () => serveAppShell(),
       "GET /agents": () => serveAppShell(),
       "GET /settings": () => serveAppShell(),
       "GET /settings/general": () => serveAppShell(),
@@ -5433,7 +5994,6 @@ async function persistState(state) {
   broadcastToWebSocketClients({
     type: "state:update",
     metrics: state.metrics,
-    capabilities: computeCapabilityCounts(state.issues),
     issues: state.issues,
     events: state.events.slice(0, 50),
     updatedAt: state.updatedAt
@@ -5577,12 +6137,6 @@ async function closeStateStore() {
 
 // src/domains/project.ts
 var SETTING_ID_PROJECT_NAME = "system.projectName";
-var LEGACY_PROJECT_SETTING_IDS = [
-  "runtime.projectName",
-  "ui.projectName",
-  "projectName",
-  "project.name"
-];
 function normalizeProjectName(value) {
   return typeof value === "string" ? value.trim().replace(/\s+/g, " ") : "";
 }
@@ -5592,14 +6146,7 @@ function detectProjectName(targetRoot) {
   return normalizeProjectName(basename4(normalizedPath));
 }
 function readSavedProjectName(settings) {
-  const settingIds = [SETTING_ID_PROJECT_NAME, ...LEGACY_PROJECT_SETTING_IDS];
-  for (const id of settingIds) {
-    const value = normalizeProjectName(settings.find((setting) => setting.id === id)?.value);
-    if (value) {
-      return value;
-    }
-  }
-  return "";
+  return normalizeProjectName(settings.find((s) => s.id === SETTING_ID_PROJECT_NAME)?.value);
 }
 function buildQueueTitle(projectName) {
   const normalizedProjectName = normalizeProjectName(projectName);
@@ -5617,7 +6164,7 @@ function resolveProjectMetadata(settings, targetRoot) {
   };
 }
 function scanProjectFiles(targetRoot) {
-  const check = (rel) => existsSync12(join15(targetRoot, rel));
+  const check = (rel) => existsSync13(join16(targetRoot, rel));
   const files = {
     claudeMd: check("CLAUDE.md"),
     claudeDir: check(".claude"),
@@ -5638,10 +6185,10 @@ function scanProjectFiles(targetRoot) {
   };
   const existingAgents = [];
   for (const agentDir of [".claude/agents", ".codex/agents"]) {
-    const fullPath = join15(targetRoot, agentDir);
-    if (!existsSync12(fullPath)) continue;
+    const fullPath = join16(targetRoot, agentDir);
+    if (!existsSync13(fullPath)) continue;
     try {
-      const entries = readdirSync3(fullPath);
+      const entries = readdirSync4(fullPath);
       for (const entry of entries) {
         if (entry.endsWith(".md")) {
           existingAgents.push(basename4(entry, ".md"));
@@ -5652,13 +6199,13 @@ function scanProjectFiles(targetRoot) {
   }
   const existingSkills = [];
   for (const skillDir of [".claude/skills", ".codex/skills"]) {
-    const fullPath = join15(targetRoot, skillDir);
-    if (!existsSync12(fullPath)) continue;
+    const fullPath = join16(targetRoot, skillDir);
+    if (!existsSync13(fullPath)) continue;
     try {
-      const entries = readdirSync3(fullPath);
+      const entries = readdirSync4(fullPath);
       for (const entry of entries) {
-        const skillFile = join15(fullPath, entry, "SKILL.md");
-        if (existsSync12(skillFile)) {
+        const skillFile = join16(fullPath, entry, "SKILL.md");
+        if (existsSync13(skillFile)) {
           existingSkills.push(entry);
         }
       }
@@ -5666,20 +6213,20 @@ function scanProjectFiles(targetRoot) {
     }
   }
   let readmeExcerpt = "";
-  const readmePath = join15(targetRoot, "README.md");
-  if (existsSync12(readmePath)) {
+  const readmePath = join16(targetRoot, "README.md");
+  if (existsSync13(readmePath)) {
     try {
-      const content = readFileSync9(readmePath, "utf8");
+      const content = readFileSync10(readmePath, "utf8");
       readmeExcerpt = content.slice(0, 200).trim();
     } catch {
     }
   }
   let packageName = "";
   let packageDescription = "";
-  const pkgPath = join15(targetRoot, "package.json");
-  if (existsSync12(pkgPath)) {
+  const pkgPath = join16(targetRoot, "package.json");
+  if (existsSync13(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync9(pkgPath, "utf8"));
+      const pkg = JSON.parse(readFileSync10(pkgPath, "utf8"));
       packageName = typeof pkg.name === "string" ? pkg.name : "";
       packageDescription = typeof pkg.description === "string" ? pkg.description : "";
     } catch {
@@ -5721,39 +6268,39 @@ function buildFallbackAnalysis(targetRoot) {
   let description = "";
   let readmeExcerpt = "";
   for (const readmeFile of ["README.md", "README.rst", "README.txt", "README"]) {
-    const p = join15(targetRoot, readmeFile);
-    if (existsSync12(p)) {
+    const p = join16(targetRoot, readmeFile);
+    if (existsSync13(p)) {
       try {
-        readmeExcerpt = readFileSync9(p, "utf8").slice(0, 300).trim();
+        readmeExcerpt = readFileSync10(p, "utf8").slice(0, 300).trim();
         break;
       } catch {
       }
     }
   }
-  const pkgPath = join15(targetRoot, "package.json");
-  if (existsSync12(pkgPath)) {
+  const pkgPath = join16(targetRoot, "package.json");
+  if (existsSync13(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync9(pkgPath, "utf8"));
+      const pkg = JSON.parse(readFileSync10(pkgPath, "utf8"));
       const name = typeof pkg.name === "string" ? pkg.name : "";
       const desc = typeof pkg.description === "string" ? pkg.description : "";
       if (desc) description = name ? `${name}: ${desc}` : desc;
     } catch {
     }
   }
-  const cargoPath = join15(targetRoot, "Cargo.toml");
-  if (!description && existsSync12(cargoPath)) {
+  const cargoPath = join16(targetRoot, "Cargo.toml");
+  if (!description && existsSync13(cargoPath)) {
     try {
-      const content = readFileSync9(cargoPath, "utf8");
+      const content = readFileSync10(cargoPath, "utf8");
       const descMatch = content.match(/^description\s*=\s*"([^"]+)"/m);
       const nameMatch = content.match(/^name\s*=\s*"([^"]+)"/m);
       if (descMatch) description = nameMatch ? `${nameMatch[1]}: ${descMatch[1]}` : descMatch[1];
     } catch {
     }
   }
-  const pyprojectPath = join15(targetRoot, "pyproject.toml");
-  if (!description && existsSync12(pyprojectPath)) {
+  const pyprojectPath = join16(targetRoot, "pyproject.toml");
+  if (!description && existsSync13(pyprojectPath)) {
     try {
-      const content = readFileSync9(pyprojectPath, "utf8");
+      const content = readFileSync10(pyprojectPath, "utf8");
       const descMatch = content.match(/^description\s*=\s*"([^"]+)"/m);
       const nameMatch = content.match(/^name\s*=\s*"([^"]+)"/m);
       if (descMatch) description = nameMatch ? `${nameMatch[1]}: ${descMatch[1]}` : descMatch[1];
@@ -5766,7 +6313,7 @@ function buildFallbackAnalysis(targetRoot) {
   let language = "unknown";
   const stack = [];
   for (const [file, signal] of Object.entries(BUILD_FILE_SIGNALS)) {
-    if (existsSync12(join15(targetRoot, file))) {
+    if (existsSync13(join16(targetRoot, file))) {
       if (language === "unknown" && signal.language !== "unknown") {
         language = signal.language;
       }
@@ -5849,7 +6396,7 @@ function isBlockedProjectAnalysisResponse(analysis) {
 var ANALYSIS_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 function computeProjectHash(targetRoot) {
   const buildFiles = Object.keys(BUILD_FILE_SIGNALS);
-  const found = buildFiles.filter((f) => existsSync12(join15(targetRoot, f))).sort();
+  const found = buildFiles.filter((f) => existsSync13(join16(targetRoot, f))).sort();
   return createHash("sha256").update(found.join(",")).digest("hex").slice(0, 16);
 }
 async function loadCachedAnalysis(targetRoot) {
@@ -5901,10 +6448,10 @@ async function analyzeProjectWithCli(provider, targetRoot, options) {
     );
     return buildFallbackAnalysis(targetRoot);
   }
-  const tempDir = mkdtempSync4(join15(tmpdir4(), "fifony-scan-"));
-  const promptFile = join15(tempDir, "fifony-scan-prompt.txt");
+  const tempDir = mkdtempSync4(join16(tmpdir4(), "fifony-scan-"));
+  const promptFile = join16(tempDir, "fifony-scan-prompt.txt");
   const analysisPrompt = await renderPrompt("project-analysis");
-  writeFileSync10(promptFile, analysisPrompt, "utf8");
+  writeFileSync11(promptFile, analysisPrompt, "utf8");
   const processEnv = {};
   for (const [key, value] of Object.entries(env3)) {
     if (typeof value === "string") processEnv[key] = value;
@@ -6022,6 +6569,12 @@ var DEFAULT_REFERENCE_REPOSITORIES = [
     name: "pbakaus/impeccable",
     url: "https://github.com/pbakaus/impeccable.git",
     description: "Frontend polish and impeccable-style quality workflows."
+  },
+  {
+    id: "everything-claude-code",
+    name: "affaan-m/everything-claude-code",
+    url: "https://github.com/affaan-m/everything-claude-code.git",
+    description: "28 specialized agents, 116 skills, and 59 commands \u2014 agent harness performance system."
   }
 ];
 var REPOSITORY_ROOT = resolve2(homedir3(), ".fifony", "repositories");
@@ -6046,7 +6599,7 @@ var REFERENCE_REPOSITORY_PARSERS = {
   impeccable: collectImpeccableArtifacts
 };
 function runGit(args, cwd) {
-  return execFileSync("git", args, {
+  return execFileSync2("git", args, {
     cwd,
     encoding: "utf8",
     stdio: "pipe",
@@ -6073,7 +6626,7 @@ function uniqueSuffix(base, used) {
 }
 function collectDirectoryEntries(path) {
   try {
-    return readdirSync3(path, { withFileTypes: true });
+    return readdirSync4(path, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -6099,7 +6652,7 @@ function isMarkdownFile(value, expectedName) {
 function isReferenceFrontMatterFile(filePath) {
   let source;
   try {
-    source = readFileSync9(filePath, "utf8");
+    source = readFileSync10(filePath, "utf8");
   } catch {
     return false;
   }
@@ -6121,10 +6674,10 @@ function collectAgentArtifacts(agentsDir, usedNames, out) {
   const parent = slugify(basename4(dirname2(agentsDir)));
   const entries = collectDirectoryEntries(agentsDir);
   for (const entry of entries) {
-    const itemPath = join15(agentsDir, entry.name);
+    const itemPath = join16(agentsDir, entry.name);
     if (entry.isDirectory()) {
-      const nestedAgentSpec = join15(itemPath, "AGENT.md");
-      if (existsSync12(nestedAgentSpec)) {
+      const nestedAgentSpec = join16(itemPath, "AGENT.md");
+      if (existsSync13(nestedAgentSpec)) {
         const name2 = uniqueSuffix(`${parent}__${slugify(entry.name)}`, usedNames);
         out.push({ kind: "agent", sourcePath: nestedAgentSpec, targetName: name2 });
       }
@@ -6145,10 +6698,10 @@ function collectSkillArtifacts(skillsDir, usedNames, out) {
   const parent = slugify(basename4(dirname2(skillsDir)));
   const entries = collectDirectoryEntries(skillsDir);
   for (const entry of entries) {
-    const itemPath = join15(skillsDir, entry.name);
+    const itemPath = join16(skillsDir, entry.name);
     if (entry.isDirectory()) {
-      const skillFile = join15(itemPath, "SKILL.md");
-      if (existsSync12(skillFile)) {
+      const skillFile = join16(itemPath, "SKILL.md");
+      if (existsSync13(skillFile)) {
         const name = uniqueSuffix(`${parent}__${slugify(entry.name)}`, usedNames);
         out.push({ kind: "skill", sourcePath: skillFile, targetName: name });
       }
@@ -6175,7 +6728,7 @@ function collectStandardArtifacts(repoPath) {
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (SKIP_DIRS.has(entry.name)) continue;
-      const childPath = join15(state.path, entry.name);
+      const childPath = join16(state.path, entry.name);
       if (entry.name === "agents") {
         collectAgentArtifacts(childPath, agentsUsed, artifacts);
       }
@@ -6203,13 +6756,13 @@ function collectAgencyArtifacts(repoPath) {
         if (SKIP_DIRS.has(entry.name) || AGENCY_AGENTS_EXCLUDED_DIRS.has(entry.name)) {
           continue;
         }
-        queue.push({ path: join15(state.path, entry.name), depth: state.depth + 1 });
+        queue.push({ path: join16(state.path, entry.name), depth: state.depth + 1 });
         continue;
       }
-      if (!isMarkdownFile(entry.name, "readme.md") || !isReferenceFrontMatterFile(join15(state.path, entry.name))) {
+      if (!isMarkdownFile(entry.name, "readme.md") || !isReferenceFrontMatterFile(join16(state.path, entry.name))) {
         continue;
       }
-      const itemPath = join15(state.path, entry.name);
+      const itemPath = join16(state.path, entry.name);
       const targetName = uniqueSuffix(buildRelativeArtifactName(repoPath, itemPath), agentsUsed);
       artifacts.push({
         kind: "agent",
@@ -6223,13 +6776,13 @@ function collectAgencyArtifacts(repoPath) {
 function collectImpeccableArtifacts(repoPath) {
   const skillsUsed = /* @__PURE__ */ new Set();
   const artifacts = [];
-  const sourceSkills = join15(repoPath, "source", "skills");
-  if (existsSync12(sourceSkills)) {
+  const sourceSkills = join16(repoPath, "source", "skills");
+  if (existsSync13(sourceSkills)) {
     collectSkillArtifacts(sourceSkills, skillsUsed, artifacts);
     return artifacts;
   }
-  const claudeSkills = join15(repoPath, ".claude", "skills");
-  if (existsSync12(claudeSkills)) {
+  const claudeSkills = join16(repoPath, ".claude", "skills");
+  if (existsSync13(claudeSkills)) {
     collectSkillArtifacts(claudeSkills, skillsUsed, artifacts);
   }
   return artifacts;
@@ -6255,19 +6808,19 @@ function getReferenceRepositoriesRoot() {
 }
 function listReferenceRepositories() {
   return DEFAULT_REFERENCE_REPOSITORIES.map((repo) => {
-    const path = join15(REPOSITORY_ROOT, repo.id);
+    const path = join16(REPOSITORY_ROOT, repo.id);
     const status = {
       id: repo.id,
       name: repo.name,
       url: repo.url,
       path,
-      present: existsSync12(path),
+      present: existsSync13(path),
       synced: false
     };
     if (!status.present) {
       return status;
     }
-    if (!existsSync12(join15(path, ".git"))) {
+    if (!existsSync13(join16(path, ".git"))) {
       status.error = "Path exists but is not a git repo";
       return status;
     }
@@ -6291,7 +6844,7 @@ function resolveReferenceRepository(query) {
 }
 function syncReferenceRepositories(repositoryId) {
   const root = REPOSITORY_ROOT;
-  mkdirSync6(root, { recursive: true });
+  mkdirSync7(root, { recursive: true });
   const repos = repositoryId ? [resolveReferenceRepository(repositoryId)] : DEFAULT_REFERENCE_REPOSITORIES;
   const selected = repos.filter((repo) => Boolean(repo));
   if (repositoryId && selected.length === 0) {
@@ -6299,9 +6852,9 @@ function syncReferenceRepositories(repositoryId) {
   }
   const results = [];
   for (const repo of selected) {
-    const target = join15(root, repo.id);
+    const target = join16(root, repo.id);
     const candidates = [repo.url, ...repo.fallbackUrls ?? []];
-    if (!existsSync12(target)) {
+    if (!existsSync13(target)) {
       let cloneError;
       for (const candidate of candidates) {
         try {
@@ -6328,7 +6881,7 @@ function syncReferenceRepositories(repositoryId) {
       }
       continue;
     }
-    if (!existsSync12(join15(target, ".git"))) {
+    if (!existsSync13(join16(target, ".git"))) {
       results.push({
         id: repo.id,
         path: target,
@@ -6363,14 +6916,14 @@ function importReferenceArtifacts(repositoryId, workspaceRoot, options) {
   if (!repository) {
     throw new Error(`Unknown reference repository: ${repositoryId}`);
   }
-  const localPath = join15(REPOSITORY_ROOT, repository.id);
-  if (!existsSync12(localPath)) {
+  const localPath = join16(REPOSITORY_ROOT, repository.id);
+  if (!existsSync13(localPath)) {
     throw new Error(`Repository not synced yet: ${repository.id}. Run 'fifony onboarding sync --repository ${repository.id}' first.`);
   }
   const basePath = resolve2(workspaceRoot);
-  const targetBase = options.importToGlobal ? join15(homedir3(), ".codex") : join15(basePath, ".codex");
-  const agentsDir = join15(targetBase, "agents");
-  const skillsDir = join15(targetBase, "skills");
+  const targetBase = options.importToGlobal ? join16(homedir3(), ".codex") : join16(basePath, ".codex");
+  const agentsDir = join16(targetBase, "agents");
+  const skillsDir = join16(targetBase, "skills");
   const artifacts = collectArtifacts(localPath, repository.id);
   const filtered = options.kind === "all" ? artifacts : artifacts.filter((artifact) => artifact.kind === options.kind.slice(0, -1));
   const summary = {
@@ -6388,16 +6941,16 @@ function importReferenceArtifacts(repositoryId, workspaceRoot, options) {
     return summary;
   }
   if (!options.dryRun) {
-    mkdirSync6(targetBase, { recursive: true });
-    mkdirSync6(agentsDir, { recursive: true });
-    mkdirSync6(skillsDir, { recursive: true });
+    mkdirSync7(targetBase, { recursive: true });
+    mkdirSync7(agentsDir, { recursive: true });
+    mkdirSync7(skillsDir, { recursive: true });
   }
   for (const artifact of filtered) {
     try {
-      const source = readFileSync9(artifact.sourcePath, "utf8");
+      const source = readFileSync10(artifact.sourcePath, "utf8");
       if (artifact.kind === "agent") {
-        const target = join15(agentsDir, `${artifact.targetName}.md`);
-        if (!options.overwrite && existsSync12(target)) {
+        const target = join16(agentsDir, `${artifact.targetName}.md`);
+        if (!options.overwrite && existsSync13(target)) {
           summary.skippedAgents.push(artifact.targetName);
           continue;
         }
@@ -6405,12 +6958,12 @@ function importReferenceArtifacts(repositoryId, workspaceRoot, options) {
           summary.importedAgents.push(artifact.targetName);
           continue;
         }
-        writeFileSync10(target, source, "utf8");
+        writeFileSync11(target, source, "utf8");
         summary.importedAgents.push(artifact.targetName);
       } else {
-        const targetDir = join15(skillsDir, artifact.targetName);
-        const target = join15(targetDir, "SKILL.md");
-        if (!options.overwrite && existsSync12(target)) {
+        const targetDir = join16(skillsDir, artifact.targetName);
+        const target = join16(targetDir, "SKILL.md");
+        if (!options.overwrite && existsSync13(target)) {
           summary.skippedSkills.push(artifact.targetName);
           continue;
         }
@@ -6418,8 +6971,8 @@ function importReferenceArtifacts(repositoryId, workspaceRoot, options) {
           summary.importedSkills.push(artifact.targetName);
           continue;
         }
-        mkdirSync6(targetDir, { recursive: true });
-        writeFileSync10(target, source, "utf8");
+        mkdirSync7(targetDir, { recursive: true });
+        writeFileSync11(target, source, "utf8");
         summary.importedSkills.push(artifact.targetName);
       }
     } catch (error) {
@@ -6533,6 +7086,37 @@ function validateConfig(config) {
 }
 
 // src/domains/issues.ts
+function normalizeIssue(raw) {
+  const id = toStringValue(raw.id, "");
+  if (!id) return null;
+  const createdAt = toStringValue(raw.createdAt, now());
+  const updatedAt = toStringValue(raw.updatedAt, createdAt);
+  const issue = {
+    id,
+    identifier: toStringValue(raw.identifier, id),
+    title: toStringValue(raw.title, `Issue ${id}`),
+    description: toStringValue(raw.description, ""),
+    state: normalizeState(raw.state, raw.plan && typeof raw.plan === "object" ? "PendingApproval" : "Planning"),
+    branchName: toStringValue(raw.branchName),
+    url: toStringValue(raw.url),
+    assigneeId: toStringValue(raw.assigneeId),
+    labels: toStringArray(raw.labels),
+    paths: toStringArray(raw.paths),
+    blockedBy: toStringArray(raw.blockedBy),
+    assignedToWorker: toBooleanValue(raw.assignedToWorker, true),
+    createdAt,
+    updatedAt,
+    history: [],
+    attempts: toNumberValue(raw.attempts, 0),
+    maxAttempts: toNumberValue(raw.maxAttempts, 3),
+    nextRetryAt: toStringValue(raw.nextRetryAt),
+    planVersion: 0,
+    executeAttempt: 0,
+    reviewAttempt: 0,
+    planHistory: []
+  };
+  return issue;
+}
 function nextLocalIssueId(issues) {
   const maxId = issues.reduce((current, issue) => {
     const match = issue.identifier.match(/^#(\d+)$/);
@@ -6550,13 +7134,12 @@ function createIssueFromPayload(payload, issues, defaultBranch) {
   const blockedBy = toStringArray(payload.blockedBy);
   const paths = toStringArray(payload.paths);
   const images = toStringArray(payload.images);
-  const initialState = parseIssueState(payload.state) ?? (payload.plan ? "Planned" : "Planning");
+  const initialState = parseIssueState(payload.state) ?? (payload.plan ? "PendingApproval" : "Planning");
   const issue = {
     id,
     identifier,
     title: toStringValue(payload.title, `Issue ${identifier}`),
     description: toStringValue(payload.description, ""),
-    priority: clamp(toNumberValue(payload.priority, 1), 1, 10),
     state: initialState,
     branchName: toStringValue(payload.branchName),
     baseBranch: toStringValue(payload.baseBranch) || defaultBranch,
@@ -6564,10 +7147,6 @@ function createIssueFromPayload(payload, issues, defaultBranch) {
     assigneeId: toStringValue(payload.assigneeId),
     labels: toStringArray(payload.labels),
     paths,
-    inferredPaths: [],
-    capabilityCategory: "",
-    capabilityOverlays: [],
-    capabilityRationale: [],
     blockedBy,
     assignedToWorker: true,
     createdAt,
@@ -6589,21 +7168,10 @@ function createIssueFromPayload(payload, issues, defaultBranch) {
     if (issue.plan.suggestedPaths?.length && !issue.paths?.length) {
       issue.paths = issue.plan.suggestedPaths;
     }
-    if (issue.plan.suggestedLabels?.length && !issue.labels?.length) {
-      issue.labels = issue.plan.suggestedLabels;
-    }
     if (issue.plan.suggestedEffort && !issue.effort) {
       issue.effort = issue.plan.suggestedEffort;
     }
   }
-  applyCapabilityMetadata(issue, resolveTaskCapabilities({
-    id: issue.id,
-    identifier: issue.identifier,
-    title: issue.title,
-    description: issue.description,
-    labels: issue.labels,
-    paths: issue.paths
-  }, getCapabilityRoutingOptions()));
   return issue;
 }
 function dedupHistoryEntries(issues) {
@@ -6627,13 +7195,10 @@ function buildRuntimeState(previous, config, projectMetadata = resolveProjectMet
       identifier: toStringValue(existing.identifier, existing.id),
       title: toStringValue(existing.title, `Issue ${toStringValue(existing.identifier, existing.id)}`),
       description: toStringValue(existing.description, ""),
-      state: normalizeState(existing.state, existing.plan ? "Planned" : "Planning"),
+      state: normalizeState(existing.state, existing.plan ? "PendingApproval" : "Planning"),
       paths: toStringArray(existing.paths),
-      inferredPaths: toStringArray(existing.inferredPaths),
       labels: toStringArray(existing.labels),
-      capabilityOverlays: toStringArray(existing.capabilityOverlays),
-      capabilityRationale: toStringArray(existing.capabilityRationale),
-      blockedBy: toStringArray(existing.blockedBy).length > 0 ? toStringArray(existing.blockedBy) : toStringArray(existing.blocked_by),
+      blockedBy: toStringArray(existing.blockedBy),
       history: Array.isArray(existing.history) ? existing.history : [],
       attempts: clamp(toNumberValue(existing.attempts, 0), 0, config.maxAttemptsDefault),
       maxAttempts: clamp(toNumberValue(existing.maxAttempts, config.maxAttemptsDefault), 1, config.maxAttemptsDefault),
@@ -6706,6 +7271,14 @@ async function transitionIssue(issue, event, context2 = {}) {
   logger.debug({ issueId: issue.id, identifier: issue.identifier, from: issue.state, event, context: context2 }, "[State] Issue transition");
   await executeTransition(issue, event, { ...context2, issue });
 }
+function issueDependenciesResolved(issue, allIssues) {
+  if (issue.blockedBy.length === 0) return true;
+  const map = new Map(allIssues.map((entry) => [entry.id, entry]));
+  return issue.blockedBy.every((dependencyId) => {
+    const dep = map.get(dependencyId);
+    return dep?.state === "Approved" || dep?.state === "Merged";
+  });
+}
 function getNextRetryAt(issue, baseMs) {
   const nextAttempt = issue.attempts + 1;
   const nextDelay = withRetryBackoff(nextAttempt, baseMs);
@@ -6723,7 +7296,7 @@ async function handleStatePatch(state, issue, payload) {
   for (const event of path) {
     await transitionIssue(issue, event, { note: `Manual state update: ${nextState}`, reason: toStringValue(payload.reason) });
   }
-  if (nextState === "Planned") {
+  if (nextState === "PendingApproval") {
     issue.nextRetryAt = void 0;
     issue.lastError = void 0;
   }
@@ -6733,6 +7306,34 @@ async function handleStatePatch(state, issue, payload) {
   addEvent(state, issue.id, "manual", `Manual state transition to ${nextState}`);
 }
 
+// src/commands/request-rework.command.ts
+async function requestReworkCommand(input, deps) {
+  const { issue, reviewerFeedback, note } = input;
+  if (issue.state !== "Reviewing" && issue.state !== "PendingDecision") {
+    throw new Error(
+      `requestReworkCommand requires Reviewing or PendingDecision state, got ${issue.state}.`
+    );
+  }
+  issue.lastError = reviewerFeedback;
+  issue.lastFailedPhase = "review";
+  issue.attempts += 1;
+  if (issue.state === "Reviewing") {
+    await transitionIssueCommand(
+      { issue, target: "PendingDecision", note: `Reviewer completed for ${issue.identifier}.` },
+      deps
+    );
+  }
+  await transitionIssueCommand(
+    { issue, target: "Queued", note: note ?? `Reviewer requested rework for ${issue.identifier}.` },
+    deps
+  );
+  deps.eventStore.addEvent(
+    issue.id,
+    "runner",
+    `Issue ${issue.identifier} sent back for rework by reviewer.`
+  );
+}
+
 // src/agents/issue-runner.ts
 async function runPlanningJob(state, issue) {
   issue.planningStatus = "planning";
@@ -6741,8 +7342,8 @@ async function runPlanningJob(state, issue) {
   issue.updatedAt = now();
   markIssueDirty(issue.id);
   const safeId = idToSafePath(issue.id);
-  const workspaceDir = join16(WORKSPACE_ROOT, safeId);
-  mkdirSync7(workspaceDir, { recursive: true });
+  const workspaceDir = join17(WORKSPACE_ROOT, safeId);
+  mkdirSync8(workspaceDir, { recursive: true });
   addEvent(state, issue.id, "info", `Plan generation started for ${issue.identifier} (v${(issue.planVersion ?? 0) + 1}).`);
   try {
     const { plan, usage, prompt } = await generatePlan(
@@ -6756,7 +7357,6 @@ async function runPlanningJob(state, issue) {
     markIssuePlanDirty(issue.id);
     issue.planVersion = Math.max(issue.planVersion ?? 0, 1);
     if (plan.suggestedPaths?.length && !issue.paths?.length) issue.paths = plan.suggestedPaths;
-    if (plan.suggestedLabels?.length && !issue.labels?.length) issue.labels = plan.suggestedLabels;
     if (plan.suggestedEffort && !issue.effort) issue.effort = plan.suggestedEffort;
     if (usage.totalTokens > 0) {
       addTokenUsage(issue, {
@@ -6768,8 +7368,8 @@ async function runPlanningJob(state, issue) {
     }
     const pv = issue.planVersion;
     try {
-      writeFileSync11(join16(workspaceDir, `plan.v${pv}.json`), JSON.stringify(plan, null, 2), "utf8");
-      writeFileSync11(join16(workspaceDir, `plan.v${pv}.prompt.md`), prompt, "utf8");
+      writeFileSync12(join17(workspaceDir, `plan.v${pv}.json`), JSON.stringify(plan, null, 2), "utf8");
+      writeFileSync12(join17(workspaceDir, `plan.v${pv}.prompt.md`), prompt, "utf8");
     } catch (artifactErr) {
       logger.warn({ err: String(artifactErr) }, "[Agent] Failed to write versioned plan artifacts");
     }
@@ -6798,21 +7398,21 @@ async function handleReviewStage(state, issue, workspacePath, startTs, routedPro
   const reviewer = routedProviders.find((p) => p.role === "reviewer");
   if (!reviewer) {
     issue.mergedReason = "Auto-approved: no reviewer configured.";
-    await transitionIssueCommand({ issue, target: "Done", note: `No reviewer configured; auto-approved for ${issue.identifier}.` }, container);
+    await transitionIssueCommand({ issue, target: "Approved", note: `No reviewer configured; auto-approved for ${issue.identifier}.` }, container);
     return;
   }
   addEvent(state, issue.id, "info", `Review provider: ${reviewer.role}:${reviewer.provider}${reviewer.model ? `/${reviewer.model}` : ""}${reviewer.profile ? `:${reviewer.profile}` : ""}.`);
   let diffSummary = "";
   try {
     if (issue.baseBranch && issue.branchName) {
-      const diffResult = execSync4(
+      const diffResult = execSync5(
         `git diff --stat "${issue.baseBranch}"..."${issue.branchName}"`,
         { cwd: TARGET_ROOT, encoding: "utf8", maxBuffer: 512e3, timeout: 1e4 }
       );
       diffSummary = diffResult.trim();
     } else {
       const diffTarget = issue.worktreePath ?? workspacePath;
-      const diffResult = execSync4(
+      const diffResult = execSync5(
         `git diff --no-index --stat -- "${SOURCE_ROOT}" "${diffTarget}" 2>/dev/null`,
         { encoding: "utf8", maxBuffer: 512e3, timeout: 1e4 }
       );
@@ -6821,10 +7421,10 @@ async function handleReviewStage(state, issue, workspacePath, startTs, routedPro
   } catch (err) {
     diffSummary = (err.stdout || "").trim();
   }
-  const compiled = await compileReview(issue, reviewer, workspacePath, diffSummary);
+  const compiled = await compileReview(issue, reviewer, workspacePath, diffSummary, state.config);
   const effectiveReviewer = { ...reviewer, command: compiled.command || reviewer.command };
-  const reviewPromptFile = join16(workspacePath, "review-prompt.md");
-  writeFileSync11(reviewPromptFile, `${compiled.prompt}
+  const reviewPromptFile = join17(workspacePath, "review-prompt.md");
+  writeFileSync12(reviewPromptFile, `${compiled.prompt}
 `, "utf8");
   const reviewResult = await runAgentSession(state, issue, effectiveReviewer, 1, workspacePath, compiled.prompt, reviewPromptFile);
   issue.durationMs = (issue.durationMs ?? 0) + (Date.now() - startTs);
@@ -6835,27 +7435,40 @@ async function handleReviewStage(state, issue, workspacePath, startTs, routedPro
   try {
     const rpv = issue.planVersion ?? 1;
     const rra = issue.reviewAttempt ?? 1;
-    const vReviewPromptSrc = join16(workspacePath, "review-prompt.md");
-    const vReviewAuditSrc = join16(workspacePath, "execution-audit.json");
-    if (existsSync13(vReviewPromptSrc)) {
-      writeFileSync11(join16(workspacePath, `review.v${rpv}a${rra}.prompt.md`), readFileSync10(vReviewPromptSrc, "utf8"), "utf8");
+    const vReviewPromptSrc = join17(workspacePath, "review-prompt.md");
+    const vReviewAuditSrc = join17(workspacePath, "execution-audit.json");
+    if (existsSync14(vReviewPromptSrc)) {
+      writeFileSync12(join17(workspacePath, `review.v${rpv}a${rra}.prompt.md`), readFileSync11(vReviewPromptSrc, "utf8"), "utf8");
     }
-    if (existsSync13(vReviewAuditSrc)) {
-      writeFileSync11(join16(workspacePath, `review.v${rpv}a${rra}.audit.json`), readFileSync10(vReviewAuditSrc, "utf8"), "utf8");
+    if (existsSync14(vReviewAuditSrc)) {
+      writeFileSync12(join17(workspacePath, `review.v${rpv}a${rra}.audit.json`), readFileSync11(vReviewAuditSrc, "utf8"), "utf8");
     }
   } catch (vErr) {
     logger.warn({ err: String(vErr) }, "[Agent] Failed to write versioned review artifacts");
   }
   if (reviewResult.success) {
     issue.mergedReason = `Auto-approved by reviewer in ${reviewResult.turns} turn(s).`;
-    await transitionIssueCommand({ issue, target: "Reviewed", note: `Reviewer completed for ${issue.identifier}.` }, container);
-    await transitionIssueCommand({ issue, target: "Done", note: `Reviewer approved ${issue.identifier} in ${reviewResult.turns} turn(s).` }, container);
+    await transitionIssueCommand({ issue, target: "PendingDecision", note: `Reviewer completed for ${issue.identifier}.` }, container);
+    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 }, "[Agent] Validation gate failed \u2014 staying in Reviewed");
+        return;
+      }
+      addEvent(state, issue.id, "info", `Validation gate passed for ${issue.identifier}.`);
+    }
+    await transitionIssueCommand({ issue, target: "Approved", note: `Reviewer approved ${issue.identifier} in ${reviewResult.turns} turn(s).` }, container);
   } else if (reviewResult.continueRequested) {
-    await transitionIssueCommand({ issue, target: "Reviewed", note: `Reviewer completed for ${issue.identifier}.` }, container);
-    await transitionIssueCommand({ issue, target: "Queued", note: `Reviewer requested rework for ${issue.identifier}.` }, container);
-    container.eventStore.addEvent(issue.id, "runner", `Issue ${issue.identifier} sent back for rework by reviewer.`);
+    await requestReworkCommand(
+      { issue, reviewerFeedback: reviewResult.output, note: `Reviewer requested rework for ${issue.identifier}.` },
+      container
+    );
   } else {
     issue.lastError = reviewResult.output;
+    issue.lastFailedPhase = "review";
     issue.attempts += 1;
     if (issue.attempts >= issue.maxAttempts) {
       issue.cancelledReason = `Max attempts reached (${issue.attempts}/${issue.maxAttempts}): reviewer failed or blocked.`;
@@ -6873,12 +7486,8 @@ async function handleExecutionStage(state, issue, workspacePath, promptText, pro
   container.eventStore.addEvent(
     issue.id,
     "info",
-    `Capability routing selected ${routedProviders.map((p) => `${p.role}:${p.provider}${p.model ? `/${p.model}` : ""}${p.profile ? `:${p.profile}` : ""}${p.reasoningEffort ? ` [${p.reasoningEffort}]` : ""}`).join(", ")}.`
+    `Agent providers: ${routedProviders.map((p) => `${p.role}:${p.provider}${p.model ? `/${p.model}` : ""}${p.reasoningEffort ? ` [${p.reasoningEffort}]` : ""}`).join(", ")}.`
   );
-  const routingSignals = describeRoutingSignals(issue, workspaceDerivedPaths);
-  if (routingSignals) {
-    container.eventStore.addEvent(issue.id, "info", `Capability routing signals: ${routingSignals}.`);
-  }
   const runResult = await runAgentPipeline(state, issue, workspacePath, promptText, promptFile, workflowConfig);
   issue.durationMs = Date.now() - startTs;
   issue.commandExitCode = runResult.code;
@@ -6898,13 +7507,13 @@ async function handleExecutionStage(state, issue, workspacePath, promptText, pro
       try {
         const epv = issue.planVersion ?? 1;
         const eea = issue.executeAttempt ?? 1;
-        const vExecPromptSrc = join16(workspacePath, "prompt.md");
-        const vExecAuditSrc = join16(workspacePath, "execution-audit.json");
-        if (existsSync13(vExecPromptSrc)) {
-          writeFileSync11(join16(workspacePath, `execute.v${epv}a${eea}.prompt.md`), readFileSync10(vExecPromptSrc, "utf8"), "utf8");
+        const vExecPromptSrc = join17(workspacePath, "prompt.md");
+        const vExecAuditSrc = join17(workspacePath, "execution-audit.json");
+        if (existsSync14(vExecPromptSrc)) {
+          writeFileSync12(join17(workspacePath, `execute.v${epv}a${eea}.prompt.md`), readFileSync11(vExecPromptSrc, "utf8"), "utf8");
         }
-        if (existsSync13(vExecAuditSrc)) {
-          writeFileSync11(join16(workspacePath, `execute.v${epv}a${eea}.audit.json`), readFileSync10(vExecAuditSrc, "utf8"), "utf8");
+        if (existsSync14(vExecAuditSrc)) {
+          writeFileSync12(join17(workspacePath, `execute.v${epv}a${eea}.audit.json`), readFileSync11(vExecAuditSrc, "utf8"), "utf8");
         }
       } catch (vErr) {
         logger.warn({ err: String(vErr) }, "[Agent] Failed to write versioned execute artifacts");
@@ -6921,6 +7530,7 @@ async function handleExecutionStage(state, issue, workspacePath, promptText, pro
     container.eventStore.addEvent(issue.id, "runner", `Issue ${issue.identifier} queued for next turn.`);
   } else {
     issue.lastError = runResult.output;
+    issue.lastFailedPhase = "execute";
     issue.attempts += 1;
     if (issue.attempts >= issue.maxAttempts) {
       issue.commandExitCode = runResult.code;
@@ -6938,17 +7548,10 @@ async function runIssueOnce(state, issue, running) {
   const isResuming = issue.state === "Running";
   logger.info({ issueId: issue.id, identifier: issue.identifier, state: issue.state, isReviewing, isResuming, attempt: issue.attempts + 1, maxAttempts: issue.maxAttempts }, "[Agent] Starting issue execution");
   if (issue.state === "Planning") {
-    issue.startedAt = issue.startedAt ?? now();
-    runPlanningJob(state, issue).catch((err) => logger.error({ err, issueId: issue.id, identifier: issue.identifier }, "[Agent] Unexpected error in background planning job")).finally(() => {
-      state.metrics = computeMetrics(state.issues);
-      state.updatedAt = now();
-      persistState(state).catch(() => {
-      });
-    });
+    logger.warn({ issueId: issue.id }, "[Agent] runIssueOnce called for Planning state \u2014 skipping (queue handles planning)");
     return;
   }
   running.add(issue.id);
-  state.metrics.activeWorkers += 1;
   issue.startedAt = issue.startedAt ?? now();
   let workflowConfig = null;
   try {
@@ -6973,20 +7576,10 @@ async function runIssueOnce(state, issue, running) {
   }
   try {
     const workspaceDerivedPaths = hydrateIssuePathsFromWorkspace(issue);
-    if ((issue.paths ?? []).length > 0) {
-      issue.inferredPaths = [.../* @__PURE__ */ new Set([...issue.inferredPaths ?? [], ...inferCapabilityPaths({
-        id: issue.id,
-        identifier: issue.identifier,
-        title: issue.title,
-        description: issue.description,
-        labels: issue.labels,
-        paths: issue.paths
-      })])];
-    }
     const { workspacePath, promptText, promptFile } = await prepareWorkspace(issue, state, state.config.defaultBranch);
     container.issueRepository.markDirty(issue.id);
     try {
-      const { getIssueStateResource: getIssueStateResource2 } = await import("./store-WN47MDT5.js");
+      const { getIssueStateResource: getIssueStateResource2 } = await import("./store-AG6LLYJ7.js");
       const res = getIssueStateResource2();
       if (res) {
         await res.patch(issue.id, {
@@ -7008,6 +7601,7 @@ async function runIssueOnce(state, issue, running) {
   } catch (error) {
     issue.attempts += 1;
     issue.lastError = String(error);
+    issue.lastFailedPhase = issue.lastFailedPhase ?? "execute";
     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 transitionIssueCommand({ issue, target: "Cancelled", note: `Issue failed unexpectedly: ${issue.lastError}` }, container);
@@ -7020,18 +7614,25 @@ async function runIssueOnce(state, issue, running) {
     logger.info({ issueId: issue.id, identifier: issue.identifier, finalState: issue.state, elapsedMs, attempts: issue.attempts }, "[Agent] Issue execution finished");
     issue.updatedAt = now();
     container.issueRepository.markDirty(issue.id);
-    state.metrics.activeWorkers = Math.max(state.metrics.activeWorkers - 1, 0);
     running.delete(issue.id);
     state.metrics = computeMetrics(state.issues);
-    state.metrics.activeWorkers = Math.max(state.metrics.activeWorkers, 0);
     state.updatedAt = now();
     await container.persistencePort.persistState(state);
   }
 }
 
 export {
+  addTokenUsage,
+  extractTokenUsage,
+  tryParseJsonOutput,
+  readAgentDirective,
+  readAgentPid,
+  isProcessAlive,
   isAgentStillRunning,
   cleanStalePidFile,
+  loadAgentPipelineState,
+  loadAgentPipelineSnapshotForIssue,
+  loadAgentSessionSnapshotsForIssue,
   hydrate,
   recoverPlanningSession,
   loadRuntimeSettings,
@@ -7041,15 +7642,27 @@ export {
   createContainer,
   runPlanningJob,
   runIssueOnce,
+  isShuttingDown,
+  installGracefulShutdown,
+  analyzeParallelizability,
+  ensureNotStale,
+  hasTerminalQueue,
   deriveConfig,
   applyWorkflowConfig,
   validateConfig,
+  normalizeIssue,
+  nextLocalIssueId,
+  createIssueFromPayload,
+  dedupHistoryEntries,
   buildRuntimeState,
   addEvent,
-  isShuttingDown,
-  installGracefulShutdown,
-  ensureNotStale,
-  hasTerminalQueue,
+  transitionIssue,
+  issueDependenciesResolved,
+  getNextRetryAt,
+  handleStatePatch,
+  runAgentSession,
+  runAgentPipeline,
+  issueHasResumableSession,
   startApiServer,
   getStateDb,
   getIssueStateResource,
@@ -7078,4 +7691,4 @@ export {
   syncReferenceRepositories,
   importReferenceArtifacts
 };
-//# sourceMappingURL=chunk-2F3Q2MAG.js.map
+//# sourceMappingURL=chunk-HSGUPFTV.js.map