fifony 0.1.13 → 0.1.14-next.6f02449

package/dist/runtime/run-local.js

@@ -86,6 +86,10 @@ 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
 import { env as env2 } from "process";
@@ -296,7 +300,7 @@ var logger = {
 };
 
 // src/runtime/store.ts
-import { mkdirSync as mkdirSync3 } from "fs";
+import { mkdirSync as mkdirSync4 } from "fs";
 
 // src/runtime/issues.ts
 import { env as env4 } from "process";
@@ -463,6 +467,50 @@ function getAnalytics(topN = 20) {
   };
 }
 
+// src/runtime/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/runtime/metrics-cache.ts
+var cachedMetrics = null;
+var metricsStale = true;
+function invalidateMetrics() {
+  metricsStale = true;
+}
+function getMetrics(issues) {
+  if (!metricsStale && cachedMetrics) return cachedMetrics;
+  cachedMetrics = computeMetrics2(issues);
+  metricsStale = false;
+  return cachedMetrics;
+}
+
 // src/runtime/issue-state-machine.ts
 var ISSUE_STATE_MACHINE_ID = "issue-lifecycle";
 var ISSUE_STATE_MACHINE_DEFINITION = {
@@ -720,7 +768,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 +784,8 @@ function detectAvailableProviders() {
       providers.push({ name, available: false, path: "" });
     }
   }
+  cachedProviders = providers;
+  providersCachedAt = Date.now();
   return providers;
 }
 var modelCache = /* @__PURE__ */ new Map();
@@ -1257,7 +1313,7 @@ function buildRuntimeState(previous, config, definition) {
     }
   }
   dedupHistoryEntries(mergedIssues);
-  const metrics = computeMetrics(mergedIssues);
+  const metrics = computeMetrics2(mergedIssues);
   return {
     startedAt: previous?.startedAt ?? now(),
     updatedAt: now(),
@@ -1280,7 +1336,7 @@ function buildRuntimeState(previous, config, definition) {
     ]
   };
 }
-function computeMetrics(issues) {
+function computeMetrics2(issues) {
   let queued = 0;
   let inProgress = 0;
   let blocked = 0;
@@ -1361,6 +1417,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 {
@@ -1371,6 +1428,8 @@ function transition(issue, target, note) {
   const previous = issue.state;
   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;
@@ -1519,12 +1578,14 @@ function getApiRuntimeContextOrThrow() {
 // src/runtime/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
@@ -1552,16 +1613,16 @@ var runtime_state_resource_default = {
 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
@@ -1608,9 +1669,141 @@ ${skill.content}`
 ${sections.join("\n\n")}`;
 }
 
+// src/runtime/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/runtime/adapters/index.ts
-import { writeFileSync } from "fs";
-import { join as join6 } from "path";
+import { writeFileSync as writeFileSync2 } from "fs";
+import { join as join7 } from "path";
 
 // src/runtime/adapters/shared.ts
 function buildPlanContextSection(plan) {
@@ -1862,7 +2055,7 @@ async function compileForClaude(issue, provider, plan, config, workspacePath, sk
 }
 
 // src/runtime/adapters/plan-to-codex.ts
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 var CODEX_RESULT_CONTRACT = `
 Return a JSON object with this exact schema when finished:
 {
@@ -1899,7 +2092,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
@@ -1987,8 +2180,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 +2203,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 +2214,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"
     );
@@ -2412,7 +2605,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 +2624,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 +2643,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 +2663,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 +2673,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 {
     }
   }
@@ -2522,33 +2715,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 +2750,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 +2779,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 +2806,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 +2825,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 +2844,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 +3169,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 +3191,10 @@ 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({
+      writeFileSync3(pidFile, JSON.stringify({
         pid,
         issueId: issue.id,
         startedAt: new Date(started).toISOString(),
@@ -3011,8 +3204,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 +3270,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 +3281,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,13 +3300,14 @@ 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 });
+    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,
@@ -3121,11 +3315,11 @@ async function prepareWorkspace(issue, workflowDefinition) {
       });
     }
   }
-  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,7 +3336,7 @@ 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) {
     return { success: true, blocked: false, continueRequested: false, code: session.lastCode, output: session.lastOutput, turns: session.turns.length };
   }
@@ -3155,8 +3349,8 @@ 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;
@@ -3267,7 +3461,7 @@ async function runAgentPipeline(state, issue, workspacePath, basePromptText, bas
   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 +3477,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);
@@ -3393,8 +3587,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);
@@ -3511,9 +3705,10 @@ async function runIssueOnce(state, issue, running, workflowDefinition) {
     }
   } finally {
     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);
+    state.metrics = computeMetrics2(state.issues);
     state.metrics.activeWorkers = Math.max(state.metrics.activeWorkers, 0);
     state.updatedAt = now();
     await persistState(state);
@@ -3863,43 +4058,43 @@ var NATIVE_RESOURCE_NAMES = NATIVE_RESOURCE_CONFIGS.map((resource) => resource.n
 
 // src/runtime/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 +4131,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 +4153,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 +4223,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 +4264,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 +4279,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 {
@@ -4179,6 +4374,14 @@ function collectProvidersUsage() {
 
 // src/runtime/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) {
@@ -4197,7 +4400,7 @@ function installGracefulShutdown(state, running) {
       }
     }
     state.updatedAt = now();
-    state.metrics = computeMetrics(state.issues);
+    state.metrics = computeMetrics2(state.issues);
     try {
       await persistState(state);
       logger.info("State persisted.");
@@ -4275,6 +4478,7 @@ async function ensureNotStale(state, staleTimeoutMs) {
       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.`);
     }
   }
@@ -4347,9 +4551,20 @@ async function scheduler(state, running, runForever, workflowDefinition) {
         }
       }
       state.updatedAt = now();
-      await persistState(state);
+      const shouldPersist = hasDirtyState() || Date.now() - lastPersistAt > PERSIST_DEBOUNCE_MS;
+      if (shouldPersist) {
+        await persistState(state);
+        lastPersistAt = Date.now();
+      }
       logger.debug("Scheduler tick completed.");
-      await sleep(state.config.pollIntervalMs);
+      const effectivePoll = running.size > 0 ? ACTIVE_POLL_MS : IDLE_POLL_MS;
+      await Promise.race([
+        sleep(effectivePoll),
+        new Promise((resolve4) => {
+          schedulerWakeResolve = resolve4;
+        })
+      ]);
+      schedulerWakeResolve = null;
     }
     return;
   }
@@ -4381,11 +4596,11 @@ 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";
+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 +4670,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 +4697,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}`;
@@ -4587,9 +4802,9 @@ async function enhanceIssueField(payload, config, workflowDefinition) {
 }
 
 // src/runtime/issue-planner.ts
-import { mkdtempSync as mkdtempSync2, writeFileSync as writeFileSync4, rmSync as rmSync3 } from "fs";
+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() {
@@ -4876,12 +5091,12 @@ 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");
+  const envFile = join11(tempDir, "fifony-plan-env.sh");
+  writeFileSync5(promptFile, `${prompt}
 `, "utf8");
-  writeFileSync4(envFile, [
+  writeFileSync5(envFile, [
     `export FIFONY_PROMPT_FILE=${JSON.stringify(promptFile)}`,
     `export FIFONY_AGENT_PROVIDER=${JSON.stringify(preferred)}`
   ].join("\n"), "utf8");
@@ -5013,12 +5228,12 @@ 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");
+  const envFile = join11(tempDir, "fifony-refine-env.sh");
+  writeFileSync5(promptFile, `${prompt}
 `, "utf8");
-  writeFileSync4(envFile, [
+  writeFileSync5(envFile, [
     `export FIFONY_PROMPT_FILE=${JSON.stringify(promptFile)}`,
     `export FIFONY_AGENT_PROVIDER=${JSON.stringify(preferred)}`
   ].join("\n"), "utf8");
@@ -5158,19 +5373,20 @@ function refinePlanInBackground(issue, feedback, config, workflowDefinition, cal
 
 // src/runtime/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 +5408,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 +5422,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 +5436,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 +5491,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 +5536,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 +5604,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 +5659,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 +5733,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 +5755,180 @@ async function analyzeProjectWithCli(provider, targetRoot) {
   }
 }
 
+// src/runtime/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/runtime/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/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";
+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 +5938,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 +5957,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 +5971,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 +5992,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 +6006,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 +6027,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");
@@ -5628,6 +6042,7 @@ function installSkills(targetRoot, skillNames, catalog) {
 }
 
 // src/runtime/api-server.ts
+import { join as join14 } from "path";
 var wsClients = /* @__PURE__ */ new Map();
 var broadcastSeq = 0;
 var lastBroadcastIssueSnapshot = /* @__PURE__ */ new Map();
@@ -5767,6 +6182,7 @@ async function startApiServer(state, port, workflowDefinition) {
     }
     await updater(issue);
     await persistState(state);
+    wakeScheduler();
     return c.json({ ok: true, issue });
   };
   const resourceConfigs = Object.fromEntries(
@@ -5787,10 +6203,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 +6214,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",
@@ -5830,7 +6246,7 @@ async function startApiServer(state, port, workflowDefinition) {
                 type: "connected",
                 seq: broadcastSeq,
                 timestamp: now(),
-                metrics: computeMetrics(state.issues),
+                metrics: computeMetrics2(state.issues),
                 capabilities: computeCapabilityCounts(state.issues),
                 issues: state.issues,
                 events: state.events.slice(0, 50)
@@ -5883,12 +6299,14 @@ async function startApiServer(state, port, workflowDefinition) {
       "GET /icon-maskable.svg": () => serveTextFile(FRONTEND_MASKABLE_ICON_SVG, "image/svg+xml", "public, max-age=604800, immutable"),
       "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;
@@ -5907,7 +6325,7 @@ async function startApiServer(state, port, workflowDefinition) {
           ...state,
           issues,
           capabilities: computeCapabilityCounts(issues),
-          metrics: computeMetrics(issues),
+          metrics: computeMetrics2(issues),
           _filter: showAll ? "all" : "recent",
           _totalIssues: state.issues.length
         });
@@ -6066,11 +6484,13 @@ async function startApiServer(state, port, workflowDefinition) {
           const payload = await c.req.json();
           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);
@@ -6113,6 +6533,7 @@ async function startApiServer(state, port, workflowDefinition) {
           const payload = await c.req.json();
           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);
@@ -6171,7 +6592,7 @@ 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: false, error: "No workspace found for this issue." }, 400);
           }
           const result = mergeWorkspace(wp);
@@ -6239,10 +6660,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 +6700,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 +6769,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 +6830,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) : [];
@@ -6495,7 +6980,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,
@@ -6634,20 +7119,25 @@ 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();
+  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 +7152,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 +7171,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 {
@@ -6750,119 +7249,6 @@ 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
 import { resolve as resolve3 } from "path";
 var VITE_CONFIG_PATH = resolve3(PACKAGE_ROOT, "app/vite.config.js");
@@ -6915,6 +7301,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
 `
   );
 }
@@ -6937,6 +7327,9 @@ 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");
   const workflowDefinition = loadWorkflowDefinition();
   debugBoot("main:workflow-loaded");
@@ -6953,14 +7346,40 @@ 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");
   await initStateStore();
   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");
+  const [previous, persistedSettings] = await Promise.all([
+    loadPersistedState(),
+    loadRuntimeSettings(),
+    persistDetectedProvidersSetting(detectedProviders),
+    recoverPlanningSession()
+  ]);
   debugBoot("main:state-loaded");
   config = applyPersistedSettings(config, persistedSettings);
   await syncRuntimeConfigSettings(config, persistedSettings);
@@ -6969,6 +7388,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 +7418,31 @@ 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) {
+    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);
+  state.metrics = computeMetrics2(state.issues);
+  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,13 +7453,6 @@ 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");
@@ -7045,8 +7464,8 @@ async function main() {
     throw error;
   } finally {
     state.updatedAt = now();
-    state.metrics = computeMetrics(state.issues);
-    await persistState(state);
+    state.metrics = computeMetrics2(state.issues);
+    await persistStateFull(state);
     await closeStateStore();
   }
 }