fifony 0.1.13 → 0.1.14-next.045d1e1

package/dist/{runtime → agent}/run-local.js

@@ -8,11 +8,11 @@ import {
   resolveTaskCapabilities
 } from "../chunk-JUSVR3DW.js";
 
-// src/runtime/run-local.ts
+// src/agent/run-local.ts
 import { mkdirSync as mkdirSync5 } from "fs";
 import { env as env10, exit as exit2, argv as argv3 } from "process";
 
-// src/runtime/constants.ts
+// src/agent/constants.ts
 import { existsSync } from "fs";
 import { basename, dirname, join, resolve } from "path";
 import { fileURLToPath } from "url";
@@ -86,8 +86,12 @@ var ALLOWED_STATES = [
 var TERMINAL_STATES = /* @__PURE__ */ new Set(["Done", "Cancelled"]);
 var EXECUTING_STATES = /* @__PURE__ */ new Set(["Running", "In Review"]);
 var PERSIST_EVENTS_MAX = 500;
+var FAST_BOOT = CLI_ARGS.includes("--fast-boot");
+var SKIP_SOURCE = FAST_BOOT || CLI_ARGS.includes("--skip-source");
+var SKIP_SCAN = FAST_BOOT || CLI_ARGS.includes("--skip-scan");
+var SKIP_RECOVERY = FAST_BOOT || CLI_ARGS.includes("--skip-recovery");
 
-// src/runtime/helpers.ts
+// src/agent/helpers.ts
 import { env as env2 } from "process";
 import { parse as parseYaml } from "yaml";
 function now() {
@@ -224,8 +228,55 @@ function extractJsonObjects(text) {
   }
   return results;
 }
+function repairTruncatedJson(text) {
+  const firstBrace = text.indexOf("{");
+  if (firstBrace < 0) return null;
+  let json = text.slice(firstBrace);
+  let inStr = false;
+  let esc = false;
+  const stack = [];
+  for (let i = 0; i < json.length; i++) {
+    const ch = json[i];
+    if (inStr) {
+      if (esc) {
+        esc = false;
+        continue;
+      }
+      if (ch === "\\") {
+        esc = true;
+        continue;
+      }
+      if (ch === '"') {
+        inStr = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inStr = true;
+      continue;
+    }
+    if (ch === "{") stack.push("{");
+    else if (ch === "[") stack.push("[");
+    else if (ch === "}") {
+      if (stack.length > 0 && stack[stack.length - 1] === "{") stack.pop();
+    } else if (ch === "]") {
+      if (stack.length > 0 && stack[stack.length - 1] === "[") stack.pop();
+    }
+  }
+  if (!inStr && stack.length === 0) return json;
+  if (inStr) {
+    if (json.endsWith("\\")) json = json.slice(0, -1);
+    json += '"';
+  }
+  json = json.replace(/[,:\s]+$/, "");
+  while (stack.length > 0) {
+    const open = stack.pop();
+    json += open === "{" ? "}" : "]";
+  }
+  return json;
+}
 
-// src/runtime/logger.ts
+// src/agent/logger.ts
 import pino from "pino";
 import { env as env3, stdout } from "process";
 import { join as join2 } from "path";
@@ -295,13 +346,13 @@ var logger = {
   }
 };
 
-// src/runtime/store.ts
-import { mkdirSync as mkdirSync3 } from "fs";
+// src/agent/store.ts
+import { mkdirSync as mkdirSync4 } from "fs";
 
-// src/runtime/issues.ts
+// src/agent/issues.ts
 import { env as env4 } from "process";
 
-// src/runtime/token-ledger.ts
+// src/agent/token-ledger.ts
 var EMPTY = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
 var overall = { ...EMPTY };
 var byPhase = /* @__PURE__ */ new Map();
@@ -463,7 +514,51 @@ function getAnalytics(topN = 20) {
   };
 }
 
-// src/runtime/issue-state-machine.ts
+// src/agent/dirty-tracker.ts
+var dirtyIssueIds = /* @__PURE__ */ new Set();
+var dirtyEventIds = /* @__PURE__ */ new Set();
+function markIssueDirty(id) {
+  dirtyIssueIds.add(id);
+}
+function markEventDirty(id) {
+  dirtyEventIds.add(id);
+}
+function hasDirtyState() {
+  return dirtyIssueIds.size > 0 || dirtyEventIds.size > 0;
+}
+function getDirtyIssueIds() {
+  return dirtyIssueIds;
+}
+function getDirtyEventIds() {
+  return dirtyEventIds;
+}
+function clearDirtyIssueIds() {
+  dirtyIssueIds.clear();
+}
+function clearDirtyEventIds() {
+  dirtyEventIds.clear();
+}
+function markAllIssuesDirty(ids) {
+  for (const id of ids) dirtyIssueIds.add(id);
+}
+function markAllEventsDirty(ids) {
+  for (const id of ids) dirtyEventIds.add(id);
+}
+
+// src/agent/metrics-cache.ts
+var cachedMetrics = null;
+var metricsStale = true;
+function invalidateMetrics() {
+  metricsStale = true;
+}
+function getMetrics(issues) {
+  if (!metricsStale && cachedMetrics) return cachedMetrics;
+  cachedMetrics = computeMetrics(issues);
+  metricsStale = false;
+  return cachedMetrics;
+}
+
+// src/agent/issue-state-machine.ts
 var ISSUE_STATE_MACHINE_ID = "issue-lifecycle";
 var ISSUE_STATE_MACHINE_DEFINITION = {
   initialState: "Planning",
@@ -592,13 +687,13 @@ function findIssueStateMachineTransitionPath(machineDefinition, from, to) {
   return null;
 }
 
-// src/runtime/providers.ts
+// src/agent/providers.ts
 import { execFileSync, spawn } from "child_process";
 import { existsSync as existsSync2, readFileSync } from "fs";
 import { join as join3 } from "path";
 import { homedir as homedir2 } from "os";
 
-// src/runtime/adapters/commands.ts
+// src/agent/adapters/commands.ts
 var CLAUDE_RESULT_SCHEMA = JSON.stringify({
   type: "object",
   properties: {
@@ -666,7 +761,7 @@ function extractPlanDirs(plan) {
   return [...dirs];
 }
 
-// src/runtime/providers.ts
+// src/agent/providers.ts
 function resolveAgentProfile(name) {
   const normalized = name.trim();
   if (!normalized) return { profilePath: "", instructions: "" };
@@ -720,7 +815,13 @@ function getProviderDefaultCommand(provider, _reasoningEffort, model) {
   if (provider === "claude") return buildClaudeCommand({ model, jsonSchema: CLAUDE_RESULT_SCHEMA });
   return "";
 }
+var cachedProviders = null;
+var providersCachedAt = 0;
+var PROVIDER_CACHE_TTL = 6e4;
 function detectAvailableProviders() {
+  if (cachedProviders && Date.now() - providersCachedAt < PROVIDER_CACHE_TTL) {
+    return cachedProviders;
+  }
   const providers = [];
   for (const name of ["claude", "codex"]) {
     try {
@@ -730,6 +831,8 @@ function detectAvailableProviders() {
       providers.push({ name, available: false, path: "" });
     }
   }
+  cachedProviders = providers;
+  providersCachedAt = Date.now();
   return providers;
 }
 var modelCache = /* @__PURE__ */ new Map();
@@ -1056,7 +1159,7 @@ function getEffectiveAgentProviders(state, issue, workflowDefinition, workflowCo
   return applyWorkflowConfigToProviders(merged, workflowConfig ?? null);
 }
 
-// src/runtime/issues.ts
+// src/agent/issues.ts
 var VALID_EFFORTS = /* @__PURE__ */ new Set(["low", "medium", "high", "extra-high"]);
 function parseEffortValue(value) {
   const str = typeof value === "string" ? value.trim().toLowerCase() : "";
@@ -1091,6 +1194,7 @@ function nextLocalIssueId(issues) {
 function createIssueFromPayload(payload, issues, workflowDefinition) {
   const identifier = toStringValue(payload.identifier, nextLocalIssueId(issues));
   const id = toStringValue(payload.id, identifier.replace(/^#/, "issue-"));
+  logger.info({ id, identifier, title: toStringValue(payload.title, "").slice(0, 80) }, "[Issues] Creating new issue");
   const createdAt = now();
   const blockedBy = toStringArray(payload.blockedBy);
   const legacyBlockedBy = toStringArray(payload.blocked_by);
@@ -1281,6 +1385,7 @@ function buildRuntimeState(previous, config, definition) {
   };
 }
 function computeMetrics(issues) {
+  let planning = 0;
   let queued = 0;
   let inProgress = 0;
   let blocked = 0;
@@ -1296,6 +1401,9 @@ function computeMetrics(issues) {
       }
     }
     switch (issue.state) {
+      case "Planning":
+        planning += 1;
+        break;
       case "Todo":
         queued += 1;
         break;
@@ -1319,6 +1427,7 @@ function computeMetrics(issues) {
   if (completionTimes.length === 0) {
     return {
       total: issues.length,
+      planning,
       queued,
       inProgress,
       blocked,
@@ -1333,6 +1442,7 @@ function computeMetrics(issues) {
   const medianCompletionMs = sortedCompletionTimes.length % 2 === 1 ? sortedCompletionTimes[mid] : Math.round((sortedCompletionTimes[mid - 1] + sortedCompletionTimes[mid]) / 2);
   return {
     total: issues.length,
+    planning,
     queued,
     inProgress,
     blocked,
@@ -1361,6 +1471,7 @@ function addEvent(state, issueId, kind, message) {
     at: now()
   };
   state.events = [event, ...state.events].slice(0, PERSIST_EVENTS_MAX);
+  markEventDirty(event.id);
   try {
     recordEvent();
   } catch {
@@ -1369,8 +1480,11 @@ function addEvent(state, issueId, kind, message) {
 }
 function transition(issue, target, note) {
   const previous = issue.state;
+  logger.debug({ issueId: issue.id, identifier: issue.identifier, from: previous, to: target, note }, "[State] Issue transition");
   issue.state = target;
   issue.updatedAt = now();
+  markIssueDirty(issue.id);
+  invalidateMetrics();
   issue.history.push(`[${issue.updatedAt}] ${note}`);
   if (previous === "Blocked" && target === "Todo") {
     issue.lastError = void 0;
@@ -1501,7 +1615,7 @@ async function handleStatePatch(state, issue, payload) {
   addEvent(state, issue.id, "manual", `Manual state transition to ${nextState}`);
 }
 
-// src/runtime/api-runtime-context.ts
+// src/agent/api-runtime-context.ts
 var context = null;
 function setApiRuntimeContext(state, workflowDefinition) {
   context = { state, workflowDefinition };
@@ -1516,18 +1630,20 @@ function getApiRuntimeContextOrThrow() {
   return context;
 }
 
-// src/runtime/api-server.ts
+// src/agent/api-server.ts
 import { execSync as execSync3 } from "child_process";
 import {
+  appendFileSync as appendFileSync2,
   closeSync,
-  existsSync as existsSync9,
+  existsSync as existsSync10,
   openSync,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync9,
   readSync,
-  statSync as statSync2
+  statSync as statSync3,
+  writeFileSync as writeFileSync8
 } from "fs";
 
-// src/runtime/resources/runtime-state.resource.ts
+// src/agent/resources/runtime-state.resource.ts
 var runtime_state_resource_default = {
   name: S3DB_RUNTIME_RESOURCE,
   attributes: {
@@ -1548,23 +1664,23 @@ var runtime_state_resource_default = {
   }
 };
 
-// src/runtime/agent.ts
+// src/agent/agent.ts
 import {
   appendFileSync,
   cpSync,
-  existsSync as existsSync4,
-  mkdirSync,
-  readdirSync as readdirSync2,
-  readFileSync as readFileSync3,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync4,
   rmSync,
-  statSync,
-  writeFileSync as writeFileSync2
+  statSync as statSync2,
+  writeFileSync as writeFileSync3
 } from "fs";
-import { join as join7, relative } from "path";
-import { env as env5 } from "process";
+import { join as join8, relative } from "path";
+import { env as env6 } from "process";
 import { execSync, spawn as spawn2 } from "child_process";
 
-// src/runtime/skills.ts
+// src/agent/skills.ts
 import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join4, resolve as resolve2 } from "path";
@@ -1608,11 +1724,143 @@ ${skill.content}`
 ${sections.join("\n\n")}`;
 }
 
-// src/runtime/adapters/index.ts
-import { writeFileSync } from "fs";
-import { join as join6 } from "path";
+// src/agent/workflow.ts
+import { existsSync as existsSync4, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync3, statSync, writeFileSync } from "fs";
+import { copyFile, mkdir, readdir, stat, writeFile } from "fs/promises";
+import { extname } from "path";
+import { argv as argv2, exit } from "process";
+var sourceReadyPromise = null;
+var skipSourceFlag = false;
+function setSkipSource(skip) {
+  skipSourceFlag = skip;
+}
+async function ensureSourceReady(onProgress) {
+  if (skipSourceFlag) {
+    onProgress?.("ready");
+    return;
+  }
+  if (existsSync4(SOURCE_MARKER)) {
+    onProgress?.("ready");
+    return;
+  }
+  if (sourceReadyPromise) return sourceReadyPromise;
+  sourceReadyPromise = (async () => {
+    onProgress?.("copying");
+    logger.info("Creating local source snapshot (async) for Fifony...");
+    const skipDirs = /* @__PURE__ */ new Set([
+      ".git",
+      ".fifony",
+      "node_modules",
+      ".venv",
+      "data",
+      "dist",
+      "build",
+      ".turbo",
+      ".next",
+      ".nuxt",
+      ".tanstack",
+      "coverage",
+      "artifacts",
+      "captures",
+      "tmp",
+      "temp"
+    ]);
+    const shouldSkip = (relativePath) => {
+      const parts = relativePath.split("/");
+      if (parts.some((segment) => skipDirs.has(segment))) return true;
+      const base = relativePath.split("/").at(-1) ?? "";
+      if (base.startsWith("map_scan_") && extname(base) === ".json") return true;
+      if (extname(base) === ".xlsx") return true;
+      return false;
+    };
+    const copyRecursiveAsync = async (source, target, rel = "") => {
+      await mkdir(target, { recursive: true });
+      const items = await readdir(source, { withFileTypes: true });
+      for (const item of items) {
+        const nextRel = rel ? `${rel}/${item.name}` : item.name;
+        if (shouldSkip(nextRel)) continue;
+        const sourcePath = `${source}/${item.name}`;
+        const targetPath = `${target}/${item.name}`;
+        const itemStat = await stat(sourcePath);
+        if (item.isDirectory()) {
+          await copyRecursiveAsync(sourcePath, targetPath, nextRel);
+          continue;
+        }
+        if (item.isSymbolicLink() || itemStat.isSymbolicLink()) continue;
+        if (itemStat.isFile() || itemStat.isFIFO()) {
+          try {
+            await copyFile(sourcePath, targetPath);
+          } catch (error) {
+            if (error.code === "ENOENT") {
+              logger.debug(`Skipped missing source file: ${sourcePath}`);
+            } else {
+              throw error;
+            }
+          }
+        }
+      }
+    };
+    await mkdir(SOURCE_ROOT, { recursive: true });
+    await copyRecursiveAsync(TARGET_ROOT, SOURCE_ROOT);
+    await writeFile(SOURCE_MARKER, `${now()}
+`, "utf8");
+    onProgress?.("ready");
+    logger.info("Source snapshot ready (async).");
+  })();
+  return sourceReadyPromise;
+}
+function loadWorkflowDefinition() {
+  const defaultPrompt = PROMPT_TEMPLATES["workflow-default"];
+  return {
+    workflowPath: "",
+    rendered: "",
+    config: {},
+    promptTemplate: defaultPrompt,
+    agentProvider: "codex",
+    agentProfile: "",
+    agentProfilePath: "",
+    agentProfileInstructions: "",
+    agentProviders: [],
+    afterCreateHook: "",
+    beforeRunHook: "",
+    afterRunHook: "",
+    beforeRemoveHook: ""
+  };
+}
+function parsePort(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") {
+      console.log(
+        `Usage: ${argv2[1]} [options]
+Options:
+  --port <n>             Start local dashboard (default: no UI and single batch run)
+  --workspace <path>     Target workspace root (default: current directory)
+  --persistence <path>   Persistence root (default: current directory)
+  --concurrency <n>      Maximum number of parallel issue runners
+  --attempts <n>         Maximum attempts per issue
+  --poll <ms>            Polling interval for the scheduler
+  --once                  Run one local batch and exit
+  --help                  Show this message`
+      );
+      exit(0);
+    }
+    if (arg === "--port") {
+      const value = args[i + 1];
+      if (!value || !/^\d+$/.test(value)) {
+        fail(`Invalid value for --port: ${value ?? "<empty>"}`);
+      }
+      return parseIntArg(value, 4040);
+    }
+  }
+  return void 0;
+}
+
+// src/agent/adapters/index.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+import { join as join7 } from "path";
 
-// src/runtime/adapters/shared.ts
+// src/agent/adapters/shared.ts
 function buildPlanContextSection(plan) {
   const parts = ["## Plan Context", "", `**Summary:** ${plan.summary}`];
   if (plan.assumptions?.length) {
@@ -1810,7 +2058,7 @@ function buildExecutionPayload(issue, provider, plan, workspacePath) {
   };
 }
 
-// src/runtime/adapters/plan-to-claude.ts
+// src/agent/adapters/plan-to-claude.ts
 async function compileForClaude(issue, provider, plan, config, workspacePath, skillContext) {
   const effort = resolveEffortForProvider(plan, provider.role, config.defaultEffort);
   const prompt = await renderPrompt("compile-execution-claude", {
@@ -1861,8 +2109,8 @@ async function compileForClaude(issue, provider, plan, config, workspacePath, sk
   };
 }
 
-// src/runtime/adapters/plan-to-codex.ts
-import { join as join5 } from "path";
+// src/agent/adapters/plan-to-codex.ts
+import { join as join6 } from "path";
 var CODEX_RESULT_CONTRACT = `
 Return a JSON object with this exact schema when finished:
 {
@@ -1899,7 +2147,7 @@ async function compileForCodex(issue, provider, plan, config, workspacePath, ski
     outputContract: CODEX_RESULT_CONTRACT
   });
   const relativeDirs = extractPlanDirs(plan);
-  const absoluteDirs = relativeDirs.map((d) => join5(workspacePath, d));
+  const absoluteDirs = relativeDirs.map((d) => join6(workspacePath, d));
   const command = buildCodexCommand({
     model: provider.model,
     addDirs: absoluteDirs
@@ -1931,7 +2179,7 @@ async function compileForCodex(issue, provider, plan, config, workspacePath, ski
   };
 }
 
-// src/runtime/adapters/index.ts
+// src/agent/adapters/index.ts
 async function compileExecution(issue, provider, config, workspacePath, skillContext) {
   const plan = issue.plan;
   if (!plan?.steps?.length) return null;
@@ -1987,8 +2235,8 @@ function buildExecutionAudit(provider, compiled, issue, durationMs, result) {
 }
 function persistCompilationArtifacts(workspacePath, compiled) {
   try {
-    writeFileSync(
-      join6(workspacePath, "fifony-compiled-execution.json"),
+    writeFileSync2(
+      join7(workspacePath, "fifony-compiled-execution.json"),
       JSON.stringify({
         adapter: compiled.meta.adapter,
         model: compiled.meta.model,
@@ -2010,8 +2258,8 @@ function persistCompilationArtifacts(workspacePath, compiled) {
   }
   if (compiled.payload) {
     try {
-      writeFileSync(
-        join6(workspacePath, "fifony-execution-payload.json"),
+      writeFileSync2(
+        join7(workspacePath, "fifony-execution-payload.json"),
         JSON.stringify(compiled.payload, null, 2),
         "utf8"
       );
@@ -2021,8 +2269,8 @@ function persistCompilationArtifacts(workspacePath, compiled) {
 }
 function persistExecutionAudit(workspacePath, audit) {
   try {
-    writeFileSync(
-      join6(workspacePath, "fifony-execution-audit.json"),
+    writeFileSync2(
+      join7(workspacePath, "fifony-execution-audit.json"),
       JSON.stringify(audit, null, 2),
       "utf8"
     );
@@ -2030,7 +2278,7 @@ function persistExecutionAudit(workspacePath, audit) {
   }
 }
 
-// src/runtime/settings.ts
+// src/agent/settings.ts
 var SETTING_ID_POLL_INTERVAL_MS = "runtime.pollIntervalMs";
 var SETTING_ID_WORKER_CONCURRENCY = "runtime.workerConcurrency";
 var SETTING_ID_COMMAND_TIMEOUT_MS = "runtime.commandTimeoutMs";
@@ -2311,7 +2559,7 @@ async function persistWorkflowConfig(config) {
   await persistSetting(SETTING_ID_WORKFLOW_CONFIG, config, { scope: "runtime", source: "user" });
 }
 
-// src/runtime/agent.ts
+// src/agent/agent.ts
 function normalizeAgentDirectiveStatus(value, fallback) {
   const normalized = typeof value === "string" ? value.trim().toLowerCase() : "";
   if (normalized === "done" || normalized === "continue" || normalized === "blocked" || normalized === "failed") {
@@ -2412,7 +2660,7 @@ function tryParseJsonOutput(output) {
 }
 function readAgentDirective(workspacePath, output, success) {
   const fallbackStatus = success ? "done" : "failed";
-  const resultFile = join7(workspacePath, "fifony-result.json");
+  const resultFile = join8(workspacePath, "fifony-result.json");
   let resultPayload = {};
   const fullJson = (() => {
     try {
@@ -2431,9 +2679,9 @@ function readAgentDirective(workspacePath, output, success) {
       tokenUsage
     };
   }
-  if (existsSync4(resultFile)) {
+  if (existsSync5(resultFile)) {
     try {
-      const parsed = JSON.parse(readFileSync3(resultFile, "utf8"));
+      const parsed = JSON.parse(readFileSync4(resultFile, "utf8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         resultPayload = parsed;
       }
@@ -2450,10 +2698,10 @@ function readAgentDirective(workspacePath, output, success) {
   return { status, summary, nextPrompt, tokenUsage };
 }
 function readAgentPid(workspacePath) {
-  const pidFile = join7(workspacePath, "fifony-agent.pid");
-  if (!existsSync4(pidFile)) return null;
+  const pidFile = join8(workspacePath, "fifony-agent.pid");
+  if (!existsSync5(pidFile)) return null;
   try {
-    const data = JSON.parse(readFileSync3(pidFile, "utf8"));
+    const data = JSON.parse(readFileSync4(pidFile, "utf8"));
     if (!data?.pid || typeof data.pid !== "number") return null;
     return data;
   } catch {
@@ -2470,7 +2718,7 @@ function isProcessAlive(pid) {
 }
 function isAgentStillRunning(issue) {
   const wp = issue.workspacePath;
-  if (!wp || !existsSync4(wp)) return { alive: false, pid: null };
+  if (!wp || !existsSync5(wp)) return { alive: false, pid: null };
   const pidInfo = readAgentPid(wp);
   if (!pidInfo) return { alive: false, pid: null };
   return { alive: isProcessAlive(pidInfo.pid), pid: pidInfo };
@@ -2480,7 +2728,7 @@ function cleanStalePidFile(workspacePath) {
   if (!pidInfo) return;
   if (!isProcessAlive(pidInfo.pid)) {
     try {
-      rmSync(join7(workspacePath, "fifony-agent.pid"), { force: true });
+      rmSync(join8(workspacePath, "fifony-agent.pid"), { force: true });
     } catch {
     }
   }
@@ -2490,13 +2738,22 @@ function canRunIssue(issue, running, state) {
   if (running.has(issue.id)) return false;
   if (TERMINAL_STATES.has(issue.state)) return false;
   const { alive } = isAgentStillRunning(issue);
-  if (alive) return false;
+  if (alive) {
+    logger.debug({ issueId: issue.id, identifier: issue.identifier }, "[Agent] Skipping issue \u2014 agent still alive from previous session");
+    return false;
+  }
   if (issue.state === "Blocked") {
     if (!issue.nextRetryAt) return false;
-    if (issue.attempts >= issue.maxAttempts) return false;
+    if (issue.attempts >= issue.maxAttempts) {
+      logger.debug({ issueId: issue.id, identifier: issue.identifier, attempts: issue.attempts, maxAttempts: issue.maxAttempts }, "[Agent] Skipping blocked issue \u2014 max attempts reached");
+      return false;
+    }
     if (Date.parse(issue.nextRetryAt) > Date.now()) return false;
   }
-  if (!issueDepsResolved(issue, state.issues)) return false;
+  if (!issueDepsResolved(issue, state.issues)) {
+    logger.debug({ issueId: issue.id, identifier: issue.identifier, blockedBy: issue.blockedBy }, "[Agent] Skipping issue \u2014 unresolved dependencies");
+    return false;
+  }
   if (issue.state === "Todo") return true;
   if (issue.state === "Queued") return true;
   if (issue.state === "Blocked") return true;
@@ -2522,33 +2779,33 @@ function shouldSkipRoutingPath(relativePath) {
   return base === "WORKFLOW.local.md" || base === ".fifony-env.sh" || base.startsWith("fifony-") || base.startsWith("fifony_");
 }
 function inferChangedWorkspacePaths(workspacePath, limit = 32) {
-  if (!workspacePath || !existsSync4(workspacePath) || !existsSync4(SOURCE_ROOT)) return [];
+  if (!workspacePath || !existsSync5(workspacePath) || !existsSync5(SOURCE_ROOT)) return [];
   const changed = /* @__PURE__ */ new Set();
   const walk = (currentRoot, relativeRoot = "") => {
     if (changed.size >= limit) return;
-    for (const item of readdirSync2(currentRoot, { withFileTypes: true })) {
+    for (const item of readdirSync3(currentRoot, { withFileTypes: true })) {
       if (changed.size >= limit) return;
       const nextRelative = relativeRoot ? `${relativeRoot}/${item.name}` : item.name;
       if (shouldSkipRoutingPath(nextRelative)) continue;
-      const currentPath = join7(currentRoot, item.name);
+      const currentPath = join8(currentRoot, item.name);
       if (item.isDirectory()) {
         walk(currentPath, nextRelative);
         continue;
       }
       if (!item.isFile()) continue;
-      const sourcePath = join7(SOURCE_ROOT, nextRelative);
-      if (!existsSync4(sourcePath)) {
+      const sourcePath = join8(SOURCE_ROOT, nextRelative);
+      if (!existsSync5(sourcePath)) {
         changed.add(nextRelative);
         continue;
       }
-      const currentStat = statSync(currentPath);
-      const sourceStat = statSync(sourcePath);
+      const currentStat = statSync2(currentPath);
+      const sourceStat = statSync2(sourcePath);
       if (currentStat.size !== sourceStat.size) {
         changed.add(nextRelative);
         continue;
       }
-      const currentFile = readFileSync3(currentPath);
-      const sourceFile = readFileSync3(sourcePath);
+      const currentFile = readFileSync4(currentPath);
+      const sourceFile = readFileSync4(sourcePath);
       if (!currentFile.equals(sourceFile)) changed.add(nextRelative);
     }
   };
@@ -2557,7 +2814,7 @@ function inferChangedWorkspacePaths(workspacePath, limit = 32) {
 }
 function computeDiffStats(issue) {
   const wp = issue.workspacePath;
-  if (!wp || !existsSync4(wp) || !existsSync4(SOURCE_ROOT)) return;
+  if (!wp || !existsSync5(wp) || !existsSync5(SOURCE_ROOT)) return;
   try {
     let raw = "";
     try {
@@ -2586,23 +2843,23 @@ function computeDiffStats(issue) {
   }
 }
 function isConflict(relativePath) {
-  const targetPath = join7(TARGET_ROOT, relativePath);
-  const sourcePath = join7(SOURCE_ROOT, relativePath);
-  if (!existsSync4(sourcePath)) return existsSync4(targetPath);
-  if (!existsSync4(targetPath)) return false;
-  const targetStat = statSync(targetPath);
-  const sourceStat = statSync(sourcePath);
+  const targetPath = join8(TARGET_ROOT, relativePath);
+  const sourcePath = join8(SOURCE_ROOT, relativePath);
+  if (!existsSync5(sourcePath)) return existsSync5(targetPath);
+  if (!existsSync5(targetPath)) return false;
+  const targetStat = statSync2(targetPath);
+  const sourceStat = statSync2(sourcePath);
   if (targetStat.size !== sourceStat.size) return true;
-  return !readFileSync3(targetPath).equals(readFileSync3(sourcePath));
+  return !readFileSync4(targetPath).equals(readFileSync4(sourcePath));
 }
 function mergeWorkspace(workspacePath) {
   const result = { copied: [], deleted: [], skipped: [], conflicts: [] };
-  if (!workspacePath || !existsSync4(workspacePath)) {
+  if (!workspacePath || !existsSync5(workspacePath)) {
     throw new Error(`Workspace not found: ${workspacePath}`);
   }
   const walkWorkspace = (dir) => {
-    for (const item of readdirSync2(dir, { withFileTypes: true })) {
-      const fullPath = join7(dir, item.name);
+    for (const item of readdirSync3(dir, { withFileTypes: true })) {
+      const fullPath = join8(dir, item.name);
       const relativePath = relative(workspacePath, fullPath);
       if (shouldSkipMergePath(relativePath)) {
         result.skipped.push(relativePath);
@@ -2613,17 +2870,17 @@ function mergeWorkspace(workspacePath) {
         continue;
       }
       if (!item.isFile()) continue;
-      const sourcePath = join7(SOURCE_ROOT, relativePath);
-      const isNew = !existsSync4(sourcePath);
+      const sourcePath = join8(SOURCE_ROOT, relativePath);
+      const isNew = !existsSync5(sourcePath);
       let isModified = false;
       if (!isNew) {
-        const wsStat = statSync(fullPath);
-        const srcStat = statSync(sourcePath);
+        const wsStat = statSync2(fullPath);
+        const srcStat = statSync2(sourcePath);
         if (wsStat.size !== srcStat.size) {
           isModified = true;
         } else {
-          const wsContent = readFileSync3(fullPath);
-          const srcContent = readFileSync3(sourcePath);
+          const wsContent = readFileSync4(fullPath);
+          const srcContent = readFileSync4(sourcePath);
           isModified = !wsContent.equals(srcContent);
         }
       }
@@ -2632,18 +2889,18 @@ function mergeWorkspace(workspacePath) {
           result.conflicts.push(relativePath);
           continue;
         }
-        const targetDir = join7(TARGET_ROOT, relative(workspacePath, dir));
-        const targetPath = join7(TARGET_ROOT, relativePath);
-        mkdirSync(targetDir, { recursive: true });
+        const targetDir = join8(TARGET_ROOT, relative(workspacePath, dir));
+        const targetPath = join8(TARGET_ROOT, relativePath);
+        mkdirSync2(targetDir, { recursive: true });
         cpSync(fullPath, targetPath, { force: true });
         result.copied.push(relativePath);
       }
     }
   };
   const walkSource = (dir) => {
-    if (!existsSync4(dir)) return;
-    for (const item of readdirSync2(dir, { withFileTypes: true })) {
-      const fullPath = join7(dir, item.name);
+    if (!existsSync5(dir)) return;
+    for (const item of readdirSync3(dir, { withFileTypes: true })) {
+      const fullPath = join8(dir, item.name);
       const relativePath = relative(SOURCE_ROOT, fullPath);
       if (shouldSkipMergePath(relativePath)) continue;
       if (item.isDirectory()) {
@@ -2651,10 +2908,10 @@ function mergeWorkspace(workspacePath) {
         continue;
       }
       if (!item.isFile()) continue;
-      const wsPath = join7(workspacePath, relativePath);
-      if (!existsSync4(wsPath)) {
-        const targetPath = join7(TARGET_ROOT, relativePath);
-        if (existsSync4(targetPath)) {
+      const wsPath = join8(workspacePath, relativePath);
+      if (!existsSync5(wsPath)) {
+        const targetPath = join8(TARGET_ROOT, relativePath);
+        if (existsSync5(targetPath)) {
           if (isConflict(relativePath)) {
             result.conflicts.push(relativePath);
           } else {
@@ -2976,16 +3233,16 @@ async function runCommandWithTimeout(command, workspacePath, issue, config, prom
     };
     for (const [key, value] of Object.entries(extraEnv)) {
       if (value.length > 4e3) {
-        const valFile = join7(workspacePath, `${key.toLowerCase()}.txt`);
-        writeFileSync2(valFile, value, "utf8");
+        const valFile = join8(workspacePath, `${key.toLowerCase()}.txt`);
+        writeFileSync3(valFile, value, "utf8");
         allVars[`${key}_FILE`] = valFile;
       } else {
         allVars[key] = value;
       }
     }
-    const envFilePath = join7(workspacePath, ".fifony-env.sh");
+    const envFilePath = join8(workspacePath, ".fifony-env.sh");
     const envFileLines = Object.entries(allVars).map(([k, v]) => `export ${k}=${JSON.stringify(v)}`).join("\n");
-    writeFileSync2(envFilePath, envFileLines, "utf8");
+    writeFileSync3(envFilePath, envFileLines, "utf8");
     const wrappedCommand = `. "${envFilePath}" && ${command}`;
     const child = spawn2(wrappedCommand, {
       shell: true,
@@ -2998,10 +3255,11 @@ async function runCommandWithTimeout(command, workspacePath, issue, config, prom
     if (child.stdin) {
       child.stdin.end();
     }
-    const pidFile = join7(workspacePath, "fifony-agent.pid");
+    const pidFile = join8(workspacePath, "fifony-agent.pid");
     const pid = child.pid;
     if (pid) {
-      writeFileSync2(pidFile, JSON.stringify({
+      logger.debug({ issueId: issue.id, pid, command: command.slice(0, 120), cwd: workspacePath }, "[Agent] Process spawned");
+      writeFileSync3(pidFile, JSON.stringify({
         pid,
         issueId: issue.id,
         startedAt: new Date(started).toISOString(),
@@ -3011,8 +3269,8 @@ async function runCommandWithTimeout(command, workspacePath, issue, config, prom
     let output = "";
     let timedOut = false;
     let outputBytes = 0;
-    const liveLogFile = join7(workspacePath, "fifony-live-output.log");
-    writeFileSync2(liveLogFile, "", "utf8");
+    const liveLogFile = join8(workspacePath, "fifony-live-output.log");
+    writeFileSync3(liveLogFile, "", "utf8");
     const onChunk = (chunk) => {
       const text = String(chunk);
       output = appendFileTail(output, text, config.logLinesTail);
@@ -3077,7 +3335,7 @@ async function runHook(command, workspacePath, issue, hookName, extraEnv = {}) {
     retryDelayMs: 0,
     staleInProgressTimeoutMs: 0,
     logLinesTail: 12e3,
-    agentProvider: normalizeAgentProvider(env5.FIFONY_AGENT_PROVIDER ?? "codex"),
+    agentProvider: normalizeAgentProvider(env6.FIFONY_AGENT_PROVIDER ?? "codex"),
     agentCommand: command,
     maxTurns: 1,
     runMode: "filesystem"
@@ -3088,8 +3346,8 @@ async function runHook(command, workspacePath, issue, hookName, extraEnv = {}) {
 }
 async function cleanWorkspace(issueId, workflowDefinition) {
   const safeId = idToSafePath(issueId);
-  const workspacePath = join7(WORKSPACE_ROOT, safeId);
-  if (!existsSync4(workspacePath)) return;
+  const workspacePath = join8(WORKSPACE_ROOT, safeId);
+  if (!existsSync5(workspacePath)) return;
   if (workflowDefinition?.beforeRemoveHook) {
     try {
       const dummyIssue = { id: issueId, identifier: issueId };
@@ -3107,25 +3365,30 @@ async function cleanWorkspace(issueId, workflowDefinition) {
 }
 async function prepareWorkspace(issue, workflowDefinition) {
   const safeId = idToSafePath(issue.id);
-  const workspaceRoot = join7(WORKSPACE_ROOT, safeId);
-  const createdNow = !existsSync4(workspaceRoot);
+  const workspaceRoot = join8(WORKSPACE_ROOT, safeId);
+  const createdNow = !existsSync5(workspaceRoot);
   if (createdNow) {
-    mkdirSync(workspaceRoot, { recursive: true });
+    logger.debug({ issueId: issue.id, identifier: issue.identifier, workspacePath: workspaceRoot }, "[Agent] Creating new workspace");
+    mkdirSync2(workspaceRoot, { recursive: true });
     if (workflowDefinition?.afterCreateHook) {
       await runHook(workflowDefinition.afterCreateHook, workspaceRoot, issue, "after_create");
     } else {
+      await ensureSourceReady();
       cpSync(SOURCE_ROOT, workspaceRoot, {
         recursive: true,
         force: true,
         filter: (sourcePath) => !sourcePath.startsWith(WORKSPACE_ROOT)
       });
     }
+    logger.debug({ issueId: issue.id, workspacePath: workspaceRoot }, "[Agent] Workspace created");
+  } else {
+    logger.debug({ issueId: issue.id, workspacePath: workspaceRoot }, "[Agent] Reusing existing workspace");
   }
-  const metaPath = join7(workspaceRoot, "fifony-issue.json");
+  const metaPath = join8(workspaceRoot, "fifony-issue.json");
   const promptText = await buildPrompt(issue, workflowDefinition);
-  const promptFile = join7(workspaceRoot, "fifony-prompt.md");
-  writeFileSync2(metaPath, JSON.stringify({ ...issue, runtimeSource: SOURCE_ROOT, bootstrapAt: now() }, null, 2), "utf8");
-  writeFileSync2(promptFile, `${promptText}
+  const promptFile = join8(workspaceRoot, "fifony-prompt.md");
+  writeFileSync3(metaPath, JSON.stringify({ ...issue, runtimeSource: SOURCE_ROOT, bootstrapAt: now() }, null, 2), "utf8");
+  writeFileSync3(promptFile, `${promptText}
 `, "utf8");
   issue.workspacePath = workspaceRoot;
   issue.workspacePreparedAt = now();
@@ -3142,8 +3405,9 @@ async function runAgentSession(state, issue, provider, cycle, workspacePath, bas
   let nextPrompt = session.nextPrompt;
   let lastCode = session.lastCode;
   let lastOutput = session.lastOutput;
-  const resultFile = join7(workspacePath, `fifony-result-${provider.role}-${provider.provider}.json`);
+  const resultFile = join8(workspacePath, `fifony-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 };
   }
   const turnIndex = session.turns.length + 1;
@@ -3155,14 +3419,15 @@ Agent requested additional turns beyond configured limit (${maxTurns}).`, state.
     return { success: false, blocked: true, continueRequested: false, code: lastCode, output: session.lastOutput, turns: session.turns.length };
   }
   const turnPrompt = await buildTurnPrompt(issue, basePromptText, previousOutput, turnIndex, maxTurns, nextPrompt);
-  const turnPromptFile = turnIndex === 1 ? basePromptFile : join7(workspacePath, `fifony-turn-${String(turnIndex).padStart(2, "0")}.md`);
-  if (turnIndex > 1) writeFileSync2(turnPromptFile, `${turnPrompt}
+  const turnPromptFile = turnIndex === 1 ? basePromptFile : join8(workspacePath, `fifony-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);
+  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 = {
     FIFONY_AGENT_PROVIDER: provider.provider,
@@ -3195,6 +3460,7 @@ Agent requested additional turns beyond configured limit (${maxTurns}).`, state.
       FIFONY_PRESERVE_RESULT_FILE: "1"
     });
   }
+  logger.info({ issueId: issue.id, identifier: issue.identifier, turn: turnIndex, exitCode: turnResult.code, success: turnResult.success, outputBytes: turnResult.output.length }, "[Agent] Agent command finished");
   const directive = readAgentDirective(workspacePath, turnResult.output, turnResult.success);
   lastCode = turnResult.code;
   lastOutput = turnResult.output;
@@ -3240,20 +3506,24 @@ Agent requested additional turns beyond configured limit (${maxTurns}).`, state.
   const directiveSummary = directive.summary ? ` ${directive.summary}` : "";
   addEvent(state, issue.id, "runner", `Turn ${turnIndex}/${maxTurns} finished with status ${directive.status}.${directiveSummary}`.trim());
   if (!turnResult.success || directive.status === "failed") {
+    logger.info({ issueId: issue.id, identifier: issue.identifier, turn: turnIndex, directiveStatus: directive.status, exitCode: lastCode }, "[Agent] Session turn failed");
     session.status = "failed";
     await persistAgentSessionState(sessionKey, issue, provider, cycle, session);
     return { success: false, blocked: false, continueRequested: false, code: lastCode, output: lastOutput, turns: turnIndex };
   }
   if (directive.status === "blocked") {
+    logger.info({ issueId: issue.id, identifier: issue.identifier, turn: turnIndex }, "[Agent] Session turn blocked \u2014 manual intervention requested");
     session.status = "blocked";
     await persistAgentSessionState(sessionKey, issue, provider, cycle, session);
     return { success: false, blocked: true, continueRequested: false, code: lastCode, output: lastOutput, turns: turnIndex };
   }
   if (directive.status === "continue") {
+    logger.info({ issueId: issue.id, identifier: issue.identifier, turn: turnIndex, maxTurns }, "[Agent] Session requests continuation");
     session.status = "running";
     await persistAgentSessionState(sessionKey, issue, provider, cycle, session);
     return { success: false, blocked: false, continueRequested: true, code: lastCode, output: lastOutput, turns: turnIndex };
   }
+  logger.info({ issueId: issue.id, identifier: issue.identifier, turn: turnIndex }, "[Agent] Session completed successfully");
   session.status = "done";
   await persistAgentSessionState(sessionKey, issue, provider, cycle, session);
   return { success: true, blocked: false, continueRequested: false, code: lastCode, output: lastOutput, turns: turnIndex };
@@ -3261,13 +3531,14 @@ Agent requested additional turns beyond configured limit (${maxTurns}).`, state.
 async function runAgentPipeline(state, issue, workspacePath, basePromptText, basePromptFile, workflowDefinition, workflowConfig) {
   const providers = getEffectiveAgentProviders(state, issue, workflowDefinition, workflowConfig);
   const attempt = issue.attempts + 1;
+  logger.debug({ issueId: issue.id, identifier: issue.identifier, attempt, providers: providers.map((p) => `${p.role}:${p.provider}`) }, "[Agent] Starting pipeline");
   const { pipeline, key: pipelineFile } = await loadAgentPipelineState(issue, attempt, providers);
   const activeProvider = providers[clamp(pipeline.activeIndex, 0, Math.max(0, providers.length - 1))];
   const executorIndex = providers.findIndex((provider) => provider.role === "executor");
   const skills = discoverSkills(workspacePath);
   const skillContext = buildSkillContext(skills);
   if (skillContext) {
-    writeFileSync2(join7(workspacePath, "fifony-skills.md"), skillContext, "utf8");
+    writeFileSync3(join8(workspacePath, "fifony-skills.md"), skillContext, "utf8");
   }
   const compiled = await compileExecution(issue, activeProvider, state.config, workspacePath, skillContext);
   let providerPrompt;
@@ -3283,9 +3554,9 @@ 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 = join7(workspacePath, ".fifony-compiled-env.sh");
+      const envFile = join8(workspacePath, ".fifony-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);
@@ -3333,6 +3604,7 @@ async function runIssueOnce(state, issue, running, workflowDefinition) {
   const startTs = Date.now();
   const isReview = issue.state === "In Review";
   const isResuming = issue.state === "Running" || issue.state === "Interrupted";
+  logger.info({ issueId: issue.id, identifier: issue.identifier, state: issue.state, isReview, isResuming, attempt: issue.attempts + 1, maxAttempts: issue.maxAttempts }, "[Agent] Starting issue execution");
   running.add(issue.id);
   state.metrics.activeWorkers += 1;
   issue.startedAt = issue.startedAt ?? now();
@@ -3393,8 +3665,8 @@ async function runIssueOnce(state, issue, running, workflowDefinition) {
       }
       const compiled = await compileReview(issue, reviewer, workspacePath, diffSummary);
       const effectiveReviewer = { ...reviewer, command: compiled.command || reviewer.command };
-      const reviewPromptFile = join7(workspacePath, "fifony-review-prompt.md");
-      writeFileSync2(reviewPromptFile, `${compiled.prompt}
+      const reviewPromptFile = join8(workspacePath, "fifony-review-prompt.md");
+      writeFileSync3(reviewPromptFile, `${compiled.prompt}
 `, "utf8");
       state._workflowDefinition = workflowDefinition;
       const reviewResult = await runAgentSession(state, issue, effectiveReviewer, 1, workspacePath, compiled.prompt, reviewPromptFile);
@@ -3510,7 +3782,10 @@ async function runIssueOnce(state, issue, running, workflowDefinition) {
       addEvent(state, issue.id, "error", `Issue ${issue.identifier} blocked after unexpected failure.`);
     }
   } finally {
+    const elapsedMs = Date.now() - startTs;
+    logger.info({ issueId: issue.id, identifier: issue.identifier, finalState: issue.state, elapsedMs, attempts: issue.attempts }, "[Agent] Issue execution finished");
     issue.updatedAt = now();
+    markIssueDirty(issue.id);
     state.metrics.activeWorkers = Math.max(state.metrics.activeWorkers - 1, 0);
     running.delete(issue.id);
     state.metrics = computeMetrics(state.issues);
@@ -3520,7 +3795,7 @@ async function runIssueOnce(state, issue, running, workflowDefinition) {
   }
 }
 
-// src/runtime/resources/issues.resource.ts
+// src/agent/resources/issues.resource.ts
 function getIssueId(c) {
   if (!c || typeof c !== "object" || !("req" in c) || !c.req || typeof c.req !== "object") {
     return null;
@@ -3746,7 +4021,7 @@ var issues_resource_default = {
   }
 };
 
-// src/runtime/resources/events.resource.ts
+// src/agent/resources/events.resource.ts
 var events_resource_default = {
   name: S3DB_EVENT_RESOURCE,
   attributes: {
@@ -3772,7 +4047,7 @@ var events_resource_default = {
   }
 };
 
-// src/runtime/resources/settings.resource.ts
+// src/agent/resources/settings.resource.ts
 var settings_resource_default = {
   name: S3DB_SETTINGS_RESOURCE,
   attributes: {
@@ -3794,7 +4069,7 @@ var settings_resource_default = {
   }
 };
 
-// src/runtime/resources/agent-sessions.resource.ts
+// src/agent/resources/agent-sessions.resource.ts
 var agent_sessions_resource_default = {
   name: S3DB_AGENT_SESSION_RESOURCE,
   attributes: {
@@ -3824,7 +4099,7 @@ var agent_sessions_resource_default = {
   }
 };
 
-// src/runtime/resources/agent-pipelines.resource.ts
+// src/agent/resources/agent-pipelines.resource.ts
 var agent_pipelines_resource_default = {
   name: S3DB_AGENT_PIPELINE_RESOURCE,
   attributes: {
@@ -3850,7 +4125,7 @@ var agent_pipelines_resource_default = {
   }
 };
 
-// src/runtime/resources/index.ts
+// src/agent/resources/index.ts
 var NATIVE_RESOURCE_CONFIGS = [
   runtime_state_resource_default,
   issues_resource_default,
@@ -3861,45 +4136,45 @@ var NATIVE_RESOURCE_CONFIGS = [
 ];
 var NATIVE_RESOURCE_NAMES = NATIVE_RESOURCE_CONFIGS.map((resource) => resource.name);
 
-// src/runtime/providers-usage.ts
+// src/agent/providers-usage.ts
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync as readdirSync3 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync4 } from "fs";
+import { join as join9 } from "path";
 import { homedir as homedir4 } from "os";
-import { env as env6 } from "process";
+import { env as env7 } from "process";
 function resolveCodexHomeCandidates() {
   const homePaths = /* @__PURE__ */ new Set([
     homedir4(),
-    env6.XDG_STATE_HOME?.trim() || "",
-    env6.XDG_DATA_HOME?.trim() || ""
+    env7.XDG_STATE_HOME?.trim() || "",
+    env7.XDG_DATA_HOME?.trim() || ""
   ]);
-  const sudoUser = env6.SUDO_USER?.trim();
+  const sudoUser = env7.SUDO_USER?.trim();
   if (sudoUser && sudoUser !== "root") {
     homePaths.add(`/home/${sudoUser}`);
   }
   const direct = /* @__PURE__ */ new Set([
-    env6.CODEX_HOME?.trim() || ""
+    env7.CODEX_HOME?.trim() || ""
   ]);
   const candidates = [...homePaths, ...direct].filter(Boolean).flatMap((candidate) => {
     if (candidate.endsWith("/.codex") || candidate.endsWith("/codex")) return [candidate];
-    return [join8(candidate, ".codex"), join8(candidate, "codex")];
+    return [join9(candidate, ".codex"), join9(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 = join8(codexDir, "state_5.sqlite");
-  if (existsSync5(explicit)) return explicit;
-  const candidates = readdirSync3(codexDir).filter((name) => name.startsWith("state_") && name.endsWith(".sqlite")).sort().reverse();
+  const explicit = join9(codexDir, "state_5.sqlite");
+  if (existsSync6(explicit)) return explicit;
+  const candidates = readdirSync4(codexDir).filter((name) => name.startsWith("state_") && name.endsWith(".sqlite")).sort().reverse();
   if (candidates.length === 0) return null;
-  return join8(codexDir, candidates[0]);
+  return join9(codexDir, candidates[0]);
 }
 function computeNextMonday() {
   const now2 = /* @__PURE__ */ new Date();
@@ -3936,15 +4211,15 @@ var CLAUDE_PLAN_LIMITS = {
 };
 function collectClaudeUsage() {
   const home = homedir4();
-  const claudeDir = join8(home, ".claude");
-  if (!existsSync5(claudeDir)) return null;
+  const claudeDir = join9(home, ".claude");
+  if (!existsSync6(claudeDir)) return null;
   let available = false;
   try {
     execSync2("which claude", { encoding: "utf8", timeout: 3e3 });
     available = true;
   } catch {
   }
-  const projectsDir = join8(claudeDir, "projects");
+  const projectsDir = join9(claudeDir, "projects");
   let totalInputTokens = 0;
   let totalOutputTokens = 0;
   let totalSessions = 0;
@@ -3958,23 +4233,23 @@ function collectClaudeUsage() {
   const todayMs = todayStart.getTime();
   const weekStart = computeWeekStart();
   const weekMs = weekStart.getTime();
-  if (existsSync5(projectsDir)) {
+  if (existsSync6(projectsDir)) {
     try {
-      const projectDirs = readdirSync3(projectsDir, { withFileTypes: true });
+      const projectDirs = readdirSync4(projectsDir, { withFileTypes: true });
       for (const dir of projectDirs) {
         if (!dir.isDirectory()) continue;
-        const projectPath = join8(projectsDir, dir.name);
+        const projectPath = join9(projectsDir, dir.name);
         let sessionFiles;
         try {
-          sessionFiles = readdirSync3(projectPath).filter((f) => f.endsWith(".jsonl"));
+          sessionFiles = readdirSync4(projectPath).filter((f) => f.endsWith(".jsonl"));
         } catch {
           continue;
         }
         for (const file of sessionFiles) {
-          const filePath = join8(projectPath, file);
+          const filePath = join9(projectPath, file);
           let content;
           try {
-            content = readFileSync4(filePath, "utf8");
+            content = readFileSync5(filePath, "utf8");
           } catch {
             continue;
           }
@@ -4028,10 +4303,10 @@ function collectClaudeUsage() {
   ];
   let plan = "pro";
   let resetInfo = "Weekly reset (every Monday 00:00 UTC)";
-  const settingsPath = join8(claudeDir, "settings.json");
-  if (existsSync5(settingsPath)) {
+  const settingsPath = join9(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`;
@@ -4069,11 +4344,11 @@ function collectCodexUsage() {
   } catch {
   }
   const models = [];
-  const modelsCachePath = join8(codexDir, "models_cache.json");
+  const modelsCachePath = join9(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,
@@ -4084,10 +4359,10 @@ function collectCodexUsage() {
     } catch {
     }
   }
-  const configPath = join8(codexDir, "config.toml");
-  if (existsSync5(configPath)) {
+  const configPath = join9(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 {
@@ -4177,8 +4452,16 @@ function collectProvidersUsage() {
   };
 }
 
-// src/runtime/scheduler.ts
+// src/agent/scheduler.ts
 var shuttingDown = false;
+var lastPersistAt = 0;
+var PERSIST_DEBOUNCE_MS = 5e3;
+var schedulerWakeResolve = null;
+function wakeScheduler() {
+  schedulerWakeResolve?.();
+}
+var IDLE_POLL_MS = 5e3;
+var ACTIVE_POLL_MS = 500;
 function installGracefulShutdown(state, running) {
   const handler = async (signal) => {
     if (shuttingDown) {
@@ -4190,9 +4473,11 @@ function installGracefulShutdown(state, running) {
     addEvent(state, void 0, "info", `Graceful shutdown initiated (${signal}).`);
     for (const issue of state.issues) {
       if (running.has(issue.id) && (issue.state === "Running" || issue.state === "In Review")) {
-        issue.state = "Interrupted";
-        issue.updatedAt = now();
-        issue.history.push(`[${issue.updatedAt}] Interrupted by ${signal} \u2014 will resume on next start.`);
+        try {
+          await transitionIssueState(issue, "Interrupted", `Interrupted by ${signal} \u2014 will resume on next start.`, { fallbackToLocal: true });
+        } catch {
+          logger.warn(`Could not transition issue ${issue.identifier} to Interrupted during shutdown.`);
+        }
         addEvent(state, issue.id, "info", `Issue ${issue.identifier} interrupted by shutdown.`);
       }
     }
@@ -4272,10 +4557,14 @@ async function ensureNotStale(state, staleTimeoutMs) {
   const limit = Date.now() - staleTimeoutMs;
   for (const issue of state.issues) {
     if (EXECUTING_STATES.has(issue.state) && Date.parse(issue.updatedAt) < limit && !TERMINAL_STATES.has(issue.state) && !issueHasResumableSession(issue)) {
+      const staleMinutes = Math.round((Date.now() - Date.parse(issue.updatedAt)) / 6e4);
+      logger.info({ issueId: issue.id, identifier: issue.identifier, state: issue.state, updatedAt: issue.updatedAt }, "[Scheduler] Recovering stale issue");
       issue.attempts += 1;
       issue.nextRetryAt = getNextRetryAt(issue, state.config.retryDelayMs);
       issue.startedAt = void 0;
+      markIssueDirty(issue.id);
       await transitionIssueState(issue, "Blocked", `Issue state auto-recovered from stale execution.`);
+      addEvent(state, issue.id, "info", `Issue ${issue.identifier} was stale for over ${staleMinutes} minute(s) in ${issue.state} state, moved to Blocked for retry.`);
     }
   }
 }
@@ -4289,7 +4578,11 @@ function isPerStateFull(issue, state, running) {
   return count >= limit;
 }
 function pickNextIssues(state, running, workflowDefinition) {
-  return state.issues.filter((issue) => canRunIssue(issue, running, state) && !isPerStateFull(issue, state, running)).sort((a, b) => {
+  const candidates = state.issues.filter((issue) => canRunIssue(issue, running, state) && !isPerStateFull(issue, state, running));
+  if (candidates.length > 0) {
+    logger.debug({ candidates: candidates.map((i) => ({ id: i.identifier, state: i.state, priority: i.priority })) }, "[Scheduler] Eligible candidates for dispatch");
+  }
+  return candidates.sort((a, b) => {
     const stateWeight = (c) => c.state === "Running" ? 0 : c.state === "Blocked" ? 2 : 1;
     const weightDiff = stateWeight(a) - stateWeight(b);
     if (weightDiff !== 0) return weightDiff;
@@ -4341,15 +4634,29 @@ async function scheduler(state, running, runForever, workflowDefinition) {
       } else {
         const ready = pickNextIssues(state, running, workflowDefinition);
         const slots = state.config.workerConcurrency - running.size;
-        if (slots > 0) {
+        if (slots > 0 && ready.length > 0) {
           const next = ready.slice(0, Math.max(0, slots));
+          logger.debug({ slots, readyCount: ready.length, dispatching: next.map((i) => i.identifier) }, "[Scheduler] Dispatching issues");
           await Promise.all(next.map((issue) => runIssueOnce(state, issue, running, workflowDefinition)));
+        } else if (ready.length > 0 && slots <= 0) {
+          logger.debug({ runningCount: running.size, readyCount: ready.length, concurrency: state.config.workerConcurrency }, "[Scheduler] No slots available, waiting");
         }
       }
       state.updatedAt = now();
-      await persistState(state);
-      logger.debug("Scheduler tick completed.");
-      await sleep(state.config.pollIntervalMs);
+      const shouldPersist = hasDirtyState() || Date.now() - lastPersistAt > PERSIST_DEBOUNCE_MS;
+      if (shouldPersist) {
+        await persistState(state);
+        lastPersistAt = Date.now();
+      }
+      logger.debug({ runningCount: running.size, issueCount: state.issues.length, dirty: hasDirtyState() }, "[Scheduler] Tick completed");
+      const effectivePoll = running.size > 0 ? ACTIVE_POLL_MS : IDLE_POLL_MS;
+      await Promise.race([
+        sleep(effectivePoll),
+        new Promise((resolve4) => {
+          schedulerWakeResolve = resolve4;
+        })
+      ]);
+      schedulerWakeResolve = null;
     }
     return;
   }
@@ -4366,11 +4673,16 @@ async function scheduler(state, running, runForever, workflowDefinition) {
     const next = ready.slice(0, Math.max(0, slots));
     if (next.length === 0 && running.size === 0) {
       if (state.issues.some((issue) => issue.state === "Blocked" && issue.nextRetryAt && issue.attempts < issue.maxAttempts)) {
+        logger.debug("[Scheduler] Batch mode: waiting for blocked issues to become eligible for retry");
         await sleep(state.config.pollIntervalMs);
         continue;
       }
+      logger.debug("[Scheduler] Batch mode: no more work to do, exiting loop");
       break;
     }
+    if (next.length > 0) {
+      logger.debug({ slots, dispatching: next.map((i) => i.identifier) }, "[Scheduler] Batch mode: dispatching issues");
+    }
     await Promise.all(next.map((issue) => runIssueOnce(state, issue, running, workflowDefinition)));
     state.updatedAt = now();
     await persistState(state);
@@ -4380,12 +4692,12 @@ async function scheduler(state, running, runForever, workflowDefinition) {
   }
 }
 
-// src/runtime/issue-enhancer.ts
-import { env as env7 } from "process";
-import { existsSync as existsSync6, mkdtempSync, readFileSync as readFileSync5, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
+// src/agent/issue-enhancer.ts
+import { env as env8 } from "process";
+import { existsSync as existsSync7, mkdtempSync, readFileSync as readFileSync6, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
 import { spawn as spawn3 } from "child_process";
 import { tmpdir } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 function getProviderCommand(provider, config, workflowDefinition) {
   const workflowConfig = workflowDefinition ? workflowDefinition.config : {};
   const codexCommand = getNestedString(getNestedRecord(workflowConfig, "codex"), "command");
@@ -4455,23 +4767,23 @@ function parseCandidate(raw, expectedField) {
   return "";
 }
 function readProviderOutput(resultFile, fallback) {
-  if (existsSync6(resultFile)) {
+  if (existsSync7(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) {
-  const tempDir = mkdtempSync(join9(tmpdir(), "fifony-enhance-"));
-  const promptFile = join9(tempDir, "fifony-enhance-prompt.md");
-  const issuePayloadFile = join9(tempDir, "fifony-issue.json");
-  const resultFile = join9(tempDir, "fifony-result.txt");
-  const envFile = join9(tempDir, "fifony-enhance-env.sh");
-  writeFileSync3(promptFile, `${prompt}
+  const tempDir = mkdtempSync(join10(tmpdir(), "fifony-enhance-"));
+  const promptFile = join10(tempDir, "fifony-enhance-prompt.md");
+  const issuePayloadFile = join10(tempDir, "fifony-issue.json");
+  const resultFile = join10(tempDir, "fifony-result.txt");
+  const envFile = join10(tempDir, "fifony-enhance-env.sh");
+  writeFileSync4(promptFile, `${prompt}
 `, "utf8");
-  writeFileSync3(issuePayloadFile, JSON.stringify({ title, description, field }, null, 2), "utf8");
+  writeFileSync4(issuePayloadFile, JSON.stringify({ title, description, field }, null, 2), "utf8");
   const envLines = [
     `export FIFONY_ISSUE_TITLE=${JSON.stringify(title)}`,
     `export FIFONY_ISSUE_DESCRIPTION=${JSON.stringify(description)}`,
@@ -4482,11 +4794,11 @@ async function runProviderCommand(command, provider, prompt, title, description,
     "export FIFONY_AGENT_PROVIDER=" + JSON.stringify(provider),
     "export FIFONY_RESULT_FILE=" + JSON.stringify(resultFile)
   ];
-  const processEnv = Object.entries(env7).map(([key, value]) => {
+  const processEnv = Object.entries(env8).map(([key, value]) => {
     if (typeof value !== "string") return `export ${key}=${JSON.stringify("")}`;
     return `export ${key}=${JSON.stringify(value)}`;
   }).join("\n");
-  writeFileSync3(envFile, `${processEnv}
+  writeFileSync4(envFile, `${processEnv}
 ${envLines.join("\n")}
 `, "utf8");
   const wrappedCommand = `. "${envFile}" && ${command}`;
@@ -4586,10 +4898,10 @@ async function enhanceIssueField(payload, config, workflowDefinition) {
   throw new Error(`Could not enhance issue field. ${errors.join(" | ")}`);
 }
 
-// src/runtime/issue-planner.ts
-import { mkdtempSync as mkdtempSync2, writeFileSync as writeFileSync4, rmSync as rmSync3 } from "fs";
+// src/agent/issue-planner.ts
+import { mkdtempSync as mkdtempSync2, writeFileSync as writeFileSync5, rmSync as rmSync3 } from "fs";
 import { spawn as spawn4 } from "child_process";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 var PLANNING_SETTING_ID = "planning:active";
 function emptySession() {
@@ -4772,6 +5084,26 @@ function parsePlanOutput(raw) {
     } catch {
     }
   }
+  const repaired = repairTruncatedJson(text);
+  if (repaired) {
+    try {
+      const parsed = JSON.parse(repaired);
+      const plan = tryBuildPlan(parsed);
+      if (plan) {
+        logger.warn("[Planner] Plan parsed from repaired truncated JSON output");
+        return plan;
+      }
+      if (parsed?.structured_output && typeof parsed.structured_output === "object") {
+        const innerPlan = tryBuildPlan(parsed.structured_output);
+        if (innerPlan) {
+          logger.warn("[Planner] Plan parsed from repaired truncated JSON envelope");
+          return innerPlan;
+        }
+      }
+    } catch {
+      logger.debug("[Planner] JSON repair attempted but result still not parseable");
+    }
+  }
   return null;
 }
 async function savePlanningInput(title, description) {
@@ -4839,6 +5171,7 @@ function extractPlanTokenUsage(raw) {
 }
 async function generatePlan(title, description, config, workflowDefinition, options) {
   const fast = options?.fast ?? false;
+  logger.info({ title: title.slice(0, 80), fast }, "[Planner] Starting plan generation");
   const providers = detectAvailableProviders();
   const available = providers.filter((p) => p.available).map((p) => p.name);
   let planStageProvider;
@@ -4859,6 +5192,7 @@ async function generatePlan(title, description, config, workflowDefinition, opti
   const effectiveEffort = fast ? "low" : planStageEffort || "medium";
   const command = getPlanCommand(preferred, planStageModel);
   if (!command) throw new Error(`No command configured for provider ${preferred}.`);
+  logger.debug({ provider: preferred, model: planStageModel, effort: effectiveEffort, command: command.slice(0, 120) }, "[Planner] Provider selected for plan generation");
   const planStartMs = Date.now();
   const session = {
     title,
@@ -4876,25 +5210,24 @@ async function generatePlan(title, description, config, workflowDefinition, opti
   };
   await persistSession(session);
   const prompt = await buildPlanPrompt(title, description, fast);
-  const tempDir = mkdtempSync2(join10(tmpdir2(), "fifony-plan-"));
-  const promptFile = join10(tempDir, "fifony-plan-prompt.md");
-  const envFile = join10(tempDir, "fifony-plan-env.sh");
-  writeFileSync4(promptFile, `${prompt}
+  const tempDir = mkdtempSync2(join11(tmpdir2(), "fifony-plan-"));
+  const promptFile = join11(tempDir, "fifony-plan-prompt.md");
+  writeFileSync5(promptFile, `${prompt}
 `, "utf8");
-  writeFileSync4(envFile, [
-    `export FIFONY_PROMPT_FILE=${JSON.stringify(promptFile)}`,
-    `export FIFONY_AGENT_PROVIDER=${JSON.stringify(preferred)}`
-  ].join("\n"), "utf8");
-  const wrappedCommand = `. "${envFile}" && ${command}`;
   let lastProgressPersist = 0;
   const PROGRESS_INTERVAL_MS = 2e3;
   const output = await new Promise((resolve4, reject) => {
     let stdout2 = "";
-    const child = spawn4(wrappedCommand, {
+    const child = spawn4(command, {
       shell: true,
       cwd: tempDir,
       detached: true,
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        FIFONY_PROMPT_FILE: promptFile,
+        FIFONY_AGENT_PROVIDER: preferred
+      }
     });
     child.unref();
     child.stdin?.end();
@@ -4943,13 +5276,17 @@ async function generatePlan(title, description, config, workflowDefinition, opti
     });
   });
   logger.info({ rawOutput: output.slice(0, 2e3) }, `Plan raw output from ${preferred}`);
+  logger.debug({ outputLength: output.length }, "[Planner] Plan command completed, parsing output");
   const plan = parsePlanOutput(output);
   if (!plan) {
+    const firstBrace = output.indexOf("{");
+    const lastBrace = output.lastIndexOf("}");
+    const truncationHint = firstBrace >= 0 && lastBrace < firstBrace ? " (JSON appears truncated \u2014 opening brace found but no matching close)" : firstBrace < 0 ? " (no JSON object found in output)" : "";
     session.status = "error";
-    session.error = `Could not parse plan. Output: ${output.slice(0, 500)}`;
+    session.error = `Could not parse plan${truncationHint}. Output length: ${output.length} chars. Tail: ${output.slice(-200)}`;
     session.pid = null;
     await persistSession(session);
-    logger.error({ rawOutput: output.slice(0, 2e3) }, "Could not parse plan from AI output");
+    logger.error({ rawOutput: output.slice(0, 2e3), outputLength: output.length, firstBrace, lastBrace }, "[Planner] Could not parse plan from AI output");
     throw new Error(session.error);
   }
   plan.provider = planStageModel ? `${preferred}/${planStageModel}` : preferred;
@@ -5013,23 +5350,22 @@ async function refinePlan(issue, feedback, config, workflowDefinition) {
   if (!command) throw new Error(`No command configured for provider ${preferred}.`);
   const refineStartMs = Date.now();
   const prompt = await buildRefinePrompt(issue.title, issue.description, issue.plan, feedback);
-  const tempDir = mkdtempSync2(join10(tmpdir2(), "fifony-refine-"));
-  const promptFile = join10(tempDir, "fifony-refine-prompt.md");
-  const envFile = join10(tempDir, "fifony-refine-env.sh");
-  writeFileSync4(promptFile, `${prompt}
+  const tempDir = mkdtempSync2(join11(tmpdir2(), "fifony-refine-"));
+  const promptFile = join11(tempDir, "fifony-refine-prompt.md");
+  writeFileSync5(promptFile, `${prompt}
 `, "utf8");
-  writeFileSync4(envFile, [
-    `export FIFONY_PROMPT_FILE=${JSON.stringify(promptFile)}`,
-    `export FIFONY_AGENT_PROVIDER=${JSON.stringify(preferred)}`
-  ].join("\n"), "utf8");
-  const wrappedCommand = `. "${envFile}" && ${command}`;
   const output = await new Promise((resolve4, reject) => {
     let stdout2 = "";
-    const child = spawn4(wrappedCommand, {
+    const child = spawn4(command, {
       shell: true,
       cwd: tempDir,
       detached: true,
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        FIFONY_PROMPT_FILE: promptFile,
+        FIFONY_AGENT_PROVIDER: preferred
+      }
     });
     child.unref();
     child.stdin?.end();
@@ -5067,8 +5403,11 @@ async function refinePlan(issue, feedback, config, workflowDefinition) {
   logger.info({ rawOutput: output.slice(0, 2e3) }, `Refine raw output from ${preferred}`);
   const plan = parsePlanOutput(output);
   if (!plan) {
-    logger.error({ rawOutput: output.slice(0, 2e3) }, "Could not parse refined plan from AI output");
-    throw new Error(`Could not parse refined plan. Output: ${output.slice(0, 500)}`);
+    const firstBrace = output.indexOf("{");
+    const lastBrace = output.lastIndexOf("}");
+    const truncationHint = firstBrace >= 0 && lastBrace < firstBrace ? " (JSON appears truncated \u2014 opening brace found but no matching close)" : firstBrace < 0 ? " (no JSON object found in output)" : "";
+    logger.error({ rawOutput: output.slice(0, 2e3), outputLength: output.length, firstBrace, lastBrace }, "Could not parse refined plan from AI output");
+    throw new Error(`Could not parse refined plan${truncationHint}. Output length: ${output.length} chars. Tail: ${output.slice(-200)}`);
   }
   plan.provider = planStageModel ? `${preferred}/${planStageModel}` : preferred;
   const existingRefinements = issue.plan.refinements ?? [];
@@ -5105,11 +5444,14 @@ function generatePlanInBackground(issue, config, workflowDefinition, callbacks,
   const { addEvent: addEvent2, persistState: persistState2, applyUsage, applySuggestions } = callbacks;
   const fast = options?.fast ?? false;
   issue.planningStatus = "planning";
+  issue.planningStartedAt = now();
   issue.planningError = void 0;
   issue.updatedAt = now();
+  addEvent2(issue.id, "info", `${fast ? "Fast plan" : "Plan"} generation starting for ${issue.identifier} (provider detection in progress).`);
   generatePlan(issue.title, issue.description, config, workflowDefinition, { fast }).then(async ({ plan, usage: usage2 }) => {
     issue.plan = plan;
     issue.planningStatus = "idle";
+    issue.planningStartedAt = void 0;
     issue.planningError = void 0;
     issue.updatedAt = now();
     applyUsage(issue, usage2);
@@ -5121,6 +5463,7 @@ function generatePlanInBackground(issue, config, workflowDefinition, callbacks,
     await persistState2();
   }).catch(async (err) => {
     issue.planningStatus = "idle";
+    issue.planningStartedAt = void 0;
     issue.planningError = err instanceof Error ? err.message : String(err);
     issue.updatedAt = now();
     addEvent2(issue.id, "error", `Plan generation failed for ${issue.identifier}: ${issue.planningError}`);
@@ -5131,11 +5474,15 @@ function generatePlanInBackground(issue, config, workflowDefinition, callbacks,
 function refinePlanInBackground(issue, feedback, config, workflowDefinition, callbacks) {
   const { addEvent: addEvent2, persistState: persistState2, applyUsage, applySuggestions } = callbacks;
   issue.planningStatus = "refining";
+  issue.planningStartedAt = now();
   issue.planningError = void 0;
   issue.updatedAt = now();
+  const feedbackSnippet = feedback.length > 60 ? `${feedback.slice(0, 57)}...` : feedback;
+  addEvent2(issue.id, "info", `Plan refinement starting for ${issue.identifier}: "${feedbackSnippet}".`);
   refinePlan(issue, feedback, config, workflowDefinition).then(async ({ plan, usage: usage2 }) => {
     issue.plan = plan;
     issue.planningStatus = "idle";
+    issue.planningStartedAt = void 0;
     issue.planningError = void 0;
     issue.updatedAt = now();
     applyUsage(issue, usage2);
@@ -5148,6 +5495,7 @@ function refinePlanInBackground(issue, feedback, config, workflowDefinition, cal
     await persistState2();
   }).catch(async (err) => {
     issue.planningStatus = "idle";
+    issue.planningStartedAt = void 0;
     issue.planningError = err instanceof Error ? err.message : String(err);
     issue.updatedAt = now();
     addEvent2(issue.id, "error", `Plan refinement failed for ${issue.identifier}: ${issue.planningError}`);
@@ -5156,21 +5504,22 @@ function refinePlanInBackground(issue, feedback, config, workflowDefinition, cal
   });
 }
 
-// src/runtime/project-scanner.ts
+// src/agent/project-scanner.ts
 import {
-  existsSync as existsSync7,
+  existsSync as existsSync8,
   mkdtempSync as mkdtempSync3,
-  readdirSync as readdirSync4,
-  readFileSync as readFileSync6,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync7,
   rmSync as rmSync4,
-  writeFileSync as writeFileSync5
+  writeFileSync as writeFileSync6
 } from "fs";
-import { join as join11, basename as basename2 } from "path";
+import { join as join12, basename as basename2 } from "path";
 import { spawn as spawn5 } from "child_process";
 import { tmpdir as tmpdir3 } from "os";
-import { env as env8 } from "process";
+import { env as env9 } from "process";
+import { createHash } from "crypto";
 function scanProjectFiles(targetRoot) {
-  const check = (rel) => existsSync7(join11(targetRoot, rel));
+  const check = (rel) => existsSync8(join12(targetRoot, rel));
   const files = {
     claudeMd: check("CLAUDE.md"),
     claudeDir: check(".claude"),
@@ -5192,10 +5541,10 @@ function scanProjectFiles(targetRoot) {
   };
   const existingAgents = [];
   for (const agentDir of [".claude/agents", ".codex/agents"]) {
-    const fullPath = join11(targetRoot, agentDir);
-    if (!existsSync7(fullPath)) continue;
+    const fullPath = join12(targetRoot, agentDir);
+    if (!existsSync8(fullPath)) continue;
     try {
-      const entries = readdirSync4(fullPath);
+      const entries = readdirSync5(fullPath);
       for (const entry of entries) {
         if (entry.endsWith(".md")) {
           existingAgents.push(basename2(entry, ".md"));
@@ -5206,13 +5555,13 @@ function scanProjectFiles(targetRoot) {
   }
   const existingSkills = [];
   for (const skillDir of [".claude/skills", ".codex/skills"]) {
-    const fullPath = join11(targetRoot, skillDir);
-    if (!existsSync7(fullPath)) continue;
+    const fullPath = join12(targetRoot, skillDir);
+    if (!existsSync8(fullPath)) continue;
     try {
-      const entries = readdirSync4(fullPath);
+      const entries = readdirSync5(fullPath);
       for (const entry of entries) {
-        const skillFile = join11(fullPath, entry, "SKILL.md");
-        if (existsSync7(skillFile)) {
+        const skillFile = join12(fullPath, entry, "SKILL.md");
+        if (existsSync8(skillFile)) {
           existingSkills.push(entry);
         }
       }
@@ -5220,20 +5569,20 @@ function scanProjectFiles(targetRoot) {
     }
   }
   let readmeExcerpt = "";
-  const readmePath = join11(targetRoot, "README.md");
-  if (existsSync7(readmePath)) {
+  const readmePath = join12(targetRoot, "README.md");
+  if (existsSync8(readmePath)) {
     try {
-      const content = readFileSync6(readmePath, "utf8");
+      const content = readFileSync7(readmePath, "utf8");
       readmeExcerpt = content.slice(0, 200).trim();
     } catch {
     }
   }
   let packageName = "";
   let packageDescription = "";
-  const pkgPath = join11(targetRoot, "package.json");
-  if (existsSync7(pkgPath)) {
+  const pkgPath = join12(targetRoot, "package.json");
+  if (existsSync8(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync6(pkgPath, "utf8"));
+      const pkg = JSON.parse(readFileSync7(pkgPath, "utf8"));
       packageName = typeof pkg.name === "string" ? pkg.name : "";
       packageDescription = typeof pkg.description === "string" ? pkg.description : "";
     } catch {
@@ -5275,39 +5624,39 @@ function buildFallbackAnalysis(targetRoot) {
   let description = "";
   let readmeExcerpt = "";
   for (const readmeFile of ["README.md", "README.rst", "README.txt", "README"]) {
-    const p = join11(targetRoot, readmeFile);
-    if (existsSync7(p)) {
+    const p = join12(targetRoot, readmeFile);
+    if (existsSync8(p)) {
       try {
-        readmeExcerpt = readFileSync6(p, "utf8").slice(0, 300).trim();
+        readmeExcerpt = readFileSync7(p, "utf8").slice(0, 300).trim();
         break;
       } catch {
       }
     }
   }
-  const pkgPath = join11(targetRoot, "package.json");
-  if (existsSync7(pkgPath)) {
+  const pkgPath = join12(targetRoot, "package.json");
+  if (existsSync8(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync6(pkgPath, "utf8"));
+      const pkg = JSON.parse(readFileSync7(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 = join11(targetRoot, "Cargo.toml");
-  if (!description && existsSync7(cargoPath)) {
+  const cargoPath = join12(targetRoot, "Cargo.toml");
+  if (!description && existsSync8(cargoPath)) {
     try {
-      const content = readFileSync6(cargoPath, "utf8");
+      const content = readFileSync7(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 = join11(targetRoot, "pyproject.toml");
-  if (!description && existsSync7(pyprojectPath)) {
+  const pyprojectPath = join12(targetRoot, "pyproject.toml");
+  if (!description && existsSync8(pyprojectPath)) {
     try {
-      const content = readFileSync6(pyprojectPath, "utf8");
+      const content = readFileSync7(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];
@@ -5320,7 +5669,7 @@ function buildFallbackAnalysis(targetRoot) {
   let language = "unknown";
   const stack = [];
   for (const [file, signal] of Object.entries(BUILD_FILE_SIGNALS)) {
-    if (existsSync7(join11(targetRoot, file))) {
+    if (existsSync8(join12(targetRoot, file))) {
       if (language === "unknown" && signal.language !== "unknown") {
         language = signal.language;
       }
@@ -5388,7 +5737,51 @@ function validateAnalysis(parsed) {
     source: "cli"
   };
 }
-async function analyzeProjectWithCli(provider, targetRoot) {
+var ANALYSIS_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+function computeProjectHash(targetRoot) {
+  const buildFiles = Object.keys(BUILD_FILE_SIGNALS);
+  const found = buildFiles.filter((f) => existsSync8(join12(targetRoot, f))).sort();
+  return createHash("sha256").update(found.join(",")).digest("hex").slice(0, 16);
+}
+async function loadCachedAnalysis(targetRoot) {
+  const resource = getSettingStateResource();
+  if (!resource) return null;
+  const hash = computeProjectHash(targetRoot);
+  const key = `project-analysis:${hash}`;
+  try {
+    const record2 = await resource.get(key);
+    if (!record2?.value) return null;
+    const cached = record2.value;
+    if (!cached.analysis || !cached.updatedAt) return null;
+    if (Date.now() - Date.parse(cached.updatedAt) > ANALYSIS_CACHE_TTL_MS) return null;
+    return cached.analysis;
+  } catch {
+    return null;
+  }
+}
+async function saveCachedAnalysis(targetRoot, analysis) {
+  const resource = getSettingStateResource();
+  if (!resource) return;
+  const hash = computeProjectHash(targetRoot);
+  const key = `project-analysis:${hash}`;
+  try {
+    await resource.replace(key, {
+      id: key,
+      scope: "system",
+      source: "detected",
+      value: { analysis, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }
+    });
+  } catch {
+  }
+}
+async function analyzeProjectWithCli(provider, targetRoot, options) {
+  if (!options?.forceRefresh) {
+    const cached = await loadCachedAnalysis(targetRoot);
+    if (cached) {
+      logger.info("Using cached project analysis.");
+      return cached;
+    }
+  }
   const normalizedProvider = provider.trim().toLowerCase();
   const providers = detectAvailableProviders();
   const providerInfo = providers.find((p) => p.name === normalizedProvider && p.available);
@@ -5399,12 +5792,12 @@ async function analyzeProjectWithCli(provider, targetRoot) {
     );
     return buildFallbackAnalysis(targetRoot);
   }
-  const tempDir = mkdtempSync3(join11(tmpdir3(), "fifony-scan-"));
-  const promptFile = join11(tempDir, "fifony-scan-prompt.txt");
+  const tempDir = mkdtempSync3(join12(tmpdir3(), "fifony-scan-"));
+  const promptFile = join12(tempDir, "fifony-scan-prompt.txt");
   const analysisPrompt = await renderPrompt("project-analysis");
-  writeFileSync5(promptFile, analysisPrompt, "utf8");
+  writeFileSync6(promptFile, analysisPrompt, "utf8");
   const processEnv = {};
-  for (const [key, value] of Object.entries(env8)) {
+  for (const [key, value] of Object.entries(env9)) {
     if (typeof value === "string") processEnv[key] = value;
   }
   processEnv.FIFONY_PROMPT_FILE = promptFile;
@@ -5473,6 +5866,7 @@ async function analyzeProjectWithCli(provider, targetRoot) {
         { provider: normalizedProvider, domains: analysis.domains, stack: analysis.stack },
         "CLI project analysis completed"
       );
+      await saveCachedAnalysis(targetRoot, analysis);
       return analysis;
     }
     logger.warn(
@@ -5494,27 +5888,180 @@ async function analyzeProjectWithCli(provider, targetRoot) {
   }
 }
 
-// src/runtime/catalog.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
-import { join as join12, dirname as dirname2 } from "path";
+// src/agent/issue-scanner.ts
+import { execFileSync as execFileSync2 } from "child_process";
+var SCAN_PATTERN = /\b(TODO|FIXME|HACK|XXX)\b[:\s]*(.*)/i;
+var EXCLUDE_DIRS = [
+  "node_modules",
+  ".git",
+  ".fifony",
+  "dist",
+  "build",
+  ".turbo",
+  ".next",
+  ".nuxt",
+  "coverage",
+  ".venv",
+  "vendor",
+  "tmp",
+  "temp",
+  "artifacts"
+];
+function scanForTodos(targetRoot) {
+  const excludeArgs = EXCLUDE_DIRS.flatMap((dir) => ["--exclude-dir", dir]);
+  let output;
+  try {
+    output = execFileSync2("grep", [
+      "-rn",
+      "-E",
+      "\\b(TODO|FIXME|HACK|XXX)\\b",
+      ...excludeArgs,
+      "--include=*.ts",
+      "--include=*.tsx",
+      "--include=*.js",
+      "--include=*.jsx",
+      "--include=*.py",
+      "--include=*.rs",
+      "--include=*.go",
+      "--include=*.java",
+      "--include=*.rb",
+      "--include=*.php",
+      "--include=*.cs",
+      "--include=*.swift",
+      "--include=*.kt",
+      "--include=*.vue",
+      "--include=*.svelte",
+      targetRoot
+    ], {
+      encoding: "utf8",
+      timeout: 15e3,
+      maxBuffer: 5e6
+    });
+  } catch (error) {
+    if (error.status === 1) return [];
+    if (error.stdout) output = error.stdout;
+    else {
+      logger.warn(`TODO scan failed: ${String(error)}`);
+      return [];
+    }
+  }
+  const results = [];
+  const lines = output.split("\n").filter(Boolean);
+  for (const line of lines) {
+    const match = line.match(/^(.+?):(\d+):(.+)$/);
+    if (!match) continue;
+    const [, file, lineNo, content] = match;
+    const todoMatch = content.match(SCAN_PATTERN);
+    if (!todoMatch) continue;
+    const [, tag, text] = todoMatch;
+    const source = tag.toLowerCase();
+    const trimmedText = text.trim();
+    if (!trimmedText || trimmedText.length < 5) continue;
+    const relativePath = file.startsWith(targetRoot) ? file.slice(targetRoot.length + 1) : file;
+    results.push({
+      source: source === "xxx" ? "hack" : source,
+      title: trimmedText.length > 120 ? `${trimmedText.slice(0, 117)}...` : trimmedText,
+      file: relativePath,
+      line: parseInt(lineNo, 10),
+      context: content.trim()
+    });
+  }
+  return results;
+}
+function categorizeScannedIssues(issues, workflowDefinition) {
+  const options = getCapabilityRoutingOptions(workflowDefinition);
+  return issues.map((issue) => {
+    const resolution = resolveTaskCapabilities({
+      id: `scan-${issue.file}:${issue.line}`,
+      identifier: `${issue.source}:${issue.file}:${issue.line}`,
+      title: issue.title,
+      description: issue.context,
+      labels: [issue.source],
+      paths: [issue.file]
+    }, options);
+    return {
+      ...issue,
+      category: resolution.category,
+      overlays: resolution.overlays,
+      rationale: resolution.rationale,
+      suggestedLabels: [
+        issue.source,
+        resolution.category ? `capability:${resolution.category}` : ""
+      ].filter(Boolean),
+      suggestedPaths: [issue.file]
+    };
+  });
+}
+
+// src/agent/github-sync.ts
+import { execFile } from "child_process";
+async function fetchGitHubIssues(targetRoot) {
+  return new Promise((resolve4) => {
+    execFile(
+      "gh",
+      [
+        "issue",
+        "list",
+        "--json",
+        "number,title,body,labels,state,url",
+        "--state",
+        "open",
+        "--limit",
+        "50"
+      ],
+      {
+        cwd: targetRoot,
+        timeout: 15e3,
+        maxBuffer: 2e6
+      },
+      (error, stdout2) => {
+        if (error) {
+          logger.warn(`Failed to fetch GitHub issues: ${String(error)}`);
+          resolve4([]);
+          return;
+        }
+        try {
+          const issues = JSON.parse(stdout2.trim());
+          const results = issues.map((issue) => ({
+            source: "github",
+            title: issue.title,
+            file: "",
+            line: 0,
+            context: (issue.body || "").slice(0, 500),
+            suggestedLabels: issue.labels.map((l) => l.name),
+            suggestedPaths: []
+          }));
+          resolve4(results);
+        } catch (parseError) {
+          logger.warn(`Failed to parse GitHub issues: ${String(parseError)}`);
+          resolve4([]);
+        }
+      }
+    );
+  });
+}
+
+// src/agent/catalog.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
+import { join as join13, dirname as dirname2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var __filename2 = fileURLToPath2(import.meta.url);
 var __dirname2 = dirname2(__filename2);
 function resolveFixturePath(filename) {
   const candidates = [
-    join12(__dirname2, "..", "fixtures", filename),
-    join12(__dirname2, "../..", "src", "fixtures", filename),
-    join12(__dirname2, "../../..", "src", "fixtures", filename)
+    join13(__dirname2, "..", "fixtures", filename),
+    join13(__dirname2, "../..", "src", "fixtures", filename),
+    join13(__dirname2, "../../..", "src", "fixtures", filename)
   ];
   for (const candidate of candidates) {
-    if (existsSync8(candidate)) return candidate;
+    if (existsSync9(candidate)) return candidate;
   }
   return candidates[0];
 }
 function loadAgentCatalog() {
   try {
     const filePath = resolveFixturePath("agent-catalog.json");
-    const raw = readFileSync7(filePath, "utf8");
+    const raw = readFileSync8(filePath, "utf8");
     return JSON.parse(raw);
   } catch (error) {
     logger.error({ err: error }, "Failed to load agent catalog");
@@ -5524,7 +6071,7 @@ function loadAgentCatalog() {
 function loadSkillCatalog() {
   try {
     const filePath = resolveFixturePath("skill-catalog.json");
-    const raw = readFileSync7(filePath, "utf8");
+    const raw = readFileSync8(filePath, "utf8");
     return JSON.parse(raw);
   } catch (error) {
     logger.error({ err: error }, "Failed to load skill catalog");
@@ -5543,9 +6090,9 @@ function filterByDomains(catalog, domains) {
 function installAgents(targetRoot, agentNames, catalog) {
   const result = { installed: [], skipped: [], errors: [] };
   const catalogMap = new Map(catalog.map((entry) => [entry.name, entry]));
-  const agentsDir = join12(targetRoot, ".claude", "agents");
+  const agentsDir = join13(targetRoot, ".claude", "agents");
   try {
-    mkdirSync2(agentsDir, { recursive: true });
+    mkdirSync3(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}` });
@@ -5557,13 +6104,13 @@ function installAgents(targetRoot, agentNames, catalog) {
       result.errors.push({ name, error: "Agent not found in catalog" });
       continue;
     }
-    const filePath = join12(agentsDir, `${name}.md`);
-    if (existsSync8(filePath)) {
+    const filePath = join13(agentsDir, `${name}.md`);
+    if (existsSync9(filePath)) {
       result.skipped.push(name);
       continue;
     }
     try {
-      writeFileSync6(filePath, entry.content, "utf8");
+      writeFileSync7(filePath, entry.content, "utf8");
       result.installed.push(name);
       logger.info({ agent: name, path: filePath }, "Agent installed");
     } catch (error) {
@@ -5578,9 +6125,9 @@ function installAgents(targetRoot, agentNames, catalog) {
 function installSkills(targetRoot, skillNames, catalog) {
   const result = { installed: [], skipped: [], errors: [] };
   const catalogMap = new Map(catalog.map((entry) => [entry.name, entry]));
-  const skillsDir = join12(targetRoot, ".claude", "skills");
+  const skillsDir = join13(targetRoot, ".claude", "skills");
   try {
-    mkdirSync2(skillsDir, { recursive: true });
+    mkdirSync3(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}` });
@@ -5592,16 +6139,16 @@ function installSkills(targetRoot, skillNames, catalog) {
       result.errors.push({ name, error: "Skill not found in catalog" });
       continue;
     }
-    const skillDir = join12(skillsDir, name);
-    const filePath = join12(skillDir, "SKILL.md");
-    if (existsSync8(filePath)) {
+    const skillDir = join13(skillsDir, name);
+    const filePath = join13(skillDir, "SKILL.md");
+    if (existsSync9(filePath)) {
       result.skipped.push(name);
       continue;
     }
     try {
-      mkdirSync2(skillDir, { recursive: true });
+      mkdirSync3(skillDir, { recursive: true });
       if (entry.installType === "bundled" && entry.content) {
-        writeFileSync6(filePath, entry.content, "utf8");
+        writeFileSync7(filePath, entry.content, "utf8");
       } else {
         const referenceContent = [
           `# ${entry.displayName}`,
@@ -5613,7 +6160,7 @@ function installSkills(targetRoot, skillNames, catalog) {
           "",
           `> This skill references an external resource. Install it from the source above.`
         ].filter(Boolean).join("\n");
-        writeFileSync6(filePath, referenceContent, "utf8");
+        writeFileSync7(filePath, referenceContent, "utf8");
       }
       result.installed.push(name);
       logger.info({ skill: name, path: filePath, type: entry.installType }, "Skill installed");
@@ -5627,7 +6174,8 @@ function installSkills(targetRoot, skillNames, catalog) {
   return result;
 }
 
-// src/runtime/api-server.ts
+// src/agent/api-server.ts
+import { join as join14 } from "path";
 var wsClients = /* @__PURE__ */ new Map();
 var broadcastSeq = 0;
 var lastBroadcastIssueSnapshot = /* @__PURE__ */ new Map();
@@ -5646,6 +6194,7 @@ function sendToAllClients(data) {
 function broadcastToWebSocketClients(message) {
   if (wsClients.size === 0) return;
   broadcastSeq++;
+  logger.debug({ seq: broadcastSeq, type: message.type, clientCount: wsClients.size }, "[WebSocket] Broadcasting state update");
   const issues = message.issues;
   if (issues && lastBroadcastIssueSnapshot.size > 0) {
     const currentIds = /* @__PURE__ */ new Set();
@@ -5693,6 +6242,7 @@ function broadcastToWebSocketClients(message) {
   }));
 }
 async function startApiServer(state, port, workflowDefinition) {
+  logger.info({ port }, "[API] Starting API server");
   const stateDb2 = getStateDb();
   if (!stateDb2) {
     throw new Error("Cannot start API plugin before the database is initialized.");
@@ -5765,9 +6315,15 @@ async function startApiServer(state, port, workflowDefinition) {
     if (!issue) {
       return c.json({ ok: false, error: "Issue not found" }, 404);
     }
-    await updater(issue);
-    await persistState(state);
-    return c.json({ ok: true, issue });
+    try {
+      await updater(issue);
+      await persistState(state);
+      wakeScheduler();
+      return c.json({ ok: true, issue });
+    } catch (error) {
+      logger.error({ err: error, issueId }, "[API] mutateIssueState failed");
+      return c.json({ ok: false, error: error instanceof Error ? error.message : String(error) }, 500);
+    }
   };
   const resourceConfigs = Object.fromEntries(
     NATIVE_RESOURCE_CONFIGS.map((resourceConfig) => [
@@ -5787,10 +6343,10 @@ async function startApiServer(state, port, workflowDefinition) {
   }
   setApiRuntimeContext(state, workflowDefinition);
   const serveTextFile = (filePath, contentType, cacheControl = "no-cache") => {
-    if (!existsSync9(filePath)) {
+    if (!existsSync10(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
@@ -5798,10 +6354,10 @@ async function startApiServer(state, port, workflowDefinition) {
     });
   };
   const serveAppShell = () => {
-    if (!existsSync9(FRONTEND_INDEX)) {
+    if (!existsSync10(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",
@@ -5881,14 +6437,17 @@ async function startApiServer(state, port, workflowDefinition) {
       "GET /offline.html": () => serveTextFile(FRONTEND_OFFLINE_HTML, "text/html; charset=utf-8"),
       "GET /icon.svg": () => serveTextFile(FRONTEND_ICON_SVG, "image/svg+xml", "public, max-age=604800, immutable"),
       "GET /icon-maskable.svg": () => serveTextFile(FRONTEND_MASKABLE_ICON_SVG, "image/svg+xml", "public, max-age=604800, immutable"),
+      "GET /onboarding": () => serveAppShell(),
       "GET /kanban": () => serveAppShell(),
       "GET /issues": () => serveAppShell(),
+      "GET /discover": () => serveAppShell(),
       "GET /agents": () => serveAppShell(),
       "GET /settings": () => serveAppShell(),
       "GET /settings/general": () => serveAppShell(),
       "GET /settings/notifications": () => serveAppShell(),
       "GET /settings/workflow": () => serveAppShell(),
       "GET /settings/providers": () => serveAppShell(),
+      "GET /api/health": (c) => c.json({ status: state.booting ? "booting" : "ready" }),
       "GET /api/state": async (c) => {
         const showAll = c.req.query("all") === "1";
         let issues = state.issues;
@@ -6037,6 +6596,7 @@ async function startApiServer(state, port, workflowDefinition) {
           const title = toStringValue(payload.title);
           const description = toStringValue(payload.description);
           if (!title) return c.json({ ok: false, error: "Title is required." }, 400);
+          logger.info({ title: title.slice(0, 80) }, "[API] POST /api/planning/generate");
           const result = await generatePlan(title, description, state.config, workflowDefinition);
           return c.json({ ok: true, plan: result.plan, usage: result.usage });
         } catch (error) {
@@ -6064,13 +6624,16 @@ async function startApiServer(state, port, workflowDefinition) {
       "POST /api/issues/create": async (c) => {
         try {
           const payload = await c.req.json();
+          logger.info({ title: toStringValue(payload.title, "").slice(0, 80) }, "[API] POST /api/issues/create");
           const issue = createIssueFromPayload(payload, state.issues, workflowDefinition);
           state.issues.push(issue);
+          markIssueDirty(issue.id);
           addEvent(state, issue.id, "info", `Issue ${issue.identifier} created via API.`);
           if (issue.plan) {
             addEvent(state, issue.id, "info", `Plan: ${issue.plan.steps.length} steps, complexity: ${issue.plan.estimatedComplexity}.`);
           }
           await persistState(state);
+          wakeScheduler();
           return c.json({ ok: true, issue }, 201);
         } catch (error) {
           return c.json({ ok: false, error: error instanceof Error ? error.message : String(error) }, 400);
@@ -6111,14 +6674,17 @@ async function startApiServer(state, port, workflowDefinition) {
         }
         try {
           const payload = await c.req.json();
+          logger.info({ issueId, identifier: issue.identifier, targetState: payload.state }, "[API] POST /api/issues/:id/state");
           await handleStatePatch(state, issue, payload);
           await persistState(state);
+          wakeScheduler();
           return c.json({ ok: true, issue });
         } catch (error) {
           return c.json({ ok: false, error: error instanceof Error ? error.message : String(error) }, 400);
         }
       },
       "POST /api/issues/:id/retry": async (c) => {
+        logger.info({ issueId: parseIssue(c) }, "[API] POST /api/issues/:id/retry");
         return mutateIssueState(c, async (issue) => {
           if (TERMINAL_STATES.has(issue.state)) {
             await transitionIssueState(issue, "Todo", "Manual retry requested.");
@@ -6131,6 +6697,7 @@ async function startApiServer(state, port, workflowDefinition) {
         });
       },
       "POST /api/issues/:id/cancel": async (c) => {
+        logger.info({ issueId: parseIssue(c) }, "[API] POST /api/issues/:id/cancel");
         return mutateIssueState(c, async (issue) => {
           await transitionIssueState(issue, "Cancelled", "Manual cancel requested.");
           addEvent(state, issue.id, "manual", `Manual cancel requested for ${issue.id}.`);
@@ -6156,6 +6723,7 @@ async function startApiServer(state, port, workflowDefinition) {
         });
       },
       "POST /api/issues/:id/approve": async (c) => {
+        logger.info({ issueId: parseIssue(c) }, "[API] POST /api/issues/:id/approve");
         return mutateIssueState(c, async (issue) => {
           if (issue.state !== "Planning") {
             throw new Error(`Cannot approve issue in state ${issue.state}. Must be in Planning.`);
@@ -6165,13 +6733,14 @@ async function startApiServer(state, port, workflowDefinition) {
         });
       },
       "POST /api/issues/:id/merge": async (c) => {
+        logger.info({ issueId: parseIssue(c) }, "[API] POST /api/issues/:id/merge");
         try {
           const issueId = parseIssue(c);
           if (!issueId) return c.json({ ok: false, error: "Issue id is required." }, 400);
           const issue = findIssue2(issueId);
           if (!issue) return c.json({ ok: false, error: "Issue not found." }, 404);
           const wp = issue.workspacePath;
-          if (!wp || !existsSync9(wp)) {
+          if (!wp || !existsSync10(wp)) {
             return c.json({ ok: false, error: "No workspace found for this issue." }, 400);
           }
           const result = mergeWorkspace(wp);
@@ -6190,6 +6759,9 @@ async function startApiServer(state, port, workflowDefinition) {
       },
       "POST /api/issues/:id/plan/refine": async (c) => {
         return mutateIssueState(c, async (issue) => {
+          if (issue.state !== "Planning") {
+            throw new Error(`Cannot refine plan for issue in state ${issue.state}. Must be in Planning.`);
+          }
           if (!issue.plan) {
             throw new Error("Issue has no plan to refine. Generate a plan first.");
           }
@@ -6239,10 +6811,10 @@ async function startApiServer(state, port, workflowDefinition) {
           const liveLog = wp ? `${wp}/fifony-live-output.log` : null;
           let logTail = "";
           let logSize = 0;
-          if (liveLog && existsSync9(liveLog)) {
+          if (liveLog && existsSync10(liveLog)) {
             try {
-              const stat = statSync2(liveLog);
-              logSize = stat.size;
+              const stat2 = statSync3(liveLog);
+              logSize = stat2.size;
               const fd = openSync(liveLog, "r");
               const readSize = Math.min(logSize, 8192);
               const buf = Buffer.alloc(readSize);
@@ -6279,10 +6851,10 @@ async function startApiServer(state, port, workflowDefinition) {
           const issue = findIssue2(issueId);
           if (!issue) return c.json({ ok: false, error: "Issue not found." }, 404);
           const wp = issue.workspacePath;
-          if (!wp || !existsSync9(wp)) {
+          if (!wp || !existsSync10(wp)) {
             return c.json({ ok: true, files: [], diff: "", message: "No workspace found." });
           }
-          if (!existsSync9(SOURCE_ROOT)) {
+          if (!existsSync10(SOURCE_ROOT)) {
             return c.json({ ok: true, files: [], diff: "", message: "Source root not found." });
           }
           let raw = "";
@@ -6348,6 +6920,46 @@ async function startApiServer(state, port, workflowDefinition) {
         });
         return c.json({ events: events.slice(0, 200) });
       },
+      // ── Onboarding: gitignore check ────────────────────────────────────
+      "GET /api/gitignore/status": async (c) => {
+        try {
+          const gitignorePath = join14(TARGET_ROOT, ".gitignore");
+          if (!existsSync10(gitignorePath)) {
+            return c.json({ exists: false, hasFifony: false });
+          }
+          const content = readFileSync9(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 });
+        } catch (error) {
+          logger.error({ err: error }, "Failed to check .gitignore");
+          return c.json({ exists: false, hasFifony: false, error: "Failed to check .gitignore" }, 500);
+        }
+      },
+      "POST /api/gitignore/add": async (c) => {
+        try {
+          const gitignorePath = join14(TARGET_ROOT, ".gitignore");
+          if (!existsSync10(gitignorePath)) {
+            writeFileSync8(gitignorePath, "# Fifony state directory\n.fifony/\n", "utf-8");
+            return c.json({ ok: true, created: true });
+          }
+          const content = readFileSync9(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) {
+            return c.json({ ok: true, alreadyPresent: true });
+          }
+          const suffix = content.endsWith("\n") ? "" : "\n";
+          appendFileSync2(gitignorePath, `${suffix}
+# Fifony state directory
+.fifony/
+`, "utf-8");
+          return c.json({ ok: true, added: true });
+        } catch (error) {
+          logger.error({ err: error }, "Failed to update .gitignore");
+          return c.json({ ok: false, error: "Failed to update .gitignore" }, 500);
+        }
+      },
       // ── Onboarding: project scanning & catalog ─────────────────────────
       "GET /api/scan/project": async (c) => {
         try {
@@ -6369,6 +6981,30 @@ async function startApiServer(state, port, workflowDefinition) {
           return c.json({ ok: false, error: "Failed to analyze project." }, 500);
         }
       },
+      "GET /api/scan/issues": async (c) => {
+        try {
+          const todos = scanForTodos(TARGET_ROOT);
+          const categorized = categorizeScannedIssues(todos, workflowDefinition);
+          return c.json({ ok: true, issues: categorized, total: categorized.length });
+        } catch (error) {
+          logger.error({ err: error }, "Failed to scan for TODOs");
+          return c.json({ ok: false, error: "Failed to scan for issues." }, 500);
+        }
+      },
+      "POST /api/boot/skip-scan": async (c) => {
+        broadcastToWebSocketClients({ type: "boot:scan:skipped" });
+        return c.json({ ok: true, message: "Scan skipped." });
+      },
+      "GET /api/scan/github-issues": async (c) => {
+        try {
+          const issues = await fetchGitHubIssues(TARGET_ROOT);
+          const categorized = categorizeScannedIssues(issues, workflowDefinition);
+          return c.json({ ok: true, issues: categorized, total: categorized.length });
+        } catch (error) {
+          logger.error({ err: error }, "Failed to fetch GitHub issues");
+          return c.json({ ok: false, error: "Failed to fetch GitHub issues." }, 500);
+        }
+      },
       "GET /api/catalog/agents": async (c) => {
         const domainsParam = c.req.query("domains");
         const domains = typeof domainsParam === "string" ? domainsParam.split(",").map((d) => d.trim()).filter(Boolean) : [];
@@ -6419,7 +7055,7 @@ async function startApiServer(state, port, workflowDefinition) {
   logger.info(`OpenAPI docs available at http://localhost:${port}/docs`);
 }
 
-// src/runtime/store.ts
+// src/agent/store.ts
 var loadedS3dbModule = null;
 var stateDb = null;
 var runtimeStateResource = null;
@@ -6495,7 +7131,7 @@ async function initStateStore() {
   debugBoot("initStateStore:start");
   const { S3db, FileSystemClient, StateMachinePlugin } = await loadS3dbModule();
   debugBoot("initStateStore:module-loaded");
-  mkdirSync3(S3DB_DATABASE_PATH, { recursive: true });
+  mkdirSync4(S3DB_DATABASE_PATH, { recursive: true });
   stateDb = new S3db({
     client: new FileSystemClient({
       basePath: S3DB_DATABASE_PATH,
@@ -6589,7 +7225,11 @@ function isStateNotFoundError(error) {
   return false;
 }
 async function loadPersistedState() {
-  if (!runtimeStateResource) return null;
+  if (!runtimeStateResource) {
+    logger.debug("[Store] No runtime state resource available, skipping load");
+    return null;
+  }
+  logger.debug("[Store] Loading persisted state from s3db");
   try {
     const record2 = await runtimeStateResource.get(S3DB_RUNTIME_RECORD_ID);
     if (record2?.state && typeof record2.state === "object") {
@@ -6624,7 +7264,7 @@ async function recoverStateFromIssueResource() {
       config: {},
       issues,
       events: [],
-      metrics: computeMetrics(issues),
+      metrics: getMetrics(issues),
       notes: ["State recovered from individual issue records after corruption."]
     };
   } catch (error) {
@@ -6634,20 +7274,30 @@ async function recoverStateFromIssueResource() {
 }
 async function persistState(state) {
   state.metrics = {
-    ...computeMetrics(state.issues),
+    ...getMetrics(state.issues),
     activeWorkers: state.metrics.activeWorkers
   };
   if (!runtimeStateResource) return;
-  await runtimeStateResource.replace(S3DB_RUNTIME_RECORD_ID, {
-    id: S3DB_RUNTIME_RECORD_ID,
-    schemaVersion: S3DB_RUNTIME_SCHEMA_VERSION,
-    trackerKind: "filesystem",
-    runtimeTag: "local-only",
-    updatedAt: now(),
-    state
-  });
-  if (issueStateResource) {
+  const dirty = hasDirtyState();
+  const dirtyIssueCount = getDirtyIssueIds().size;
+  const dirtyEventCount = getDirtyEventIds().size;
+  if (dirty || dirtyIssueCount > 0 || dirtyEventCount > 0) {
+    logger.debug({ dirty, dirtyIssues: dirtyIssueCount, dirtyEvents: dirtyEventCount }, "[Store] Persisting state");
+  }
+  if (dirty) {
+    await runtimeStateResource.replace(S3DB_RUNTIME_RECORD_ID, {
+      id: S3DB_RUNTIME_RECORD_ID,
+      schemaVersion: S3DB_RUNTIME_SCHEMA_VERSION,
+      trackerKind: "filesystem",
+      runtimeTag: "local-only",
+      updatedAt: now(),
+      state
+    });
+  }
+  const dirtyIssues = getDirtyIssueIds();
+  if (issueStateResource && dirtyIssues.size > 0) {
     for (const issue of state.issues) {
+      if (!dirtyIssues.has(issue.id)) continue;
       const clean = {
         ...issue,
         nextRetryAt: issue.nextRetryAt || void 0,
@@ -6662,11 +7312,15 @@ async function persistState(state) {
         logger.warn(`Failed to persist issue ${issue.id}: ${String(error)}`);
       }
     }
+    clearDirtyIssueIds();
   }
-  if (eventStateResource) {
+  const dirtyEvents = getDirtyEventIds();
+  if (eventStateResource && dirtyEvents.size > 0) {
     for (const event of state.events) {
+      if (!dirtyEvents.has(event.id)) continue;
       await eventStateResource.replace(event.id, event);
     }
+    clearDirtyEventIds();
   }
   broadcastToWebSocketClients({
     type: "state:update",
@@ -6677,6 +7331,11 @@ async function persistState(state) {
     updatedAt: state.updatedAt
   });
 }
+async function persistStateFull(state) {
+  markAllIssuesDirty(state.issues.map((i) => i.id));
+  markAllEventsDirty(state.events.map((e) => e.id));
+  await persistState(state);
+}
 async function loadPersistedSettings() {
   if (!settingStateResource?.list) return [];
   try {
@@ -6696,6 +7355,7 @@ async function replacePersistedSetting(setting) {
   await settingStateResource.replace(setting.id, setting);
 }
 async function closeStateStore() {
+  logger.info("[Store] Closing state store and plugins");
   clearApiRuntimeContext();
   if (activeEcPlugin?.stop) {
     try {
@@ -6750,120 +7410,7 @@ async function closeStateStore() {
   }
 }
 
-// src/runtime/workflow.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync4, readdirSync as readdirSync5, readFileSync as readFileSync9, statSync as statSync3, writeFileSync as writeFileSync7 } from "fs";
-import { extname } from "path";
-import { argv as argv2, exit } from "process";
-function bootstrapSource() {
-  if (existsSync10(SOURCE_MARKER)) return;
-  logger.info("Creating local source snapshot for Fifony (local-only runtime)...");
-  const skipDirs = /* @__PURE__ */ new Set([
-    ".git",
-    ".fifony",
-    "node_modules",
-    ".venv",
-    "data",
-    "dist",
-    "build",
-    ".turbo",
-    ".next",
-    ".nuxt",
-    ".tanstack",
-    "coverage",
-    "artifacts",
-    "captures",
-    "tmp",
-    "temp"
-  ]);
-  const shouldSkip = (relativePath) => {
-    const parts = relativePath.split("/");
-    if (parts.some((segment) => skipDirs.has(segment))) return true;
-    const base = relativePath.split("/").at(-1) ?? "";
-    if (base.startsWith("map_scan_") && extname(base) === ".json") return true;
-    if (extname(base) === ".xlsx") return true;
-    return false;
-  };
-  const copyRecursive = (source, target, rel = "") => {
-    mkdirSync4(target, { recursive: true });
-    const items = readdirSync5(source, { withFileTypes: true });
-    for (const item of items) {
-      const nextRel = rel ? `${rel}/${item.name}` : item.name;
-      if (shouldSkip(nextRel)) continue;
-      const sourcePath = `${source}/${item.name}`;
-      const targetPath = `${target}/${item.name}`;
-      const itemStat = statSync3(sourcePath);
-      if (item.isDirectory()) {
-        copyRecursive(sourcePath, targetPath, nextRel);
-        continue;
-      }
-      if (item.isSymbolicLink() || itemStat.isSymbolicLink()) continue;
-      if (itemStat.isFile() || itemStat.isFIFO()) {
-        try {
-          const file = readFileSync9(sourcePath);
-          writeFileSync7(targetPath, file);
-        } catch (error) {
-          if (error.code === "ENOENT") {
-            logger.debug(`Skipped missing source file: ${sourcePath}`);
-          } else {
-            throw error;
-          }
-        }
-      }
-    }
-  };
-  mkdirSync4(SOURCE_ROOT, { recursive: true });
-  copyRecursive(TARGET_ROOT, SOURCE_ROOT);
-  writeFileSync7(SOURCE_MARKER, `${now()}
-`, "utf8");
-}
-function loadWorkflowDefinition() {
-  const defaultPrompt = PROMPT_TEMPLATES["workflow-default"];
-  return {
-    workflowPath: "",
-    rendered: "",
-    config: {},
-    promptTemplate: defaultPrompt,
-    agentProvider: "codex",
-    agentProfile: "",
-    agentProfilePath: "",
-    agentProfileInstructions: "",
-    agentProviders: [],
-    afterCreateHook: "",
-    beforeRunHook: "",
-    afterRunHook: "",
-    beforeRemoveHook: ""
-  };
-}
-function parsePort(args) {
-  for (let i = 0; i < args.length; i += 1) {
-    const arg = args[i];
-    if (arg === "--help" || arg === "-h") {
-      console.log(
-        `Usage: ${argv2[1]} [options]
-Options:
-  --port <n>             Start local dashboard (default: no UI and single batch run)
-  --workspace <path>     Target workspace root (default: current directory)
-  --persistence <path>   Persistence root (default: current directory)
-  --concurrency <n>      Maximum number of parallel issue runners
-  --attempts <n>         Maximum attempts per issue
-  --poll <ms>            Polling interval for the scheduler
-  --once                  Run one local batch and exit
-  --help                  Show this message`
-      );
-      exit(0);
-    }
-    if (arg === "--port") {
-      const value = args[i + 1];
-      if (!value || !/^\d+$/.test(value)) {
-        fail(`Invalid value for --port: ${value ?? "<empty>"}`);
-      }
-      return parseIntArg(value, 4040);
-    }
-  }
-  return void 0;
-}
-
-// src/runtime/dev-server.ts
+// src/agent/dev-server.ts
 import { resolve as resolve3 } from "path";
 var VITE_CONFIG_PATH = resolve3(PACKAGE_ROOT, "app/vite.config.js");
 async function startDevFrontend(apiPort, devPort) {
@@ -6901,7 +7448,7 @@ async function startDevFrontend(apiPort, devPort) {
   }
 }
 
-// src/runtime/run-local.ts
+// src/agent/run-local.ts
 function usage() {
   console.log(
     `Usage: ${argv3[1]} [options]
@@ -6915,6 +7462,10 @@ Options:
   --timeout <ms>         Agent command timeout in ms (default: 1800000)
   --dev                   Start Vite dev server alongside API (HMR on port+1)
   --once                  Process once and exit
+  --skip-source           Skip source snapshot copy
+  --skip-scan             Skip project analysis
+  --skip-recovery         Skip orphaned agent recovery
+  --fast-boot             Equivalent to --skip-source --skip-scan --skip-recovery
 `
   );
 }
@@ -6930,6 +7481,8 @@ async function main() {
   }
   mkdirSync5(STATE_ROOT, { recursive: true });
   initLogger(STATE_ROOT);
+  logger.info("[Boot] Fifony runtime starting");
+  logger.info({ stateRoot: STATE_ROOT, cwd: process.cwd() }, "[Boot] State root initialized");
   const detectedProviders = detectAvailableProviders();
   for (const p of detectedProviders) {
     logger.info(`Provider ${p.name}: ${p.available ? `available at ${p.path}` : "not found"}`);
@@ -6937,8 +7490,13 @@ async function main() {
   const interfaceMode = (env10.FIFONY_INTERFACE ?? "cli").trim().toLowerCase();
   const runOnce = args.includes("--once");
   const devMode = args.includes("--dev") || env10.NODE_ENV === "development";
+  const fastBoot = args.includes("--fast-boot");
+  const skipSource = fastBoot || args.includes("--skip-source");
+  if (skipSource) setSkipSource(true);
   debugBoot("main:state-root-ready");
+  logger.debug("[Boot] Loading workflow definition");
   const workflowDefinition = loadWorkflowDefinition();
+  logger.info({ workflowPath: workflowDefinition.workflowPath }, "[Boot] Workflow definition loaded");
   debugBoot("main:workflow-loaded");
   const port = parsePort(args);
   let config = applyWorkflowConfig(deriveConfig(args), workflowDefinition, port);
@@ -6953,14 +7511,44 @@ async function main() {
     }
   }
   const dashboardPort = port ?? (config.dashboardPort ? Number.parseInt(config.dashboardPort, 10) : void 0);
-  bootstrapSource();
-  debugBoot("main:source-bootstrapped");
+  const skipRecovery = args.includes("--skip-recovery") || args.includes("--fast-boot");
+  debugBoot("main:phase-b-start");
+  logger.debug("[Boot] Initializing state store (s3db)");
   await initStateStore();
+  logger.info("[Boot] State store initialized");
   debugBoot("main:store-initialized");
-  await persistDetectedProvidersSetting(detectedProviders);
-  await recoverPlanningSession();
-  const previous = await loadPersistedState();
-  const persistedSettings = await loadRuntimeSettings();
+  const earlyState = {
+    startedAt: now(),
+    updatedAt: now(),
+    trackerKind: "filesystem",
+    sourceRepoUrl: "",
+    sourceRef: "workspace",
+    workflowPath: "",
+    config,
+    issues: [],
+    events: [],
+    metrics: { total: 0, queued: 0, inProgress: 0, blocked: 0, done: 0, cancelled: 0, activeWorkers: 0 },
+    notes: [],
+    booting: true
+  };
+  let apiState = earlyState;
+  if (dashboardPort) {
+    await startApiServer(apiState, dashboardPort, workflowDefinition);
+    debugBoot("main:api-server-early-start");
+    if (devMode) {
+      const devPort = dashboardPort + 1;
+      await startDevFrontend(dashboardPort, devPort);
+    }
+  }
+  debugBoot("main:phase-c-start");
+  logger.debug("[Boot] Loading persisted state, settings, and recovering sessions");
+  const [previous, persistedSettings] = await Promise.all([
+    loadPersistedState(),
+    loadRuntimeSettings(),
+    persistDetectedProvidersSetting(detectedProviders),
+    recoverPlanningSession()
+  ]);
+  logger.info({ hadPreviousState: previous !== null, issueCount: previous?.issues?.length ?? 0, settingsCount: persistedSettings.length }, "[Boot] State loaded from persistence");
   debugBoot("main:state-loaded");
   config = applyPersistedSettings(config, persistedSettings);
   await syncRuntimeConfigSettings(config, persistedSettings);
@@ -6969,6 +7557,7 @@ async function main() {
   state.config.dashboardPort = dashboardPort ? String(dashboardPort) : void 0;
   state.workflowPath = WORKFLOW_RENDERED;
   state.updatedAt = now();
+  state.booting = false;
   if (state.config.agentCommand) {
     state.notes.push(`Using agent command: ${state.config.agentCommand}`);
   }
@@ -6998,25 +7587,32 @@ async function main() {
       logger.info("Background workspace cleanup complete.");
     });
   }
-  for (const issue of state.issues) {
-    if (issue.state === "Running" || issue.state === "Interrupted" || issue.state === "Queued") {
-      const { alive, pid } = isAgentStillRunning(issue);
-      if (alive && pid) {
-        logger.info(`Agent for ${issue.identifier} still alive (PID ${pid.pid}), keeping state as Running.`);
-        issue.state = "Running";
-        addEvent(state, issue.id, "info", `Orphaned agent detected (PID ${pid.pid}), still alive \u2014 tracking resumed.`);
-      } else {
-        if (issue.workspacePath) cleanStalePidFile(issue.workspacePath);
-        if (issue.state === "Running") {
-          issue.state = "Interrupted";
-          issue.history.push(`[${now()}] Agent process not found on boot \u2014 marked Interrupted.`);
-          addEvent(state, issue.id, "info", `Agent for ${issue.identifier} not found, marked Interrupted.`);
+  if (!skipRecovery) {
+    logger.debug({ issueCount: state.issues.filter((i) => i.state === "Running" || i.state === "Interrupted" || i.state === "Queued").length }, "[Boot] Checking for orphaned agent processes");
+    for (const issue of state.issues) {
+      if (issue.state === "Running" || issue.state === "Interrupted" || issue.state === "Queued") {
+        const { alive, pid } = isAgentStillRunning(issue);
+        if (alive && pid) {
+          logger.info(`Agent for ${issue.identifier} still alive (PID ${pid.pid}), keeping state as Running.`);
+          issue.state = "Running";
+          addEvent(state, issue.id, "info", `Orphaned agent detected (PID ${pid.pid}), still alive \u2014 tracking resumed.`);
+        } else {
+          if (issue.workspacePath) cleanStalePidFile(issue.workspacePath);
+          if (issue.state === "Running") {
+            issue.state = "Interrupted";
+            issue.history.push(`[${now()}] Agent process not found on boot \u2014 marked Interrupted.`);
+            addEvent(state, issue.id, "info", `Agent for ${issue.identifier} not found, marked Interrupted.`);
+          }
         }
       }
     }
   }
   state.metrics = computeMetrics(state.issues);
-  await persistState(state);
+  await persistStateFull(state);
+  if (dashboardPort) {
+    Object.assign(apiState, state);
+    debugBoot("main:api-state-swapped");
+  }
   const running = /* @__PURE__ */ new Set();
   installGracefulShutdown(state, running);
   logger.info(`Rendered local workflow: ${WORKFLOW_RENDERED}`);
@@ -7027,16 +7623,10 @@ async function main() {
   logger.info(`Max turns: ${state.config.maxTurns}`);
   logger.info(`Agent provider: ${state.config.agentProvider}`);
   logger.info(`Interface mode: ${interfaceMode}`);
-  if (dashboardPort) {
-    await startApiServer(state, dashboardPort, workflowDefinition);
-    if (devMode) {
-      const devPort = dashboardPort + 1;
-      await startDevFrontend(dashboardPort, devPort);
-    }
-  }
   try {
     addEvent(state, void 0, "info", `Runtime started in local-only mode (filesystem tracker).`);
     const runForever = !runOnce && (Boolean(dashboardPort) || interfaceMode === "mcp");
+    logger.info({ runForever, runOnce, dashboardPort, interfaceMode }, "[Boot] Entering scheduler loop");
     await scheduler(state, running, runForever, workflowDefinition);
   } catch (error) {
     console.error("FATAL STACK TRACE:", error);
@@ -7046,7 +7636,7 @@ async function main() {
   } finally {
     state.updatedAt = now();
     state.metrics = computeMetrics(state.issues);
-    await persistState(state);
+    await persistStateFull(state);
     await closeStateStore();
   }
 }