fifony 0.1.14-next.6f02449 → 0.1.14-next.f20a2d1

package/app/dist/service-worker.js

@@ -1,4 +1,4 @@
-const CACHE_VERSION = "1773754620530";
+const CACHE_VERSION = "1773755105602";
 const CORE_CACHE = `fifony-core-${CACHE_VERSION}`;
 const ASSET_CACHE = `fifony-assets-${CACHE_VERSION}`;
 const APP_SHELL_ROUTES = ["/kanban", "/issues", "/agents", "/providers", "/settings"];

package/dist/runtime/run-local.js

@@ -1147,6 +1147,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);
@@ -1426,6 +1427,7 @@ 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);
@@ -2683,13 +2685,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;
@@ -3194,6 +3205,7 @@ async function runCommandWithTimeout(command, workspacePath, issue, config, prom
     const pidFile = join8(workspacePath, "fifony-agent.pid");
     const pid = child.pid;
     if (pid) {
+      logger.debug({ issueId: issue.id, pid, command: command.slice(0, 120), cwd: workspacePath }, "[Agent] Process spawned");
       writeFileSync3(pidFile, JSON.stringify({
         pid,
         issueId: issue.id,
@@ -3303,6 +3315,7 @@ async function prepareWorkspace(issue, workflowDefinition) {
   const workspaceRoot = join8(WORKSPACE_ROOT, safeId);
   const createdNow = !existsSync5(workspaceRoot);
   if (createdNow) {
+    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");
@@ -3314,6 +3327,9 @@ async function prepareWorkspace(issue, workflowDefinition) {
         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 = join8(workspaceRoot, "fifony-issue.json");
   const promptText = await buildPrompt(issue, workflowDefinition);
@@ -3338,6 +3354,7 @@ async function runAgentSession(state, issue, provider, cycle, workspacePath, bas
   let lastOutput = session.lastOutput;
   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;
@@ -3357,6 +3374,7 @@ Agent requested additional turns beyond configured limit (${maxTurns}).`, state.
   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,
@@ -3389,6 +3407,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;
@@ -3434,20 +3453,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 };
@@ -3455,6 +3478,7 @@ 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");
@@ -3527,6 +3551,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();
@@ -3704,6 +3729,8 @@ 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);
@@ -4475,6 +4502,7 @@ 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)) {
+      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;
@@ -4493,7 +4521,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;
@@ -4545,9 +4577,12 @@ 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();
@@ -4556,7 +4591,7 @@ async function scheduler(state, running, runForever, workflowDefinition) {
         await persistState(state);
         lastPersistAt = Date.now();
       }
-      logger.debug("Scheduler tick completed.");
+      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),
@@ -4581,11 +4616,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);
@@ -5054,6 +5094,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;
@@ -5074,6 +5115,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,
@@ -5158,13 +5200,14 @@ 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) {
     session.status = "error";
     session.error = `Could not parse plan. Output: ${output.slice(0, 500)}`;
     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) }, "[Planner] Could not parse plan from AI output");
     throw new Error(session.error);
   }
   plan.provider = planStageModel ? `${preferred}/${planStageModel}` : preferred;
@@ -6061,6 +6104,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();
@@ -6108,6 +6152,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.");
@@ -6455,6 +6500,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) {
@@ -6482,6 +6528,7 @@ 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);
@@ -6531,6 +6578,7 @@ 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();
@@ -6540,6 +6588,7 @@ async function startApiServer(state, port, workflowDefinition) {
         }
       },
       "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.");
@@ -6552,6 +6601,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}.`);
@@ -6577,6 +6627,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.`);
@@ -6586,6 +6637,7 @@ 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);
@@ -7074,7 +7126,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") {
@@ -7124,6 +7180,11 @@ async function persistState(state) {
   };
   if (!runtimeStateResource) return;
   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,
@@ -7195,6 +7256,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 {
@@ -7320,6 +7382,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"}`);
@@ -7331,7 +7395,9 @@ async function main() {
   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);
@@ -7348,7 +7414,9 @@ async function main() {
   const dashboardPort = port ?? (config.dashboardPort ? Number.parseInt(config.dashboardPort, 10) : void 0);
   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");
   const earlyState = {
     startedAt: now(),
@@ -7374,12 +7442,14 @@ async function main() {
     }
   }
   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);
@@ -7419,6 +7489,7 @@ async function main() {
     });
   }
   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);
@@ -7456,6 +7527,7 @@ async function main() {
   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);