openfox 2.0.113 → 2.0.115

package/dist/chunk-3QQAIUZI.js

@@ -0,0 +1,957 @@
+import {
+  runAgentTurn
+} from "./chunk-3NPLERPQ.js";
+import {
+  executeSubAgent,
+  getToolRegistryForAgent
+} from "./chunk-JFK4GKQD.js";
+import {
+  TurnMetrics,
+  createMessageStartEvent
+} from "./chunk-YX3OQBNX.js";
+import {
+  checkAborted,
+  decodeUtf8,
+  spawnShellProcess
+} from "./chunk-ZTOG6LJD.js";
+import {
+  terminateProcessTree
+} from "./chunk-I72ACQ6R.js";
+import {
+  gitSpawnEnv
+} from "./chunk-J7GAZGZT.js";
+import {
+  findWorkflowById,
+  loadAllWorkflows,
+  loadDefaultWorkflows,
+  loadProjectWorkflows,
+  loadUserWorkflows,
+  normalizeWorkflowScope
+} from "./chunk-6RGACY4E.js";
+import {
+  getCurrentContextWindowId,
+  getEventStore
+} from "./chunk-ERNWAKUB.js";
+import {
+  createChatMessageMessage,
+  createSessionRunningMessage
+} from "./chunk-I7FY2LTR.js";
+import {
+  findAgentById,
+  getRuntimeConfig,
+  loadAllAgentsDefault,
+  resolveDefaultAgentId
+} from "./chunk-LNNBLB6G.js";
+import {
+  logger
+} from "./chunk-K44MW7JJ.js";
+import {
+  computeSessionStats
+} from "./chunk-VUQCQXXJ.js";
+import {
+  createServerMessage
+} from "./chunk-X25Q6RAV.js";
+import {
+  getGlobalConfigDir
+} from "./chunk-CQGTEGKL.js";
+
+// src/server/workflows/types.ts
+var TERMINAL_DONE = "$done";
+var TERMINAL_BLOCKED = "$blocked";
+
+// src/server/git/diff.ts
+import { spawn } from "child_process";
+function getGitDiffFiles(cwd) {
+  return new Promise((resolve) => {
+    const env = gitSpawnEnv();
+    const diffProc = spawn("git", ["diff", "--name-status", "HEAD"], {
+      cwd,
+      env,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    const statusProc = spawn("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 findMatchingTransition(transitions, stepOutcome, metadataEntries) {
+  for (const transition of transitions) {
+    if (evaluateCondition(transition.when, stepOutcome, metadataEntries)) {
+      return transition;
+    }
+  }
+  return null;
+}
+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 activeSubGroups = /* @__PURE__ */ new Set();
+  if (subGroup) {
+    activeSubGroups.add(subGroup);
+  }
+  const stepsById = /* @__PURE__ */ new Map();
+  for (const step of workflow.steps) {
+    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 ?? {},
+      subGroup
+    );
+  }
+  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(sessionManager.getProjectWorkdir(sessionId));
+        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 candidates = subGroup ? step.transitions.filter((t) => !t.subGroup || activeSubGroups.has(t.subGroup)) : step.transitions;
+    const fired = findMatchingTransition(candidates, stepOutcome, refreshedSession.metadataEntries);
+    let nextStepId = fired ? fired.goto : TERMINAL_BLOCKED;
+    if (subGroup && nextStepId !== TERMINAL_DONE && nextStepId !== TERMINAL_BLOCKED && !activeStepIds.has(nextStepId)) {
+      if (fired && fired.subGroup && activeSubGroups.has(fired.subGroup)) {
+        activeStepIds.add(nextStepId);
+        const targetStep = stepsById.get(nextStepId);
+        if (targetStep?.subGroup) {
+          activeSubGroups.add(targetStep.subGroup);
+        }
+      } else {
+        nextStepId = TERMINAL_DONE;
+      }
+    }
+    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/runner/launch.ts
+var activeRuns = /* @__PURE__ */ new Map();
+function abortRunnerRun(sessionId) {
+  const controller = activeRuns.get(sessionId);
+  if (!controller) return false;
+  controller.abort();
+  return true;
+}
+function launchWorkflowRun(deps, payload) {
+  const { sessionManager, sessionId, controller, llmClient, statsIdentity, broadcastForSession, onFinished } = deps;
+  const signal = controller.signal;
+  activeRuns.set(sessionId, controller);
+  sessionManager.setRunning(sessionId, true);
+  broadcastForSession(sessionId, createSessionRunningMessage(true));
+  const launchAttachments = payload.attachments;
+  const hasUserContent = payload.content && payload.content.trim().length > 0;
+  const hasUserAttachments = launchAttachments && launchAttachments.length > 0;
+  runOrchestrator({
+    sessionManager,
+    sessionId,
+    llmClient,
+    statsIdentity,
+    scope: normalizeWorkflowScope(payload.scope),
+    ...payload.workflowId ? { workflowId: payload.workflowId } : {},
+    ...payload.subGroup ? { subGroup: payload.subGroup } : {},
+    ...payload.params ? { params: payload.params } : {},
+    ...payload.resumeFrom ? { resumeFromStep: payload.resumeFrom } : {},
+    ...payload.stepOutput ? { initialStepOutput: payload.stepOutput } : {},
+    ...payload.userChoice ? { userChoice: payload.userChoice } : {},
+    ...payload.resumeFrom ? (() => {
+      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 } : {},
+            ...exec.subGroup ? { subGroup: exec.subGroup } : {}
+          };
+        }
+      }
+      return {
+        ...Object.keys(exec.params).length > 0 ? { params: exec.params } : {},
+        ...Object.keys(exec.stepOutput).length > 0 ? { initialStepOutput: exec.stepOutput } : {},
+        ...exec.currentStepId ? { resumeFromStep: exec.currentStepId } : {},
+        ...exec.subGroup ? { subGroup: exec.subGroup } : {}
+      };
+    })() : {},
+    ...hasUserContent || hasUserAttachments ? {
+      userMessage: {
+        content: payload.content ?? "",
+        ...hasUserAttachments ? { attachments: launchAttachments } : {}
+      }
+    } : {},
+    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(() => {
+    if (activeRuns.get(sessionId) === controller) {
+      activeRuns.delete(sessionId);
+    }
+    try {
+      sessionManager.setRunning(sessionId, false);
+      broadcastForSession(sessionId, createSessionRunningMessage(false));
+      onFinished?.();
+    } catch {
+    }
+  });
+}
+
+export {
+  TEMPLATE_VARIABLES,
+  abortRunnerRun,
+  launchWorkflowRun
+};
+//# sourceMappingURL=chunk-3QQAIUZI.js.map