openfox 2.0.113 → 2.0.114

package/dist/{chunk-HGOTZWON.js → chunk-7GWARYQC.js}

@@ -2,46 +2,37 @@ import {
   generateSessionNameForSession,
   getSessionMessageCount,
   needsNameGeneration
-} from "./chunk-3R43CMLS.js";
+} from "./chunk-NWJLWLKF.js";
+import {
+  launchWorkflowRun
+} from "./chunk-W77NBJAZ.js";
 import {
-  runAgentTurn,
   runChatTurn
-} from "./chunk-YGPPFVLJ.js";
+} from "./chunk-FW4NDUBL.js";
+import {
+  devServerManager
+} from "./chunk-K733B5T2.js";
 import {
   applyDynamicContext,
   computeSessionHash,
   computeUnifiedDiff
-} from "./chunk-O2YSYW2F.js";
+} from "./chunk-GUHHUDNL.js";
 import {
   appendCompactionPrompt
-} from "./chunk-EMI3YYLP.js";
-import {
-  devServerManager,
-  executeSubAgent,
-  getToolRegistryForAgent
-} from "./chunk-5VYSKVZT.js";
+} from "./chunk-VPVLO436.js";
 import {
-  TurnMetrics,
-  createMessageStartEvent
-} from "./chunk-JR54MDZI.js";
+  onProcessEvent
+} from "./chunk-TKKP56QK.js";
 import {
-  checkAborted,
-  decodeUtf8,
-  onProcessEvent,
-  spawnShellProcess
-} from "./chunk-EC5T5A6O.js";
-import {
-  killProcessTree,
-  terminateProcessTree
+  killProcessTree
 } from "./chunk-I72ACQ6R.js";
 import {
   gitSpawnEnv
 } from "./chunk-J7GAZGZT.js";
 import {
   combineEventsWithSnapshot,
-  getCurrentContextWindowId,
   getEventStore
-} from "./chunk-CP44U7BT.js";
+} from "./chunk-JXLRL5JR.js";
 import {
   createChatErrorMessage,
   createChatMessageMessage,
@@ -56,10 +47,10 @@ import {
   parseClientMessage,
   serializeServerMessage,
   storedEventToServerMessage
-} from "./chunk-4NMGX5F2.js";
+} from "./chunk-I7FY2LTR.js";
 import {
   getPlatformShell
-} from "./chunk-BNFGDTEU.js";
+} from "./chunk-SA34STZ6.js";
 import {
   getPendingQuestionsForSession,
   provideAnswer
@@ -67,35 +58,23 @@ import {
 import {
   buildMessagesFromStoredEvents,
   foldPendingConfirmations
-} from "./chunk-YB6WYVNY.js";
+} from "./chunk-UTIQ7OO5.js";
 import {
-  deleteItemFromDir,
-  findAgentById,
-  getRuntimeConfig,
-  jsonSerializer,
-  loadAllAgentsDefault,
-  resolveDefaultAgentId,
-  saveItemToDir
-} from "./chunk-BYSUSSSC.js";
+  getRuntimeConfig
+} from "./chunk-UPBWEHIL.js";
 import {
   getMaxVisibleItems
-} from "./chunk-WWTYWLDM.js";
+} from "./chunk-HP5CIB66.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
-import {
-  computeSessionStats
-} from "./chunk-VUQCQXXJ.js";
 import {
   createServerMessage
-} from "./chunk-BKCW3JLL.js";
-import {
-  getGlobalConfigDir
-} from "./chunk-CQGTEGKL.js";
+} from "./chunk-X25Q6RAV.js";
 
 // src/server/ws/server.ts
 import { WebSocketServer, WebSocket as WebSocket2 } from "ws";
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { createHash as createHash2 } from "crypto";
 
 // src/server/ws/terminal.ts
@@ -351,943 +330,17 @@ function unsubscribeAllFromTerminal(ws) {
   }
 }
 
-// src/server/workflows/registry.ts
-import { readdir, readFile, writeFile, mkdir, access, unlink } from "fs/promises";
-import { join, dirname } from "path";
-import { constants } from "fs";
-import { fileURLToPath } from "url";
-var __bundleDir = dirname(fileURLToPath(import.meta.url));
-var DEFAULTS_DIR = join(__bundleDir, "defaults");
-var DEFAULTS_DIR_ALT = join(__bundleDir, "workflow-defaults");
-var WORKFLOW_EXTENSION = ".workflow.json";
-function normalizeWorkflowScope(value) {
-  return typeof value === "string" && (value === "builtin" || value === "user" || value === "project" || value === "auto") ? value : "auto";
-}
-function getWorkflowsDir(configDir) {
-  return join(configDir, "workflows");
-}
-function getProjectWorkflowsDir(projectDir) {
-  return join(projectDir, ".openfox", "workflows");
-}
-async function pathExists(path) {
-  try {
-    await access(path, constants.R_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function loadWorkflowsFromDir(dir) {
-  if (!await pathExists(dir)) {
-    return [];
-  }
-  let files;
-  try {
-    files = (await readdir(dir)).filter((f) => f.endsWith(WORKFLOW_EXTENSION));
-  } catch {
-    return [];
-  }
-  const workflows = [];
-  for (const file of files) {
-    try {
-      const raw = await readFile(join(dir, file), "utf-8");
-      const parsed = JSON.parse(raw);
-      if (parsed.metadata?.id && parsed.steps?.length > 0) {
-        workflows.push(parsed);
-      } else {
-        logger.warn("Skipping invalid workflow file", { file });
-      }
-    } catch (err) {
-      logger.warn("Failed to parse workflow file", { file, error: err instanceof Error ? err.message : String(err) });
-    }
-  }
-  return workflows;
-}
-async function loadDefaultWorkflows() {
-  let defaults = await loadWorkflowsFromDir(DEFAULTS_DIR);
-  if (!defaults.length) {
-    defaults = await loadWorkflowsFromDir(DEFAULTS_DIR_ALT);
-  }
-  return defaults;
-}
-async function loadUserWorkflows(configDir) {
-  return loadWorkflowsFromDir(getWorkflowsDir(configDir));
-}
-async function loadProjectWorkflows(projectDir) {
-  return loadWorkflowsFromDir(getProjectWorkflowsDir(projectDir));
-}
-async function loadAllWorkflows(configDir, projectDir) {
-  const [defaultWorkflows, userWorkflows] = await Promise.all([loadDefaultWorkflows(), loadUserWorkflows(configDir)]);
-  const workflowMap = /* @__PURE__ */ new Map();
-  for (const workflow of defaultWorkflows) {
-    workflowMap.set(workflow.metadata.id, workflow);
-  }
-  for (const workflow of userWorkflows) {
-    workflowMap.set(workflow.metadata.id, workflow);
-  }
-  if (projectDir) {
-    const projectWorkflows = await loadProjectWorkflows(projectDir);
-    for (const workflow of projectWorkflows) {
-      workflowMap.set(workflow.metadata.id, workflow);
-    }
-  }
-  return Array.from(workflowMap.values());
-}
-async function saveWorkflowToProject(projectDir, workflow) {
-  await saveItemToDir(getProjectWorkflowsDir(projectDir), workflow, WORKFLOW_EXTENSION, jsonSerializer);
-}
-async function deleteProjectWorkflow(projectDir, workflowId) {
-  return deleteItemFromDir(getProjectWorkflowsDir(projectDir), workflowId, WORKFLOW_EXTENSION);
-}
-async function getDefaultWorkflowIds() {
-  for (const dir of [DEFAULTS_DIR, DEFAULTS_DIR_ALT]) {
-    try {
-      const files = (await readdir(dir)).filter((f) => f.endsWith(WORKFLOW_EXTENSION));
-      return files.map((f) => f.replace(WORKFLOW_EXTENSION, ""));
-    } catch {
-    }
-  }
-  return [];
-}
-async function isDefaultWorkflow(workflowId) {
-  const defaultIds = await getDefaultWorkflowIds();
-  return defaultIds.includes(workflowId);
-}
-function findWorkflowById(workflowId, workflows) {
-  return workflows.find((p) => p.metadata.id === workflowId);
-}
-async function workflowExists(configDir, workflowId, projectDir) {
-  if (await pathExists(join(getWorkflowsDir(configDir), `${workflowId}${WORKFLOW_EXTENSION}`))) return true;
-  if (projectDir && await pathExists(join(getProjectWorkflowsDir(projectDir), `${workflowId}${WORKFLOW_EXTENSION}`)))
-    return true;
-  return false;
-}
-async function saveWorkflow(configDir, workflow) {
-  const workflowsDir = getWorkflowsDir(configDir);
-  if (!await pathExists(workflowsDir)) {
-    await mkdir(workflowsDir, { recursive: true });
-  }
-  const filePath = join(workflowsDir, `${workflow.metadata.id}${WORKFLOW_EXTENSION}`);
-  await writeFile(filePath, JSON.stringify(workflow, null, 2) + "\n", "utf-8");
-}
-async function deleteWorkflow(configDir, workflowId) {
-  const isDefault = await isDefaultWorkflow(workflowId);
-  if (isDefault) {
-    return { success: false, reason: "Cannot delete built-in defaults" };
-  }
-  const filePath = join(getWorkflowsDir(configDir), `${workflowId}${WORKFLOW_EXTENSION}`);
-  try {
-    await unlink(filePath);
-    return { success: true };
-  } catch {
-    return { success: false };
-  }
-}
-
-// src/server/workflows/types.ts
-var TERMINAL_DONE = "$done";
-var TERMINAL_BLOCKED = "$blocked";
-
-// src/server/git/diff.ts
-import { spawn as spawn2 } from "child_process";
-function getGitDiffFiles(cwd) {
-  return new Promise((resolve) => {
-    const env = gitSpawnEnv();
-    const diffProc = spawn2("git", ["diff", "--name-status", "HEAD"], {
-      cwd,
-      env,
-      stdio: ["ignore", "pipe", "pipe"],
-      windowsHide: true
-    });
-    const statusProc = spawn2("git", ["status", "--porcelain"], {
-      cwd,
-      env,
-      stdio: ["ignore", "pipe", "pipe"],
-      windowsHide: true
-    });
-    let diffStdout = "";
-    let statusStdout = "";
-    let diffExited = false;
-    let statusExited = false;
-    let diffCode = null;
-    let statusCode = null;
-    const collect = () => {
-      if (!diffExited || !statusExited) return;
-      const files = [];
-      if (diffCode === 0) {
-        for (const line of diffStdout.split("\n")) {
-          if (!line.trim()) continue;
-          const [statusChar, ...pathParts] = line.split("	");
-          const path = pathParts.join("	") || statusChar || "";
-          if (!path) continue;
-          const status = statusChar === "A" ? "added" : statusChar === "D" ? "deleted" : "modified";
-          files.push({ path, status, additions: 0, deletions: 0 });
-        }
-      }
-      if (statusCode === 0) {
-        for (const line of statusStdout.split("\n")) {
-          if (!line.startsWith("?? ")) continue;
-          const path = line.slice(3).trim();
-          if (!path) continue;
-          files.push({ path, status: "added", additions: 0, deletions: 0 });
-        }
-      }
-      resolve(files);
-    };
-    diffProc.stdout.on("data", (data) => {
-      diffStdout += data.toString();
-    });
-    statusProc.stdout.on("data", (data) => {
-      statusStdout += data.toString();
-    });
-    diffProc.on("close", (code) => {
-      diffExited = true;
-      diffCode = code;
-      collect();
-    });
-    statusProc.on("close", (code) => {
-      statusExited = true;
-      statusCode = code;
-      collect();
-    });
-    diffProc.on("error", () => {
-      diffExited = true;
-      diffCode = 1;
-      collect();
-    });
-    statusProc.on("error", () => {
-      statusExited = true;
-      statusCode = 1;
-      collect();
-    });
-  });
-}
-async function formatGitDiffFiles(cwd) {
-  const files = await getGitDiffFiles(cwd);
-  if (files.length === 0) return "(none)";
-  return files.map((f) => `- ${f.path} (${f.status})`).join("\n");
-}
-
-// src/server/workflows/shell.ts
-function executeShellCommand(command, cwd, timeout, signal) {
-  return new Promise((resolve, reject) => {
-    if (checkAborted(signal)) {
-      reject(new Error("Aborted"));
-      return;
-    }
-    const proc = spawnShellProcess(command, cwd, signal);
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    let killed = false;
-    const timer = setTimeout(() => {
-      killed = true;
-      void terminateProcessTree(proc);
-      resolve({
-        exitCode: 1,
-        stdout: decodeUtf8(stdoutChunks),
-        stderr: decodeUtf8(stderrChunks) + "\nCommand timed out",
-        success: false
-      });
-    }, timeout);
-    const onAbort = () => {
-      if (!killed) {
-        killed = true;
-        void terminateProcessTree(proc, { immediate: true });
-        clearTimeout(timer);
-        reject(new Error("Aborted"));
-      }
-    };
-    signal?.addEventListener("abort", onAbort);
-    proc.stdout?.on("data", (data) => {
-      stdoutChunks.push(data);
-    });
-    proc.stderr?.on("data", (data) => {
-      stderrChunks.push(data);
-    });
-    proc.on("close", (code) => {
-      clearTimeout(timer);
-      signal?.removeEventListener("abort", onAbort);
-      if (killed) return;
-      const exitCode = code ?? 1;
-      resolve({
-        exitCode,
-        stdout: decodeUtf8(stdoutChunks),
-        stderr: decodeUtf8(stderrChunks),
-        success: exitCode === 0
-      });
-    });
-    proc.on("error", (err) => {
-      clearTimeout(timer);
-      signal?.removeEventListener("abort", onAbort);
-      if (killed) return;
-      resolve({ exitCode: 1, stdout: decodeUtf8(stdoutChunks), stderr: err.message, success: false });
-    });
-  });
-}
-
-// src/server/workflows/executor.ts
-var TEMPLATE_VARIABLES = [
-  { name: "workdir", description: "Working directory of the session" },
-  { name: "reason", description: 'Human-readable reason (e.g. "2 criteria remaining")' },
-  {
-    name: "stepOutput",
-    description: "Structured output from the previous step (content, stdout, stderr, exitCode, etc.)"
-  },
-  {
-    name: "verifierFindings",
-    description: "@deprecated Use stepOutput.content instead. Output from the last sub-agent step"
-  },
-  {
-    name: "previousStepOutput",
-    description: "@deprecated Use stepOutput.stdout instead. Output from the last shell step"
-  },
-  { name: "criteriaCount", description: "Total number of criteria" },
-  { name: "pendingCount", description: "Number of pending/failed criteria" },
-  { name: "criteriaList", description: "Formatted list of all criteria with status" },
-  { name: "modifiedFiles", description: "List of modified files" }
-];
-function formatCriteriaList(entries) {
-  if (entries.length === 0) return "(none)";
-  return entries.map((e) => {
-    const status = e.status === "passed" ? "[PASSED]" : e.status === "completed" ? "[NEEDS VERIFICATION]" : e.status === "failed" ? "[FAILED]" : "[NOT COMPLETED]";
-    return `- **${e.id}** ${status}: ${e.description}`;
-  }).join("\n");
-}
-async function formatModifiedFiles(workdir) {
-  return formatGitDiffFiles(workdir);
-}
-function resolveTemplate(template, ctx) {
-  let result = template;
-  for (const { name } of TEMPLATE_VARIABLES) {
-    if (name === "stepOutput" || name === "verifierFindings" || name === "previousStepOutput") continue;
-    const value = String(ctx[name]);
-    result = result.replace(new RegExp(`\\{\\{${name}\\}\\}`, "g"), value);
-  }
-  result = result.replace(/\{\{stepOutput\.(\w+)\}\}/g, (_, key) => ctx.stepOutput[key] ?? "");
-  result = result.replace(/\{\{verifierFindings\}\}/g, ctx.stepOutput["content"] ?? "");
-  result = result.replace(/\{\{previousStepOutput\}\}/g, ctx.stepOutput["stdout"] ?? "");
-  for (const [key, value] of Object.entries(ctx.params)) {
-    result = result.replaceAll(`{{${key}}}`, value);
-  }
-  return result;
-}
-function evaluateCondition(condition, stepOutcome, metadataEntries) {
-  switch (condition.type) {
-    case "step_result":
-      if (!stepOutcome) return false;
-      return stepOutcome.result === condition.result;
-    case "metadata_all_match": {
-      if (!metadataEntries) return false;
-      const entries = metadataEntries[condition.key];
-      if (!entries || entries.length === 0) return true;
-      return entries.every((e) => e[condition.field] === condition.value);
-    }
-    case "metadata_all_in": {
-      if (!metadataEntries) return false;
-      const entries = metadataEntries[condition.key];
-      if (!entries || entries.length === 0) return true;
-      return entries.every((e) => condition.values.includes(e[condition.field]));
-    }
-    case "always":
-      return true;
-  }
-}
-function evaluateTransitions(transitions, stepOutcome, metadataEntries) {
-  for (const transition of transitions) {
-    if (evaluateCondition(transition.when, stepOutcome, metadataEntries)) {
-      return transition.goto;
-    }
-  }
-  return TERMINAL_BLOCKED;
-}
-var DEFAULT_USER_RESULT = "continue";
-var CONTINUE_CHOICE_ID = "continue";
-function userStepChoices(step) {
-  const seen = /* @__PURE__ */ new Set();
-  const choices = [];
-  for (const t of step.transitions) {
-    if (t.when.type === "step_result") {
-      const id = t.when.result;
-      if (seen.has(id)) continue;
-      seen.add(id);
-      choices.push({ id, label: id, goto: t.goto });
-    } else if (t.when.type === "always") {
-      if (seen.has(CONTINUE_CHOICE_ID)) continue;
-      seen.add(CONTINUE_CHOICE_ID);
-      choices.push({ id: CONTINUE_CHOICE_ID, label: "Continue", goto: t.goto });
-    }
-  }
-  return choices;
-}
-function emitWorkflowMessage(eventStore, sessionId, content, windowOptions, onMessage) {
-  const msgId = crypto.randomUUID();
-  eventStore.append(
-    sessionId,
-    createMessageStartEvent(msgId, "user", content, {
-      ...windowOptions ?? {},
-      isSystemGenerated: true,
-      messageKind: "correction",
-      metadata: { type: "workflow", name: "Workflow", color: "#f59e0b" }
-    })
-  );
-  eventStore.append(sessionId, { type: "message.done", data: { messageId: msgId } });
-  if (onMessage) {
-    onMessage(
-      createChatMessageMessage({
-        id: msgId,
-        role: "user",
-        content,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        isSystemGenerated: true,
-        messageKind: "correction",
-        metadata: { type: "workflow", name: "Workflow", color: "#f59e0b" }
-      })
-    );
-  }
-  return msgId;
-}
-function injectGenericKickoff(sessionId) {
-  const eventStore = getEventStore();
-  const windowOpts = getCurrentWindowMessageOptions(sessionId);
-  const msgId = crypto.randomUUID();
-  eventStore.append(
-    sessionId,
-    createMessageStartEvent(msgId, "user", "Proceed with the current step.", {
-      ...windowOpts ?? {},
-      isSystemGenerated: true,
-      messageKind: "auto-prompt",
-      metadata: { type: "workflow", name: "Workflow", color: "#f59e0b" }
-    })
-  );
-  eventStore.append(sessionId, { type: "message.done", data: { messageId: msgId } });
-}
-function getCurrentWindowMessageOptions(sessionId) {
-  const contextWindowId = getCurrentContextWindowId(sessionId);
-  return contextWindowId ? { contextWindowId } : void 0;
-}
-function buildReason(metadataEntries) {
-  const entries = metadataEntries?.["criteria"] ?? [];
-  const remaining = entries.filter((e) => e.status !== "passed");
-  return `${remaining.length} criteria remaining`;
-}
-async function executeWorkflow(workflow, options, subGroup) {
-  const { sessionManager, sessionId, llmClient, signal, onMessage } = options;
-  const eventStore = getEventStore();
-  const startTime = performance.now();
-  let iterations = 0;
-  const activeSteps = subGroup ? workflow.steps.filter((s) => s.subGroup === subGroup) : workflow.steps;
-  const resumeFromStep = options.resumeFromStep;
-  const isResume = !!resumeFromStep;
-  let resumeConsumed = false;
-  let currentStepId = isResume ? resumeFromStep : subGroup ? activeSteps[0]?.id ?? workflow.entryStep : workflow.entryStep;
-  let lastStepOutput = options.initialStepOutput ?? {};
-  const firstEntryForStep = /* @__PURE__ */ new Set();
-  const messagesBeforeWorkflow = sessionManager.requireSession(sessionId).messages.length;
-  const activeStepIds = new Set(activeSteps.map((s) => s.id));
-  const stepsById = /* @__PURE__ */ new Map();
-  for (const step of activeSteps) {
-    stepsById.set(step.id, step);
-  }
-  if (resumeFromStep) {
-    const targetStep = stepsById.get(resumeFromStep);
-    if (!targetStep) {
-      return {
-        finalAction: {
-          type: "BLOCKED",
-          reason: `Resume target step "${resumeFromStep}" not found in workflow "${workflow.metadata.id}"`,
-          blockedCriteria: []
-        },
-        iterations: 0,
-        totalTime: (performance.now() - startTime) / 1e3
-      };
-    }
-  }
-  logger.debug("Workflow executor starting", { sessionId, workflow: workflow.metadata.id });
-  let executionId;
-  if (isResume) {
-    const activeExec = sessionManager.getActiveWorkflowExecution(sessionId);
-    if (activeExec) {
-      executionId = activeExec.id;
-    }
-  }
-  if (workflow.startCondition && workflow.startCondition.type !== "always") {
-    const session = sessionManager.requireSession(sessionId);
-    const conditionMet = evaluateCondition(
-      workflow.startCondition,
-      null,
-      session.metadataEntries
-    );
-    if (!conditionMet) {
-      logger.debug("Workflow start condition not met", { sessionId, condition: workflow.startCondition.type });
-      return {
-        finalAction: {
-          type: "BLOCKED",
-          reason: `Start condition not met: ${workflow.startCondition.type}`,
-          blockedCriteria: []
-        },
-        iterations: 0,
-        totalTime: (performance.now() - startTime) / 1e3
-      };
-    }
-  }
-  if (!isResume) {
-    const startMsgId = crypto.randomUUID();
-    const startWindowOpts = getCurrentWindowMessageOptions(sessionId);
-    eventStore.append(
-      sessionId,
-      createMessageStartEvent(
-        startMsgId,
-        "user",
-        JSON.stringify({
-          workflowName: workflow.metadata.name,
-          workflowId: workflow.metadata.id,
-          workflowColor: workflow.metadata.color
-        }),
-        { ...startWindowOpts ?? {}, isSystemGenerated: true, messageKind: "workflow-started" }
-      )
-    );
-    eventStore.append(sessionId, { type: "message.done", data: { messageId: startMsgId } });
-    executionId = crypto.randomUUID();
-    sessionManager.startWorkflow(
-      sessionId,
-      executionId,
-      workflow.metadata.id,
-      workflow.metadata.name,
-      workflow.metadata.color,
-      options.params ?? {}
-    );
-  }
-  if (options.userMessage) {
-    sessionManager.addMessage(sessionId, {
-      role: "user",
-      content: options.userMessage.content,
-      ...options.userMessage.attachments ? { attachments: options.userMessage.attachments } : {}
-    });
-  }
-  while (iterations < workflow.settings.maxIterations) {
-    if (signal?.aborted) {
-      logger.debug("Workflow executor aborted \u2014 preserving execution", { sessionId, iterations });
-      return {
-        finalAction: { type: "RUN_BUILDER", reason: "Aborted" },
-        iterations,
-        totalTime: (performance.now() - startTime) / 1e3
-      };
-    }
-    iterations++;
-    const step = stepsById.get(currentStepId);
-    if (!step) {
-      logger.error("Workflow step not found", { sessionId, stepId: currentStepId });
-      return {
-        finalAction: { type: "BLOCKED", reason: `Step "${currentStepId}" not found in workflow`, blockedCriteria: [] },
-        iterations,
-        totalTime: (performance.now() - startTime) / 1e3
-      };
-    }
-    const session = sessionManager.requireSession(sessionId);
-    const currentWindowMessageOptions = getCurrentWindowMessageOptions(sessionId);
-    const criteriaEntries = session.metadataEntries["criteria"] ?? [];
-    const templateCtx = {
-      workdir: sessionManager.getEffectiveWorkdir(sessionId),
-      reason: buildReason(session.metadataEntries),
-      verifierFindings: lastStepOutput["content"] ?? "",
-      previousStepOutput: lastStepOutput["stdout"] ?? "",
-      criteriaCount: criteriaEntries.length,
-      pendingCount: criteriaEntries.filter((e) => e.status !== "passed").length,
-      criteriaList: formatCriteriaList(criteriaEntries),
-      modifiedFiles: await formatModifiedFiles(sessionManager.getEffectiveWorkdir(sessionId)),
-      stepOutput: lastStepOutput,
-      params: options.params ?? {}
-    };
-    sessionManager.setPhase(sessionId, step.phase);
-    if (executionId) {
-      sessionManager.updateWorkflowStep(
-        sessionId,
-        executionId,
-        step.id,
-        step.name,
-        workflow.metadata.id,
-        workflow.metadata.name,
-        workflow.metadata.color
-      );
-    }
-    if (step.type === "agent") {
-      const agentStep = step;
-      sessionManager.setMode(sessionId, agentStep.agentId ?? resolveDefaultAgentId());
-    }
-    logger.debug("Workflow step executing", { sessionId, iteration: iterations, stepId: step.id, stepType: step.type });
-    let stepOutcome = null;
-    switch (step.type) {
-      case "agent": {
-        const agentStep = step;
-        const STEP_DONE_PROMPT = "\n\nOnce you're done, call step_done()";
-        const STEP_DONE_NUDGE = "You haven't called step_done(). If you haven't finished the task, continue and when you're finished call step_done()";
-        let promptContent;
-        let nudgeContent;
-        const isResumingCurrentStep = isResume && step.id === resumeFromStep && !resumeConsumed;
-        if (!firstEntryForStep.has(step.id) && agentStep.prompt && !isResumingCurrentStep) {
-          const resolvedPrompt = resolveTemplate(agentStep.prompt, templateCtx);
-          promptContent = resolvedPrompt + STEP_DONE_PROMPT;
-          const promptMsgId = crypto.randomUUID();
-          const msgMetadata = { type: "workflow", name: "Workflow", color: "#f59e0b" };
-          eventStore.append(
-            sessionId,
-            createMessageStartEvent(promptMsgId, "user", promptContent, {
-              ...currentWindowMessageOptions ?? {},
-              isSystemGenerated: true,
-              messageKind: "auto-prompt",
-              metadata: msgMetadata
-            })
-          );
-          eventStore.append(sessionId, { type: "message.done", data: { messageId: promptMsgId } });
-          if (onMessage) {
-            onMessage(
-              createChatMessageMessage({
-                id: promptMsgId,
-                role: "user",
-                content: promptContent,
-                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-                isSystemGenerated: true,
-                messageKind: "auto-prompt",
-                metadata: { type: "workflow", name: "Workflow", color: "#f59e0b" }
-              })
-            );
-          }
-        } else if (firstEntryForStep.has(step.id) && !isResumingCurrentStep) {
-          const parts = [];
-          if (agentStep.nudgePrompt) {
-            const resolvedNudge = resolveTemplate(agentStep.nudgePrompt, templateCtx);
-            parts.push(resolvedNudge);
-          }
-          parts.push(STEP_DONE_NUDGE);
-          nudgeContent = parts.join("\n\n");
-          emitWorkflowMessage(eventStore, sessionId, nudgeContent, currentWindowMessageOptions, onMessage);
-        }
-        const turnMetrics = new TurnMetrics();
-        const es = getEventStore();
-        const append = (event) => es.append(sessionId, event);
-        let stepDoneCalled = false;
-        const agentResult = await runAgentTurn(
-          {
-            sessionManager,
-            sessionId,
-            llmClient,
-            ...options.statsIdentity ? { statsIdentity: options.statsIdentity } : {},
-            ...signal ? { signal } : {},
-            ...onMessage ? { onMessage } : {}
-          },
-          turnMetrics,
-          agentStep.agentId ?? resolveDefaultAgentId(),
-          append,
-          {
-            ...!firstEntryForStep.has(step.id) && !agentStep.prompt && !isResumingCurrentStep ? { injectKickoff: () => injectGenericKickoff(sessionId) } : {},
-            onToolExecuted: (toolCall, toolResult) => {
-              if (toolCall.name === "step_done" && toolResult.success) {
-                stepDoneCalled = true;
-              }
-            }
-          }
-        );
-        firstEntryForStep.add(step.id);
-        resumeConsumed = true;
-        const agentReturnValue = agentResult.returnValueResult ?? "completed";
-        lastStepOutput = {
-          ...agentResult.returnValueContent ? { content: agentResult.returnValueContent } : {},
-          ...agentResult.returnValueResult ? { result: agentResult.returnValueResult } : {},
-          stepDoneCalled: String(stepDoneCalled)
-        };
-        stepOutcome = { result: agentReturnValue, output: lastStepOutput };
-        if (!stepDoneCalled) {
-          logger.debug("step_done not called, looping agent step", {
-            sessionId,
-            stepId: step.id,
-            iteration: iterations
-          });
-          continue;
-        }
-        break;
-      }
-      case "sub_agent": {
-        const subStep = step;
-        const turnMetrics = new TurnMetrics();
-        const promptTemplate = subStep.prompt ?? "Perform your task.";
-        const resolvedPrompt = resolveTemplate(promptTemplate, templateCtx);
-        const allAgents = await loadAllAgentsDefault();
-        const agentDef = findAgentById(subStep.subAgentType, allAgents);
-        if (!agentDef) {
-          logger.error("Sub-agent definition not found", { subAgentType: subStep.subAgentType });
-          stepOutcome = { result: "error", output: {} };
-          break;
-        }
-        const toolRegistry = getToolRegistryForAgent(agentDef);
-        const filteredToolRegistry = {
-          tools: toolRegistry.tools.filter((t) => t.name !== "step_done"),
-          definitions: toolRegistry.definitions.filter((d) => d.type === "function" && d.function.name !== "step_done"),
-          execute: toolRegistry.execute
-        };
-        const result = await executeSubAgent({
-          subAgentType: subStep.subAgentType,
-          prompt: resolvedPrompt,
-          sessionManager,
-          sessionId,
-          llmClient,
-          toolRegistry: filteredToolRegistry,
-          turnMetrics,
-          statsIdentity: options.statsIdentity ?? {
-            providerId: "",
-            providerName: "",
-            backend: "unknown",
-            model: llmClient.getModel()
-          },
-          ...signal ? { signal } : {},
-          ...onMessage ? { onMessage } : {}
-        });
-        lastStepOutput = { content: result.content ?? "", ...result.result ? { result: result.result } : {} };
-        stepOutcome = { result: result.result ?? "success", output: lastStepOutput };
-        break;
-      }
-      case "shell": {
-        const shellStep = step;
-        const command = resolveTemplate(shellStep.command, templateCtx);
-        const timeout = shellStep.timeout ?? 6e4;
-        const successCodes = shellStep.successExitCodes ?? [0];
-        const shellMsgId = crypto.randomUUID();
-        eventStore.append(
-          sessionId,
-          createMessageStartEvent(shellMsgId, "user", `Running: \`${command}\``, {
-            ...currentWindowMessageOptions ?? {},
-            isSystemGenerated: true,
-            messageKind: "auto-prompt",
-            metadata: { type: "workflow", name: "Workflow", color: "#f59e0b" }
-          })
-        );
-        if (onMessage) {
-          onMessage(
-            createChatMessageMessage({
-              id: shellMsgId,
-              role: "user",
-              content: `Running: \`${command}\``,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              isSystemGenerated: true,
-              messageKind: "auto-prompt",
-              metadata: { type: "workflow", name: "Workflow", color: "#f59e0b" }
-            })
-          );
-        }
-        const result = await executeShellCommand(
-          command,
-          sessionManager.getEffectiveWorkdir(sessionId),
-          timeout,
-          signal
-        );
-        const output = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
-        lastStepOutput = { stdout: result.stdout ?? "", stderr: result.stderr ?? "", exitCode: String(result.exitCode) };
-        const outputContent = output ? `Exit code: ${result.exitCode}
-\`\`\`
-${output.slice(0, 1e4)}
-\`\`\`` : `Exit code: ${result.exitCode}`;
-        eventStore.append(sessionId, { type: "message.done", data: { messageId: shellMsgId } });
-        const outputMsgId = crypto.randomUUID();
-        eventStore.append(
-          sessionId,
-          createMessageStartEvent(outputMsgId, "user", outputContent, {
-            ...currentWindowMessageOptions ?? {},
-            isSystemGenerated: true,
-            messageKind: "correction"
-          })
-        );
-        eventStore.append(sessionId, { type: "message.done", data: { messageId: outputMsgId } });
-        if (onMessage) {
-          onMessage(
-            createChatMessageMessage({
-              id: outputMsgId,
-              role: "user",
-              content: outputContent,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              isSystemGenerated: true,
-              messageKind: "correction"
-            })
-          );
-        }
-        stepOutcome = { result: successCodes.includes(result.exitCode) ? "success" : "failure", output: lastStepOutput };
-        break;
-      }
-      case "user": {
-        if (resumeFromStep === step.id) {
-          const choice = options.userChoice;
-          const result = choice === void 0 || choice === CONTINUE_CHOICE_ID ? DEFAULT_USER_RESULT : choice;
-          stepOutcome = { result, output: lastStepOutput };
-          break;
-        }
-        if (executionId) {
-          const choices = userStepChoices(step).map((choice) => {
-            const target = choice.goto ? stepsById.get(choice.goto) : void 0;
-            return target ? { ...choice, nextStepName: target.name } : choice;
-          });
-          sessionManager.waitAtStep(
-            sessionId,
-            executionId,
-            step.id,
-            step.name,
-            lastStepOutput,
-            workflow.metadata.id,
-            workflow.metadata.name,
-            workflow.metadata.color,
-            choices
-          );
-        }
-        logger.debug("Workflow paused at user step", { sessionId, stepId: step.id, stepName: step.name });
-        return {
-          finalAction: {
-            type: "WAITING",
-            reason: `Paused at user step: ${step.name}`,
-            workflowId: workflow.metadata.id,
-            stepId: step.id,
-            stepOutput: lastStepOutput
-          },
-          iterations,
-          totalTime: (performance.now() - startTime) / 1e3
-        };
-      }
-    }
-    const refreshedSession = sessionManager.requireSession(sessionId);
-    const effectiveTransitions = subGroup ? step.transitions.filter((t) => !t.subGroup || t.subGroup === subGroup) : step.transitions;
-    const rawNextStepId = evaluateTransitions(effectiveTransitions, stepOutcome, refreshedSession.metadataEntries);
-    const nextStepId = subGroup && rawNextStepId !== TERMINAL_DONE && rawNextStepId !== TERMINAL_BLOCKED && !activeStepIds.has(rawNextStepId) ? TERMINAL_DONE : rawNextStepId;
-    if (nextStepId === TERMINAL_DONE) {
-      sessionManager.setPhase(sessionId, "done");
-      if (executionId) {
-        sessionManager.completeWorkflow(
-          sessionId,
-          executionId,
-          workflow.metadata.id,
-          workflow.metadata.name,
-          workflow.metadata.color
-        );
-      }
-      const totalTimeSeconds = Math.round((performance.now() - startTime) / 100) / 10;
-      const completedSession = sessionManager.requireSession(sessionId);
-      const workflowMessages = completedSession.messages.slice(messagesBeforeWorkflow);
-      const workflowStats = computeSessionStats(workflowMessages);
-      const totalToolCalls = workflowMessages.reduce((sum, m) => sum + (m.toolCalls?.length ?? 0), 0);
-      const taskCompletedData = {
-        summary: null,
-        iterations,
-        totalTimeSeconds,
-        totalToolCalls,
-        totalTokensGenerated: workflowStats?.generationTokens ?? 0,
-        avgGenerationSpeed: workflowStats?.avgGenerationSpeed ?? 0,
-        responseCount: workflowStats?.responseCount ?? 0,
-        llmCallCount: workflowStats?.llmCallCount ?? 0,
-        criteria: [],
-        workflowName: workflow.metadata.name,
-        workflowId: workflow.metadata.id,
-        ...workflow.metadata.color ? { workflowColor: workflow.metadata.color } : {}
-      };
-      eventStore.append(sessionId, { type: "task.completed", data: taskCompletedData });
-      const markerMsgId = crypto.randomUUID();
-      eventStore.append(
-        sessionId,
-        createMessageStartEvent(markerMsgId, "user", JSON.stringify(taskCompletedData), {
-          ...currentWindowMessageOptions ?? {},
-          isSystemGenerated: true,
-          messageKind: "task-completed"
-        })
-      );
-      eventStore.append(sessionId, { type: "message.done", data: { messageId: markerMsgId } });
-      logger.debug("Workflow executor complete", { sessionId, iterations });
-      const doneAction = { type: "DONE" };
-      return {
-        finalAction: doneAction,
-        iterations,
-        totalTime: totalTimeSeconds
-      };
-    }
-    if (nextStepId === TERMINAL_BLOCKED) {
-      sessionManager.setPhase(sessionId, "blocked");
-      if (executionId) {
-        sessionManager.blockWorkflow(
-          sessionId,
-          executionId,
-          workflow.metadata.id,
-          workflow.metadata.name,
-          workflow.metadata.color
-        );
-      }
-      const reason = "No matching transition";
-      emitWorkflowMessage(eventStore, sessionId, `Runner blocked: ${reason}`, currentWindowMessageOptions, onMessage);
-      logger.warn("Workflow executor blocked", { sessionId, iterations, reason });
-      const blockedAction = { type: "BLOCKED", reason, blockedCriteria: [] };
-      return {
-        finalAction: blockedAction,
-        iterations,
-        totalTime: (performance.now() - startTime) / 1e3
-      };
-    }
-    currentStepId = nextStepId;
-  }
-  logger.warn("Workflow executor max iterations reached", { sessionId, iterations });
-  return {
-    finalAction: {
-      type: "BLOCKED",
-      reason: `Max iterations (${workflow.settings.maxIterations}) reached`,
-      blockedCriteria: []
-    },
-    iterations,
-    totalTime: (performance.now() - startTime) / 1e3
-  };
-}
-
-// src/server/runner/orchestrator.ts
-async function runOrchestrator(options) {
-  const runtimeConfig = getRuntimeConfig();
-  const workflowId = options.workflowId ?? runtimeConfig.activeWorkflowId ?? "default";
-  const configDir = getGlobalConfigDir(runtimeConfig.mode ?? "production");
-  const session = options.sessionManager.requireSession(options.sessionId);
-  const projectDir = session.workdir;
-  const scope = normalizeWorkflowScope(options.scope);
-  let workflow;
-  if (scope === "builtin") {
-    workflow = findWorkflowById(workflowId, await loadDefaultWorkflows());
-  } else if (scope === "user") {
-    workflow = findWorkflowById(workflowId, await loadUserWorkflows(configDir));
-  } else if (scope === "project") {
-    workflow = projectDir ? findWorkflowById(workflowId, await loadProjectWorkflows(projectDir)) : void 0;
-  } else {
-    workflow = void 0;
-  }
-  if (!workflow) {
-    const workflows = await loadAllWorkflows(configDir, projectDir);
-    workflow = findWorkflowById(workflowId, workflows);
-  }
-  if (!workflow) {
-    throw new Error(`Workflow "${workflowId}" not found`);
-  }
-  const requiredParams = (workflow.metadata.parameters ?? []).filter((p) => p.required);
-  const suppliedParams = options.params ?? {};
-  const missing = requiredParams.filter((p) => !(p.id in suppliedParams));
-  if (missing.length > 0) {
-    const names = missing.map((p) => p.label || p.id).join(", ");
-    throw new Error(`Missing required parameter${missing.length > 1 ? "s" : ""}: ${names}`);
-  }
-  logger.debug("Using workflow executor", {
-    sessionId: options.sessionId,
-    workflow: workflow.metadata.id,
-    subGroup: options.subGroup
-  });
-  return executeWorkflow(workflow, options, options.subGroup);
-}
-
 // src/server/auth.ts
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { join as join2, dirname as dirname2, basename } from "path";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join, dirname, basename } from "path";
 import { createHash, privateDecrypt, createPublicKey } from "crypto";
 function getAuthConfigPath() {
   const configDir = getRuntimeConfig();
   const mode = configDir.mode === "development" ? "development" : configDir.mode === "test" ? "test" : "production";
   if (mode === "test") {
     const cwd = process.cwd();
-    const base = basename(cwd) === "e2e" ? cwd : join2(cwd, "e2e");
-    const testAuthPath = join2(base, ".openfox-test", "auth.json");
+    const base = basename(cwd) === "e2e" ? cwd : join(cwd, "e2e");
+    const testAuthPath = join(base, ".openfox-test", "auth.json");
     return testAuthPath;
   }
   const home = process.env["HOME"] || process.env["USERPROFILE"] || "";
@@ -1297,8 +350,8 @@ function getAuthConfigPath() {
 }
 function getKeyPath() {
   const authPath = getAuthConfigPath();
-  const dir = dirname2(authPath);
-  return join2(dir, "auth.key");
+  const dir = dirname(authPath);
+  return join(dir, "auth.key");
 }
 var cachedAuth = null;
 var cachedPrivateKey = null;
@@ -1307,9 +360,9 @@ async function loadPrivateKey() {
     return cachedPrivateKey;
   }
   const keyPath = getKeyPath();
-  const keyDir = dirname2(keyPath);
+  const keyDir = dirname(keyPath);
   try {
-    cachedPrivateKey = await readFile2(keyPath, "utf-8");
+    cachedPrivateKey = await readFile(keyPath, "utf-8");
     return cachedPrivateKey;
   } catch {
     const { privateKey } = await import("crypto").then(
@@ -1319,8 +372,8 @@ async function loadPrivateKey() {
         publicKeyEncoding: { type: "spki", format: "pem" }
       })
     );
-    await mkdir2(keyDir, { recursive: true });
-    await writeFile2(keyPath, privateKey, { mode: 384 });
+    await mkdir(keyDir, { recursive: true });
+    await writeFile(keyPath, privateKey, { mode: 384 });
     cachedPrivateKey = privateKey;
     return privateKey;
   }
@@ -1335,7 +388,7 @@ async function loadServerAuthConfig() {
   }
   try {
     const authPath = getAuthConfigPath();
-    const data = await readFile2(authPath, "utf-8");
+    const data = await readFile(authPath, "utf-8");
     const authConfig = JSON.parse(data);
     cachedAuth = authConfig;
     return authConfig;
@@ -1410,7 +463,7 @@ function signalMcpReady() {
 }
 function moduleGitBranch(cwd) {
   return new Promise((resolve) => {
-    const proc = spawn3("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+    const proc = spawn2("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
       cwd,
       env: gitSpawnEnv(),
       stdio: ["ignore", "pipe", "ignore"],
@@ -1436,13 +489,13 @@ function hashContent(content) {
 function moduleGitDiff(cwd) {
   return new Promise((resolve) => {
     const env = gitSpawnEnv();
-    const diffProc = spawn3("git", ["diff", "--name-status", "HEAD"], {
+    const diffProc = spawn2("git", ["diff", "--name-status", "HEAD"], {
       cwd,
       env,
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true
     });
-    const statusProc = spawn3("git", ["status", "--porcelain"], {
+    const statusProc = spawn2("git", ["status", "--porcelain"], {
       cwd,
       env,
       stdio: ["ignore", "pipe", "pipe"],
@@ -2220,8 +1273,8 @@ async function handleClientMessage(ws, client, message, _getLLMClient, _getActiv
       const sessionId = client.activeSessionId;
       const session = sessionManager.requireSession(sessionId);
       try {
-        const { buildCachedPrompt } = await import("./dynamic-context-F2XTQJR5.js");
-        const allAgents = await import("./registry-VCKDSVKA.js");
+        const { buildCachedPrompt } = await import("./dynamic-context-MVGOF5V2.js");
+        const allAgents = await import("./registry-ZP4TN2IN.js");
         const agentDef = allAgents.findAgentById(session.mode, await allAgents.loadAllAgentsDefault()) ?? allAgents.findAgentById("planner", await allAgents.loadAllAgentsDefault());
         const modelName = session.providerModel ?? _providerManager?.getCurrentModel();
         const { systemPrompt: newPrompt, hash: newHash } = await buildCachedPrompt(
@@ -2341,8 +1394,6 @@ ${content}` : workflowInfo;
       const hasUserAttachments = launchAttachments && launchAttachments.length > 0;
       const hasUserMessage = hasUserContent || hasUserAttachments;
       const isResume = !!launchPayload?.resumeFrom;
-      sessionManager.setRunning(sessionId, true);
-      sendForSession(sessionId, createSessionRunningMessage(true));
       const controller = new AbortController();
       const existingController = activeAgents.get(sessionId);
       if (existingController) {
@@ -2371,71 +1422,30 @@ ${content}` : workflowInfo;
           );
         }
       }
-      runOrchestrator({
-        sessionManager,
-        sessionId,
-        llmClient: llmForSession(sessionId),
-        statsIdentity: statsForSession(sessionId),
-        scope: normalizeWorkflowScope(launchPayload?.scope),
-        ...launchPayload?.workflowId ? { workflowId: launchPayload.workflowId } : {},
-        ...launchPayload?.subGroup ? { subGroup: launchPayload.subGroup } : {},
-        ...isResume && launchPayload?.resumeFrom ? { resumeFromStep: launchPayload.resumeFrom } : {},
-        ...isResume && launchPayload?.stepOutput ? { initialStepOutput: launchPayload.stepOutput } : {},
-        ...isResume && launchPayload?.userChoice ? { userChoice: launchPayload.userChoice } : {},
-        ...launchPayload?.params ? { params: launchPayload.params } : {},
-        // On resume, prefer params/stepOutput from the persisted workflow execution
-        ...isResume ? (() => {
-          const exec = sessionManager.getActiveWorkflowExecution(sessionId);
-          if (!exec) return {};
-          if (exec.status === "waiting") {
-            const resumed = sessionManager.resumeWorkflow(
-              sessionId,
-              exec.id,
-              exec.workflowId,
-              exec.workflowName,
-              exec.workflowColor
-            );
-            if (resumed) {
-              return {
-                params: resumed.params,
-                initialStepOutput: resumed.stepOutput,
-                ...exec.currentStepId ? { resumeFromStep: exec.currentStepId } : {}
-              };
-            }
-          }
-          return {
-            ...Object.keys(exec.params).length > 0 ? { params: exec.params } : {},
-            ...Object.keys(exec.stepOutput).length > 0 ? { initialStepOutput: exec.stepOutput } : {},
-            ...exec.currentStepId ? { resumeFromStep: exec.currentStepId } : {}
-          };
-        })() : {},
-        ...hasUserMessage ? {
-          userMessage: {
+      launchWorkflowRun(
+        {
+          sessionManager,
+          sessionId,
+          controller,
+          llmClient: llmForSession(sessionId),
+          statsIdentity: statsForSession(sessionId),
+          broadcastForSession: (sid, msg) => _broadcastForSession(sid, msg),
+          onFinished: () => cleanupAfterTurn(sessionId, controller, sendForSession, true)
+        },
+        {
+          ...launchPayload?.workflowId ? { workflowId: launchPayload.workflowId } : {},
+          ...launchPayload?.subGroup ? { subGroup: launchPayload.subGroup } : {},
+          ...launchPayload?.scope ? { scope: launchPayload.scope } : {},
+          ...isResume && launchPayload?.resumeFrom ? { resumeFrom: launchPayload.resumeFrom } : {},
+          ...isResume && launchPayload?.stepOutput ? { stepOutput: launchPayload.stepOutput } : {},
+          ...isResume && launchPayload?.userChoice ? { userChoice: launchPayload.userChoice } : {},
+          ...launchPayload?.params ? { params: launchPayload.params } : {},
+          ...hasUserMessage ? {
             content: hasUserContent ? launchPayload.content : "",
             ...hasUserAttachments ? { attachments: launchAttachments } : {}
-          }
-        } : {},
-        signal: controller.signal,
-        onMessage: (msg) => _broadcastForSession(sessionId, msg)
-        // For path confirmation dialogs
-      }).catch((error) => {
-        if (error instanceof Error && error.message === "Aborted") {
-          return;
+          } : {}
         }
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logger.error("Runner error", { error: errorMessage, sessionId });
-        _broadcastForSession(
-          sessionId,
-          createServerMessage("chat.error", { error: errorMessage, recoverable: false })
-        );
-      }).finally(() => {
-        try {
-          sessionManager.setRunning(sessionId, false);
-          sendForSession(sessionId, createSessionRunningMessage(false));
-          cleanupAfterTurn(sessionId, controller, sendForSession, true);
-        } catch {
-        }
-      });
+      );
       break;
     }
     // =========================================================================
@@ -2522,20 +1532,6 @@ ${content}` : workflowInfo;
 
 export {
   terminalManager,
-  normalizeWorkflowScope,
-  loadDefaultWorkflows,
-  loadUserWorkflows,
-  loadProjectWorkflows,
-  loadAllWorkflows,
-  saveWorkflowToProject,
-  deleteProjectWorkflow,
-  getDefaultWorkflowIds,
-  isDefaultWorkflow,
-  findWorkflowById,
-  workflowExists,
-  saveWorkflow,
-  deleteWorkflow,
-  TEMPLATE_VARIABLES,
   loadServerAuthConfig,
   getAuthConfig,
   requiresAuth,
@@ -2546,4 +1542,4 @@ export {
   signalMcpReady,
   createWebSocketServer
 };
-//# sourceMappingURL=chunk-HGOTZWON.js.map
+//# sourceMappingURL=chunk-7GWARYQC.js.map