openfox 2.0.0-beta.5 → 2.0.0-beta.6

package/dist/{chunk-RF2JGDSS.js → chunk-IGSZUXQP.js}

@@ -2,11 +2,11 @@ import {
   clearModelCache,
   createLLMClient,
   detectModel
-} from "./chunk-HHAJ3QF6.js";
+} from "./chunk-EMJGF3A7.js";
 import {
   detectBackend,
   getModelProfile
-} from "./chunk-HGAMIPFO.js";
+} from "./chunk-7FDY3EOH.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -511,4 +511,4 @@ export {
   parseDefaultModelSelection,
   createProviderManager
 };
-//# sourceMappingURL=chunk-RF2JGDSS.js.map
+//# sourceMappingURL=chunk-IGSZUXQP.js.map

package/dist/{chunk-UH27FDT7.js → chunk-NPHYEUYE.js}

@@ -1,6 +1,3 @@
-import {
-  getDatabase
-} from "./chunk-FBGWG4N6.js";
 import {
   buildContextMessagesFromEventHistory,
   buildMessagesFromStoredEvents,
@@ -8,10 +5,10 @@ import {
   foldContextState,
   foldSessionState,
   spreadOptionalMessageFields
-} from "./chunk-XL7SW5B4.js";
+} from "./chunk-XJEOP6XU.js";
 import {
-  getRuntimeConfig
-} from "./chunk-CGZHLM3K.js";
+  getDatabase
+} from "./chunk-FBGWG4N6.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -104,6 +101,18 @@ var EventStore = class {
       CREATE INDEX IF NOT EXISTS idx_events_session_type 
       ON events(session_id, event_type)
     `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS tombstones (
+        session_id TEXT NOT NULL,
+        seq INTEGER NOT NULL,
+        timestamp INTEGER NOT NULL,
+        UNIQUE(session_id, seq)
+      )
+    `);
+    this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_tombstones_session_seq 
+      ON tombstones(session_id, seq)
+    `);
   }
   // --------------------------------------------------------------------------
   // Append
@@ -182,10 +191,41 @@ var EventStore = class {
    * Get all events for a session, optionally starting from a specific seq
    */
   getEvents(sessionId, fromSeq) {
-    const query = fromSeq !== void 0 ? `SELECT * FROM events WHERE session_id = ? AND seq >= ? ORDER BY seq` : `SELECT * FROM events WHERE session_id = ? ORDER BY seq`;
+    const query = fromSeq !== void 0 ? `SELECT e.* FROM events e
+           LEFT JOIN tombstones t ON e.session_id = t.session_id AND e.seq = t.seq
+           WHERE e.session_id = ? AND e.seq >= ? AND t.seq IS NULL
+           ORDER BY e.seq` : `SELECT e.* FROM events e
+           LEFT JOIN tombstones t ON e.session_id = t.session_id AND e.seq = t.seq
+           WHERE e.session_id = ? AND t.seq IS NULL
+           ORDER BY e.seq`;
     const rows = fromSeq !== void 0 ? this.db.prepare(query).all(sessionId, fromSeq) : this.db.prepare(query).all(sessionId);
     return rows.map((row) => this.rowToStoredEvent(row));
   }
+  /**
+   * Soft-delete (tombstone) events by sequence number.
+   * Tombstoned events are hidden from getEvents but remain in the database.
+   *
+   * @param sessionId - The session ID
+   * @param seqs - Array of sequence numbers to tombstone
+   * @returns The number of events tombstoned
+   */
+  tombstoneEvents(sessionId, seqs) {
+    if (seqs.length === 0) return 0;
+    const timestamp = Date.now();
+    const insert = this.db.prepare(
+      `INSERT OR IGNORE INTO tombstones (session_id, seq, timestamp)
+       VALUES (?, ?, ?)`
+    );
+    let count = 0;
+    const transaction = this.db.transaction(() => {
+      for (const seq of seqs) {
+        const result = insert.run(sessionId, seq, timestamp);
+        count += result.changes;
+      }
+    });
+    transaction();
+    return count;
+  }
   /**
    * Get the latest sequence number for a session
    */
@@ -791,6 +831,70 @@ function mapSessionSummaryRow(row) {
   };
 }
 
+// src/server/config.ts
+import { z } from "zod";
+var backendSchema = z.enum(["auto", "vllm", "sglang", "ollama", "llamacpp"]).default("auto");
+var envSchema = z.object({
+  // New env var name, with fallback to old name for backward compatibility
+  OPENFOX_LLM_URL: z.string().url().optional(),
+  OPENFOX_VLLM_URL: z.string().url().optional(),
+  OPENFOX_BACKEND: backendSchema,
+  OPENFOX_MODEL_NAME: z.string().default("qwen3.5-122b-int4-autoround"),
+  OPENFOX_MAX_CONTEXT: z.coerce.number().default(2e5),
+  OPENFOX_PORT: z.coerce.number().default(10369),
+  OPENFOX_HOST: z.string().optional(),
+  OPENFOX_WORKDIR: z.string().optional(),
+  OPENFOX_DB_PATH: z.string().default("./openfox.db"),
+  OPENFOX_LOG_LEVEL: z.enum(["debug", "info", "warn", "error"]).default("info"),
+  OPENFOX_DISABLE_THINKING: z.coerce.boolean().default(false),
+  OPENFOX_DEV: z.coerce.boolean().default(false)
+});
+function loadConfig() {
+  const env = envSchema.parse(process.env);
+  const llmUrl = env.OPENFOX_LLM_URL ?? env.OPENFOX_VLLM_URL ?? "http://localhost:8000/v1";
+  const workdir = env.OPENFOX_WORKDIR ?? process.cwd();
+  return {
+    llm: {
+      baseUrl: llmUrl,
+      model: env.OPENFOX_MODEL_NAME,
+      timeout: 3e5,
+      // 5 minutes (deprecated, kept for backward compatibility)
+      idleTimeout: 3e5,
+      // 5 minutes of inactivity
+      backend: env.OPENFOX_BACKEND,
+      disableThinking: env.OPENFOX_DISABLE_THINKING
+    },
+    context: {
+      maxTokens: env.OPENFOX_MAX_CONTEXT,
+      compactionThreshold: 0.85,
+      compactionTarget: 0.6
+    },
+    agent: {
+      maxIterations: 10,
+      maxConsecutiveFailures: 3,
+      toolTimeout: 3e5
+    },
+    server: {
+      port: env.OPENFOX_PORT,
+      ...env.OPENFOX_HOST !== void 0 ? { host: env.OPENFOX_HOST } : {}
+    },
+    database: {
+      path: env.OPENFOX_DB_PATH
+    },
+    mode: env.OPENFOX_DEV ? "development" : "production",
+    workdir
+  };
+}
+
+// src/server/runtime-config.ts
+var runtimeConfig = null;
+function setRuntimeConfig(config) {
+  runtimeConfig = config;
+}
+function getRuntimeConfig() {
+  return runtimeConfig ?? loadConfig();
+}
+
 // src/server/events/session.ts
 function toSnapshotMessage(message) {
   return {
@@ -873,6 +977,10 @@ function getCurrentContextWindowId(sessionId) {
   const contextResult = foldContextState(events, "");
   return contextResult.currentContextWindowId || void 0;
 }
+function getCurrentWindowMessageOptions(sessionId) {
+  const contextWindowId = getCurrentContextWindowId(sessionId);
+  return contextWindowId ? { contextWindowId } : void 0;
+}
 function getReadFilesCache(sessionId) {
   const state = getSessionState(sessionId);
   return state?.readFiles ?? [];
@@ -1097,11 +1205,11 @@ function emitChatError(sessionId, error, recoverable) {
     data: { error, recoverable }
   });
 }
-function emitFormatRetry(sessionId, attempt, maxAttempts) {
+function emitPatternRetry(sessionId, messageId, pattern, field, attempt, maxAttempts, matchedContent) {
   const eventStore = getEventStore();
   eventStore.append(sessionId, {
-    type: "format.retry",
-    data: { attempt, maxAttempts }
+    type: "pattern.retry",
+    data: { messageId, pattern, field, attempt, maxAttempts, matchedContent }
   });
 }
 function emitTurnSnapshot(sessionId, snapshot) {
@@ -1227,10 +1335,14 @@ export {
   listSessions,
   listSessionsByProject,
   deleteSession,
+  loadConfig,
+  setRuntimeConfig,
+  getRuntimeConfig,
   getSessionState,
   getCurrentWindowMessages,
   getContextMessages,
   getCurrentContextWindowId,
+  getCurrentWindowMessageOptions,
   getReadFilesCache,
   isFileInCache,
   emitSessionInitialized,
@@ -1255,10 +1367,10 @@ export {
   emitContextState,
   emitChatDone,
   emitChatError,
-  emitFormatRetry,
+  emitPatternRetry,
   emitTurnSnapshot,
   truncateSessionMessages,
   compactContext,
   getRecentUserPromptsForSession
 };
-//# sourceMappingURL=chunk-UH27FDT7.js.map
+//# sourceMappingURL=chunk-NPHYEUYE.js.map

package/dist/{chunk-NNEHZT3V.js → chunk-QUSUEN5R.js}

@@ -1,9 +1,9 @@
 import {
   detectModel
-} from "./chunk-HHAJ3QF6.js";
+} from "./chunk-EMJGF3A7.js";
 import {
   detectBackend
-} from "./chunk-HGAMIPFO.js";
+} from "./chunk-7FDY3EOH.js";
 import {
   getGlobalConfigPath
 } from "./chunk-CQGTEGKL.js";
@@ -435,4 +435,4 @@ export {
   activateProvider,
   mergeConfigs
 };
-//# sourceMappingURL=chunk-NNEHZT3V.js.map
+//# sourceMappingURL=chunk-QUSUEN5R.js.map

package/dist/{chunk-I67T2E5K.js → chunk-R3EK3ODJ.js}

@@ -33,7 +33,7 @@ Options:
 }
 async function runNetworkSetup(mode) {
   const { loadAuthConfig, saveAuthConfig, encryptPassword } = await import("./auth-56SIRACI.js");
-  const { saveGlobalConfig } = await import("./config-YU7NYZYG.js");
+  const { saveGlobalConfig } = await import("./config-VBBMTXJZ.js");
   const { getAuthKeyPath } = await import("./paths-X46PPOI2.js");
   const existingAuth = await loadAuthConfig(mode);
   if (existingAuth) {
@@ -94,7 +94,7 @@ async function runNetworkSetup(mode) {
   console.log("\u2713 Configuration saved!\n");
 }
 async function runConfig(mode) {
-  const { loadGlobalConfig, getActiveProvider, getDefaultModel } = await import("./config-YU7NYZYG.js");
+  const { loadGlobalConfig, getActiveProvider, getDefaultModel } = await import("./config-VBBMTXJZ.js");
   const { getGlobalConfigPath } = await import("./paths-X46PPOI2.js");
   const config = await loadGlobalConfig(mode);
   const configPath = getGlobalConfigPath(mode);
@@ -151,7 +151,7 @@ async function runCli(options) {
       break;
     }
     case "provider": {
-      const { runProviderCommand } = await import("./provider-HTJEB3ON.js");
+      const { runProviderCommand } = await import("./provider-NRWSSO55.js");
       const [, subcommand] = positionals;
       await runProviderCommand(mode, subcommand);
       break;
@@ -188,12 +188,12 @@ async function runCli(options) {
       break;
     }
     default: {
-      const { configFileExists } = await import("./config-YU7NYZYG.js");
+      const { configFileExists } = await import("./config-VBBMTXJZ.js");
       const configExists = await configFileExists(mode);
       if (!configExists) {
         await runNetworkSetup(mode);
       }
-      const { runServe } = await import("./serve-EUEQ6ERI.js");
+      const { runServe } = await import("./serve-J6EM3G6N.js");
       const serveOptions = { mode };
       if (values.port) serveOptions.port = parseInt(values.port);
       if (values["no-browser"] === true) serveOptions.openBrowser = false;
@@ -205,4 +205,4 @@ async function runCli(options) {
 export {
   runCli
 };
-//# sourceMappingURL=chunk-I67T2E5K.js.map
+//# sourceMappingURL=chunk-R3EK3ODJ.js.map

package/dist/{chunk-X36JIWSF.js → chunk-RBJ25FIR.js}

@@ -1,57 +1,78 @@
 import {
-  BUILDER_KICKOFF_PROMPT,
   PathAccessDeniedError,
   TurnMetrics,
-  VERIFIER_KICKOFF_PROMPT,
+  WORKFLOW_KICKOFF_PROMPT,
   assembleAgentRequest,
   buildAgentReminder,
+  createAssemblyResult,
   createChatDoneEvent,
   createMessageStartEvent,
-  executeSubAgent,
   findAgentById,
+  getAllInstructions,
+  getConversationMessages,
+  getEnabledSkillMetadata,
   getSubAgents,
   getToolRegistryForAgent,
   loadAllAgentsDefault,
+  processEventsForConversation,
   runTopLevelAgentLoop
-} from "./chunk-DFWGWULB.js";
+} from "./chunk-FRCLNAE2.js";
 import {
   getCurrentContextWindowId,
-  getEventStore
-} from "./chunk-UH27FDT7.js";
+  getCurrentWindowMessageOptions,
+  getEventStore,
+  getRuntimeConfig
+} from "./chunk-NPHYEUYE.js";
 import {
   buildSnapshotFromSessionState
-} from "./chunk-XL7SW5B4.js";
+} from "./chunk-XJEOP6XU.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
+import {
+  getGlobalConfigDir
+} from "./chunk-CQGTEGKL.js";
 
-// src/server/sub-agents/verifier-helpers.ts
-var MAX_CONSECUTIVE_VERIFIER_NUDGES = 10;
-var VERIFIER_STALL_REASON = "Verifier stopped repeatedly before terminalizing verification after repeated nudges.";
-function getCriteriaAwaitingVerification(criteria) {
-  return criteria.filter((criterion) => criterion.status.type === "completed");
-}
-function buildVerifierNudgeContent(criteria) {
-  const ids = criteria.map((criterion) => criterion.id).join(", ");
-  return `You stopped before finalizing verification. ${criteria.length} criteria still need a terminal verification result. Use criterion with action "pass" or "fail" for each remaining criterion: ${ids}.`;
-}
-function buildVerifierRestartContent(criteria) {
-  const ids = criteria.map((criterion) => criterion.id).join(", ");
-  return `${VERIFIER_STALL_REASON} Leaving remaining criteria unchanged so verification can restart in a fresh window: ${ids}.`;
-}
-function createVerifierNudgeConfig() {
-  return {
-    maxConsecutiveNudges: MAX_CONSECUTIVE_VERIFIER_NUDGES,
-    getCriteriaAwaiting: getCriteriaAwaitingVerification,
-    buildNudgeContent: buildVerifierNudgeContent,
-    buildRestartContent: buildVerifierRestartContent
-  };
+// src/server/chat/dynamic-context.ts
+import { createHash } from "crypto";
+function computeDynamicContextHash(instructionContent, skills) {
+  const dynamicInputs = JSON.stringify({
+    instructions: instructionContent,
+    skills: skills.map((s) => s.id).sort()
+  });
+  return createHash("sha256").update(dynamicInputs).digest("hex");
 }
 
 // src/server/chat/orchestrator.ts
-function getCurrentWindowMessageOptions(sessionId) {
-  const contextWindowId = getCurrentContextWindowId(sessionId);
-  return contextWindowId ? { contextWindowId } : void 0;
+async function buildRetryPatterns() {
+  const { getSetting, SETTINGS_KEYS } = await import("./settings-6XX56F3F.js");
+  const raw = getSetting(SETTINGS_KEYS.RETRY_PATTERNS);
+  if (!raw) {
+    const oldXmlProtection = getSetting("llm.disableXmlProtection");
+    if (oldXmlProtection !== null) {
+      const disabled = oldXmlProtection === "true";
+      return {
+        retryPatterns: disabled ? [] : [{ field: "both", pattern: "<(tool_call|function=|/tool_call|parameter=)", action: "retry", active: true }],
+        maxRetriesPerTurn: 10
+      };
+    }
+    return { retryPatterns: [], maxRetriesPerTurn: 10 };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return {
+      retryPatterns: Array.isArray(parsed.patterns) ? parsed.patterns : [],
+      maxRetriesPerTurn: typeof parsed.maxRetriesPerTurn === "number" ? parsed.maxRetriesPerTurn : 10
+    };
+  } catch {
+    return { retryPatterns: [], maxRetriesPerTurn: 10 };
+  }
+}
+function buildGetConversationMessages(sessionId, llmClient, append) {
+  return async () => {
+    const processedEvents = await processEventsForConversation(sessionId, llmClient, (event) => append(event));
+    return getConversationMessages({ type: "toplevel", sessionId }, { events: processedEvents });
+  };
 }
 function resolveStatsIdentity(options) {
   const model = options.llmClient.getModel();
@@ -75,13 +96,11 @@ async function runChatTurn(options) {
   const session = sessionManager.requireSession(sessionId);
   const mode = session.mode;
   logger.debug("Starting chat turn", { sessionId, mode });
+  sessionManager.setRunning(sessionId, true);
+  const append = (event) => eventStore.append(sessionId, event);
   const turnMetrics = new TurnMetrics();
   try {
-    if (mode === "builder") {
-      await runBuilderTurn(options, turnMetrics);
-    } else {
-      await runGenericAgentTurn(options, turnMetrics, mode);
-    }
+    await runAgentTurn(options, turnMetrics, mode, append);
     const snapshot = buildSnapshot(sessionManager, sessionId, turnMetrics.buildStats(statsIdentity, mode));
     const snapshotEvent = eventStore.append(sessionId, { type: "turn.snapshot", data: snapshot });
     const deletedCount = eventStore.cleanupOldEvents(sessionId);
@@ -147,18 +166,30 @@ async function runChatTurn(options) {
     eventStore.append(sessionId, { type: "running.changed", data: { isRunning: false } });
   }
 }
+function windowHasReminder(sessionId, windowId) {
+  const eventStore = getEventStore();
+  const events = eventStore.getEvents(sessionId);
+  return events.some((event) => {
+    if (event.type !== "message.start") return false;
+    const data = event.data;
+    return data.contextWindowId === windowId && data.messageKind === "auto-prompt" && typeof data.content === "string" && data.content.includes("<system-reminder>");
+  });
+}
 function injectModeReminderIfNeeded(sessionManager, sessionId, agentId, allAgents, _onMessage) {
   const eventStore = getEventStore();
   const session = sessionManager.requireSession(sessionId);
+  const currentWindowId = getCurrentContextWindowId(sessionId);
   const lastModeReminder = session.executionState?.lastModeWithReminder;
   if (lastModeReminder === agentId) {
-    return;
+    if (!currentWindowId || windowHasReminder(sessionId, currentWindowId)) {
+      return;
+    }
   }
   const agentDef = findAgentById(agentId, allAgents);
   if (!agentDef) return;
   const reminderContent = buildAgentReminder(agentDef);
   const reminderMsgId = crypto.randomUUID();
-  const currentWindowMessageOptions = getCurrentContextWindowId(sessionId) ? { contextWindowId: getCurrentContextWindowId(sessionId) } : void 0;
+  const currentWindowMessageOptions = currentWindowId ? { contextWindowId: currentWindowId } : void 0;
   eventStore.append(sessionId, {
     type: "message.start",
     data: {
@@ -183,130 +214,88 @@ function injectModeReminderIfNeeded(sessionManager, sessionId, agentId, allAgent
     lastModeWithReminder: agentId
   });
 }
-async function runGenericAgentTurn(options, turnMetrics, agentId) {
+async function runAgentTurn(options, turnMetrics, agentId, append, callbacks) {
   const statsIdentity = resolveStatsIdentity(options);
   const allAgents = await loadAllAgentsDefault();
   injectModeReminderIfNeeded(options.sessionManager, options.sessionId, agentId, allAgents, options.onMessage);
   const agentDef = findAgentById(agentId, allAgents) ?? findAgentById("planner", allAgents);
   const subAgentDefs = getSubAgents(allAgents);
-  await runTopLevelAgentLoop(
+  const { content: instructionContent } = await getAllInstructions(
+    options.sessionManager.requireSession(options.sessionId).workdir,
+    options.sessionManager.requireSession(options.sessionId).projectId
+  );
+  const runtimeConfig = getRuntimeConfig();
+  const configDir = getGlobalConfigDir(runtimeConfig.mode ?? "production");
+  const skills = await getEnabledSkillMetadata(configDir, runtimeConfig.workdir);
+  return runTopLevelAgentLoop(
     {
       mode: agentId,
+      append,
+      ...await buildRetryPatterns(),
       sessionManager: options.sessionManager,
       sessionId: options.sessionId,
       llmClient: options.llmClient,
       statsIdentity,
       signal: options.signal,
       onMessage: options.onMessage,
-      assembleRequest: (input) => assembleAgentRequest({ ...input, agentDef, subAgentDefs, modelName: options.llmClient.getModel() }),
-      getToolRegistry: () => getToolRegistryForAgent(agentDef)
-    },
-    turnMetrics
-  );
-}
-function filterToolRegistryForStepDone(baseRegistry, _injectStepDone) {
-  return baseRegistry;
-}
-async function runBuilderTurn(options, turnMetrics) {
-  const { sessionManager, sessionId } = options;
-  const statsIdentity = resolveStatsIdentity(options);
-  const eventStore = getEventStore();
-  const allAgents = await loadAllAgentsDefault();
-  injectModeReminderIfNeeded(options.sessionManager, options.sessionId, "builder", allAgents, options.onMessage);
-  const builderDef = findAgentById("builder", allAgents);
-  const subAgentDefs = getSubAgents(allAgents);
-  let stepDoneCalled = false;
-  return {
-    ...await runTopLevelAgentLoop(
-      {
-        mode: "builder",
-        sessionManager,
-        sessionId,
-        llmClient: options.llmClient,
-        statsIdentity,
-        signal: options.signal,
-        onMessage: options.onMessage,
-        assembleRequest: (input) => assembleAgentRequest({
-          ...input,
-          agentDef: builderDef,
-          subAgentDefs,
-          modelName: options.llmClient.getModel()
-        }),
-        getToolRegistry: () => {
-          const baseRegistry = getToolRegistryForAgent(builderDef);
-          return filterToolRegistryForStepDone(baseRegistry, options.injectStepDone === true);
-        },
-        onToolExecuted: (toolCall, toolResult) => {
-          if (toolCall.name === "step_done" && toolResult.success) {
-            stepDoneCalled = true;
-          }
-          if (toolResult.success && ["write_file", "edit_file"].includes(toolCall.name)) {
-            const path = toolCall.arguments["path"];
-            sessionManager.addModifiedFile(sessionId, path);
+      assembleRequest: (input) => {
+        const cached = options.sessionManager.getCachedPrompt(options.sessionId);
+        if (cached) {
+          const currentHash = computeDynamicContextHash(instructionContent ?? "", skills);
+          if (cached.hash !== currentHash) {
+            options.sessionManager.setDynamicContextChanged(options.sessionId, true);
           }
-        },
-        injectKickoff: () => {
-          if (options.injectBuilderKickoff !== true) return;
-          const session = sessionManager.requireSession(sessionId);
-          const currentWindowMessageOptions = getCurrentContextWindowId(sessionId) ? { contextWindowId: getCurrentContextWindowId(sessionId) } : void 0;
-          const events = eventStore.getEvents(sessionId);
-          const hasBuilderKickoff = events.some((e) => {
-            if (e.type !== "message.start") return false;
-            const data = e.data;
-            return data.messageKind === "auto-prompt" && data.content?.includes("fulfil the");
+          return createAssemblyResult({
+            systemPrompt: cached.systemPrompt,
+            messages: input.messages,
+            injectedFiles: input.injectedFiles,
+            requestTools: input.promptTools,
+            toolChoice: input.toolChoice,
+            disableThinking: false
           });
-          if (!hasBuilderKickoff) {
-            const kickoffMsgId = crypto.randomUUID();
-            const kickoffContent = BUILDER_KICKOFF_PROMPT(session.criteria.length);
-            const msgMetadata = { type: "workflow", name: "Workflow", color: "#f59e0b" };
-            eventStore.append(
-              sessionId,
-              createMessageStartEvent(kickoffMsgId, "user", kickoffContent, {
-                ...currentWindowMessageOptions ?? {},
-                isSystemGenerated: true,
-                messageKind: "auto-prompt",
-                metadata: msgMetadata
-              })
-            );
-            eventStore.append(sessionId, { type: "message.done", data: { messageId: kickoffMsgId } });
-          }
         }
+        const result = assembleAgentRequest({
+          ...input,
+          agentDef,
+          subAgentDefs,
+          modelName: options.llmClient.getModel()
+        });
+        const hash = computeDynamicContextHash(instructionContent ?? "", skills);
+        options.sessionManager.setCachedPrompt(options.sessionId, result.systemPrompt, hash);
+        return result;
       },
-      turnMetrics
-    ),
-    stepDoneCalled
-  };
+      getToolRegistry: () => getToolRegistryForAgent(agentDef),
+      getConversationMessages: buildGetConversationMessages(options.sessionId, options.llmClient, append),
+      injectModeReminder: () => injectModeReminderIfNeeded(options.sessionManager, options.sessionId, agentId, allAgents, options.onMessage),
+      ...callbacks?.injectKickoff ? { injectKickoff: callbacks.injectKickoff } : {},
+      ...callbacks?.onToolExecuted ? { onToolExecuted: callbacks.onToolExecuted } : {}
+    },
+    turnMetrics
+  );
 }
-async function runVerifierTurn(options, turnMetrics) {
-  const { sessionManager, sessionId, llmClient, signal, onMessage } = options;
-  const statsIdentity = resolveStatsIdentity(options);
+function injectWorkflowKickoffIfNeeded(sessionManager, sessionId, eventStore) {
   const session = sessionManager.requireSession(sessionId);
-  const toVerify = session.criteria.filter((c) => c.status.type === "completed");
-  if (toVerify.length === 0) {
-    logger.debug("Nothing to verify", { sessionId });
-    return { allPassed: true, failed: [] };
-  }
-  const allAgents = await loadAllAgentsDefault();
-  const verifierDef = findAgentById("verifier", allAgents);
-  const toolRegistry = getToolRegistryForAgent(verifierDef);
-  const result = await executeSubAgent({
-    subAgentType: "verifier",
-    prompt: VERIFIER_KICKOFF_PROMPT,
-    sessionManager,
-    sessionId,
-    llmClient,
-    toolRegistry,
-    turnMetrics,
-    statsIdentity,
-    signal,
-    onMessage,
-    nudgeConfig: createVerifierNudgeConfig()
+  const currentWindowMessageOptions = getCurrentContextWindowId(sessionId) ? { contextWindowId: getCurrentContextWindowId(sessionId) } : void 0;
+  const events = eventStore.getEvents(sessionId);
+  const hasKickoff = events.some((e) => {
+    if (e.type !== "message.start") return false;
+    const data = e.data;
+    return data.messageKind === "auto-prompt" && data.content?.includes("fulfil the");
   });
-  return {
-    allPassed: result.allPassed ?? true,
-    failed: result.failed ?? [],
-    content: result.content
-  };
+  if (!hasKickoff) {
+    const kickoffMsgId = crypto.randomUUID();
+    const kickoffContent = WORKFLOW_KICKOFF_PROMPT(session.criteria.length);
+    eventStore.append(
+      sessionId,
+      createMessageStartEvent(kickoffMsgId, "user", kickoffContent, {
+        ...currentWindowMessageOptions ?? {},
+        isSystemGenerated: true,
+        messageKind: "auto-prompt",
+        metadata: { type: "workflow", name: "Workflow", color: "#f59e0b" }
+      })
+    );
+    eventStore.append(sessionId, { type: "message.done", data: { messageId: kickoffMsgId } });
+  }
 }
 function buildSnapshot(sessionManager, sessionId, _lastStats) {
   const eventStore = getEventStore();
@@ -323,10 +312,9 @@ function buildSnapshot(sessionManager, sessionId, _lastStats) {
 }
 
 export {
-  createVerifierNudgeConfig,
+  computeDynamicContextHash,
   runChatTurn,
-  filterToolRegistryForStepDone,
-  runBuilderTurn,
-  runVerifierTurn
+  runAgentTurn,
+  injectWorkflowKickoffIfNeeded
 };
-//# sourceMappingURL=chunk-X36JIWSF.js.map
+//# sourceMappingURL=chunk-RBJ25FIR.js.map