@circuitwall/jarela 2.2.1 → 2.3.0

package/.next/standalone/.next/server/chunks/{424.js → 1388.js}

@@ -1,6 +1,6 @@
 "use strict";
-exports.id = 424;
-exports.ids = [424,3944,8154];
+exports.id = 1388;
+exports.ids = [1388,8154];
 exports.modules = {
 
 /***/ 2522:
@@ -27,9 +27,6 @@ const state = (0,global_state/* getOrCreateGlobal */.X)("__jarela_trigger_regist
 function registerTriggerHandler(handler) {
     state.handlers.set(handler.kind, handler);
 }
-function getTriggerHandler(kind) {
-    return state.handlers.get(kind);
-}
 function registry_listTriggerHandlers() {
     return Array.from(state.handlers.values());
 }
@@ -1364,120 +1361,6 @@ registerHandlers();
 
 
 
-/***/ }),
-
-/***/ 3944:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   M6: () => (/* binding */ enqueueThreadRun),
-/* harmony export */   Zm: () => (/* binding */ QueueFullError),
-/* harmony export */   getQueueDepth: () => (/* binding */ getQueueDepth),
-/* harmony export */   vR: () => (/* binding */ QueueExpiredError)
-/* harmony export */ });
-/* unused harmony export __resetForTests */
-/* harmony import */ var _lib_utils_global_state__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15559);
-// Per-thread priority queue for agent runs.
-//
-// A thread can have one active run. Waiting interactive runs are selected
-// before waiting background runs, while FIFO order is preserved within each
-// lane. Different threads drain independently.
-//
-// In-memory + single-process. Multi-instance deployment would need a shared
-// lock (Redis, Postgres advisory locks) — explicitly out of scope.
-
-const queues = (0,_lib_utils_global_state__WEBPACK_IMPORTED_MODULE_0__/* .getOrCreateGlobal */ .X)("__jarela_thread_run_queues", ()=>new Map());
-const DEFAULT_MAX_DEPTH = 16;
-const sourceLanes = {
-    user: "interactive",
-    bridge: "interactive",
-    delegate: "interactive",
-    scheduler: "background",
-    watcher: "background",
-    trigger: "background",
-    extension: "background"
-};
-class QueueFullError extends Error {
-    constructor(thread_id, depth){
-        super(`Per-thread run queue full for thread ${thread_id} (depth=${depth})`);
-        this.name = "QueueFullError";
-    }
-}
-class QueueExpiredError extends Error {
-    constructor(thread_id, expiresAt){
-        super(`Queued run expired for thread ${thread_id} at ${expiresAt}`);
-        this.name = "QueueExpiredError";
-    }
-}
-function depth(queue) {
-    return (queue.active ? 1 : 0) + queue.interactive.length + queue.background.length;
-}
-function drain(thread_id, queue) {
-    if (queue.active) return;
-    const job = queue.interactive.shift() ?? queue.background.shift();
-    if (!job) {
-        if (queues.get(thread_id) === queue) queues.delete(thread_id);
-        return;
-    }
-    queue.active = job;
-    Promise.resolve().then(()=>{
-        if (job.expiresAt !== undefined && Date.now() >= job.expiresAt) {
-            throw new QueueExpiredError(thread_id, job.expiresAt);
-        }
-        return job.runner();
-    }).then((value)=>{
-        finish(thread_id, queue);
-        job.resolve(value);
-    }, (error)=>{
-        finish(thread_id, queue);
-        job.reject(error);
-    });
-}
-function finish(thread_id, queue) {
-    queue.active = undefined;
-    if (queues.get(thread_id) === queue) drain(thread_id, queue);
-}
-function enqueueThreadRun(thread_id, source, runner, options = {}) {
-    const queue = queues.get(thread_id) ?? {
-        interactive: [],
-        background: []
-    };
-    const currentDepth = depth(queue);
-    const max = options.maxDepth ?? DEFAULT_MAX_DEPTH;
-    if (currentDepth >= max) {
-        throw new QueueFullError(thread_id, currentDepth);
-    }
-    const lane = options.lane ?? sourceLanes[source];
-    const position = queue.active ? 1 + queue.interactive.length + (lane === "background" ? queue.background.length : 0) : queue.interactive.length + (lane === "background" ? queue.background.length : 0);
-    let resolve;
-    let reject;
-    const result = new Promise((res, rej)=>{
-        resolve = res;
-        reject = rej;
-    });
-    const job = {
-        runner,
-        expiresAt: options.expiresAt,
-        resolve,
-        reject
-    };
-    queue[lane].push(job);
-    queues.set(thread_id, queue);
-    drain(thread_id, queue);
-    return {
-        result,
-        position
-    };
-}
-/** Current queue depth for a thread, including the active job. */ function getQueueDepth(thread_id) {
-    const queue = queues.get(thread_id);
-    return queue ? depth(queue) : 0;
-}
-/** Reset all queue state. Test-only — never call from production code. */ function __resetForTests() {
-    queues.clear();
-}
-
-
 /***/ }),
 
 /***/ 5209:
@@ -1490,18 +1373,20 @@ function enqueueThreadRun(thread_id, source, runner, options = {}) {
 /* harmony import */ var _lib_stores_agent_configs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(41720);
 /* harmony import */ var _lib_stores_threads__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(83042);
 /* harmony import */ var _lib_stores_memory__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(80956);
-/* harmony import */ var _lib_agents_warm_summary_background__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(79640);
-/* harmony import */ var _lib_env_config__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(67500);
+/* harmony import */ var _lib_agents_warm_summary_background__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(36923);
+/* harmony import */ var _lib_agents_thread_compaction_state__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(87313);
+/* harmony import */ var _lib_env_config__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(67500);
+
 
 
 
 
 
 function maxThreadMessages() {
-    return (0,_lib_env_config__WEBPACK_IMPORTED_MODULE_4__/* .getConfig */ .z)().maxThreadMessages;
+    return (0,_lib_env_config__WEBPACK_IMPORTED_MODULE_5__/* .getConfig */ .z)().maxThreadMessages;
 }
 function maxSessionArchives() {
-    return (0,_lib_env_config__WEBPACK_IMPORTED_MODULE_4__/* .getConfig */ .z)().maxSessionArchives;
+    return (0,_lib_env_config__WEBPACK_IMPORTED_MODULE_5__/* .getConfig */ .z)().maxSessionArchives;
 }
 function autoCompactionKeepLast(cap) {
     return Math.max(1, cap - Math.max(20, Math.ceil(cap * 0.1)));
@@ -1532,19 +1417,43 @@ async function compactAgentThread(agentId, keepLast = maxThreadMessages(), reset
     const lastRow = rows[rows.length - 1];
     const boundaryRow = fullSessionReset ? null : rows[Math.max(0, rows.length - keepLast)] ?? lastRow;
     const boundarySeq = fullSessionReset ? lastRow.seq + 1 : boundaryRow.seq;
-    const context = await (0,_lib_agents_warm_summary_background__WEBPACK_IMPORTED_MODULE_3__/* .trackManualCompaction */ .bO)(thread.thread_id, boundarySeq, ()=>(0,_lib_agents_warm_summary_background__WEBPACK_IMPORTED_MODULE_3__/* .compactThreadWarmContext */ .gQ)(thread.thread_id, boundarySeq, {
-            expectedHotSinceSeq: thread.hot_since_seq ?? null,
-            alignTopicBoundary: !fullSessionReset
-        }));
+    if ((0,_lib_agents_warm_summary_background__WEBPACK_IMPORTED_MODULE_3__/* .isManualCompactionRunning */ .xU)(thread.thread_id)) {
+        return {
+            compacted: false,
+            reason: "already compacting"
+        };
+    }
+    let context;
+    try {
+        context = await (0,_lib_agents_warm_summary_background__WEBPACK_IMPORTED_MODULE_3__/* .trackManualCompaction */ .bO)(thread.thread_id, boundarySeq, (attempt)=>(0,_lib_agents_warm_summary_background__WEBPACK_IMPORTED_MODULE_3__/* .compactThreadWarmContext */ .gQ)(thread.thread_id, boundarySeq, {
+                expectedHotSinceSeq: thread.hot_since_seq ?? null,
+                alignTopicBoundary: !fullSessionReset,
+                attempt
+            }));
+    } catch (err) {
+        if (err instanceof _lib_agents_thread_compaction_state__WEBPACK_IMPORTED_MODULE_4__/* .CompactionTimeoutError */ .nQ) return {
+            compacted: false,
+            reason: "timed out"
+        };
+        throw err;
+    }
     if (!context) return {
         compacted: false,
-        reason: "summary was not committed"
+        reason: "no summary produced"
     };
+    // Automation channels (bridge, watcher, scheduled task) are compacted at the
+    // same boundary; a bridge-only agent has nothing but channel recaps.
+    const channelRecaps = context.channels.filter((c)=>!!c.summary);
+    const archivedSummary = [
+        context.summary,
+        ...channelRecaps.map((c)=>c.summary)
+    ].filter(Boolean).join("\n\n");
+    const messageCount = context.sourceMessages + channelRecaps.reduce((n, c)=>n + c.sourceMessages, 0);
     (0,_lib_stores_memory__WEBPACK_IMPORTED_MODULE_2__/* .putMemory */ .Ri)("sessions", `${agentId}/${Date.now()}`, {
-        summary: context.summary,
+        summary: archivedSummary,
         agent_id: agentId,
         agent_name: agent.name,
-        message_count: context.sourceMessages,
+        message_count: messageCount,
         compacted_at: new Date().toISOString()
     });
     const archivePruned = pruneSessionArchives(agentId, maxSessionArchives());
@@ -1553,7 +1462,7 @@ async function compactAgentThread(agentId, keepLast = maxThreadMessages(), reset
     return {
         compacted: true,
         summary: context.summary,
-        message_count: context.sourceMessages,
+        message_count: messageCount,
         context_chars: context.sourceChars,
         pruned,
         archive_pruned: archivePruned,
@@ -2219,7 +2128,7 @@ __webpack_require__.d(__webpack_exports__, {
   rw: () => (/* reexport */ applyToolBindBudget),
   o8: () => (/* reexport */ executeTool),
   tA: () => (/* reexport */ getAllToolCatalogAsync),
-  n0: () => (/* reexport */ runtime_getAllToolsAsync),
+  n0: () => (/* reexport */ getAllToolsAsync),
   sT: () => (/* reexport */ getBuiltinToolNames),
   vL: () => (/* reexport */ getDefaultAgentToolNames),
   iD: () => (/* reexport */ isHotLoadTool),
@@ -2227,7 +2136,7 @@ __webpack_require__.d(__webpack_exports__, {
   pe: () => (/* reexport */ toOpenAITools)
 });
 
-// UNUSED EXPORTS: allBuiltins, builtinNames, getAllTools, getDefaultAgentToolNamesAsync, getPackagesDir, getToolCapability, getToolCategory, getToolCredentialsRequired, getToolGroup, getToolIntegration, getToolSource, getToolsDir, initTools, loadExternal, loadLangChainPackages, registerTools, reloadLangChainPackages, toCatalogEntry
+// UNUSED EXPORTS: allBuiltins, builtinNames, getAllTools, getPackagesDir, getToolCategory, getToolCredentialsRequired, getToolIntegration, getToolSource, getToolsDir, initTools, loadExternal, loadLangChainPackages, registerTools, reloadLangChainPackages, toCatalogEntry
 
 // EXTERNAL MODULE: ./lib/tools/runtime/external.ts
 var external = __webpack_require__(16836);
@@ -2382,7 +2291,7 @@ const memoryUpsertTool = (0,tools/* tool */.z6)(async ({ namespace, key, record
     });
 }, {
     name: "memory_upsert",
-    description: "Store a durable, structured memory record for proactive semantic recall. Use namespace='facts' for information that should surface in future conversations. Store explicit user preferences, verified facts, decisions, constraints, and reusable project context; do not store transient chat details or secrets. Use an expiry for temporary facts, and status='archived' to soft-retire a record instead of deleting it.",
+    description: "Store a durable, structured memory record for proactive semantic recall. Use namespace='facts' for information that should surface in future conversations. Store explicit user preferences, verified facts, decisions, constraints, and reusable project context; do not store transient chat details or secrets. Use an expiry for temporary facts, and status='archived' to soft-retire a record instead of deleting it. Save proactively in the same turn the information appears so other agents can use it immediately; do not defer to background compaction.",
     schema: schemas/* object */.Ikc({
         namespace: schemas/* string */.YjP().describe("Memory namespace. Use 'facts' for proactively recalled durable knowledge."),
         key: schemas/* string */.YjP().describe("Stable, descriptive key such as 'user-research-preference' or 'project-auth-decision'."),
@@ -8390,8 +8299,8 @@ const getIntegrationSetupTool = (0,tools/* tool */.z6)(async ({ id })=>{
     }
 });
 
-// EXTERNAL MODULE: ./lib/stores/version-adoption.ts + 2 modules
-var version_adoption = __webpack_require__(95936);
+// EXTERNAL MODULE: ./lib/stores/version-adoption.ts + 4 modules
+var version_adoption = __webpack_require__(96570);
 ;// ./lib/tools/general/workflow-progress.ts
 
 
@@ -8423,7 +8332,8 @@ const workflowProgressSchema = schemas/* object */.Ikc({
     validation_evidence: schemas/* string */.YjP().trim().min(1).max(500).optional().describe("Exact check performed and observed result. Required when marking a version_adoption item done."),
     summary: schemas/* string */.YjP().max(300).optional().describe("Optional short workflow summary shown in the chat checklist."),
     detail: schemas/* string */.YjP().max(300).optional().describe("Optional live progress text to stream immediately to the UI."),
-    needs_attention_reason: schemas/* string */.YjP().max(300).optional().describe("Optional reason shown when the item or workflow needs user attention.")
+    needs_attention_reason: schemas/* string */.YjP().max(300).optional().describe("Optional reason shown when the item or workflow needs user attention."),
+    needs_user: schemas/* boolean */.zMY().optional().describe("For version_adoption only: set true when item_id cannot progress without the user's input or approval.")
 });
 function versionAdoptionPhase(phase) {
     return phase === "impact_radius" || phase === "adoption" || phase === "complete" ? phase : undefined;
@@ -8517,7 +8427,7 @@ const workflowProgressTool = (0,tools/* tool */.z6)(async (input, config)=>{
     }
 }, {
     name: "workflow_progress",
-    description: "Report structured progress for a substantial multi-step task. Use only when the task has several dependent phases, likely spans turns, or needs explicit verification; skip simple tasks and work already covered by native tool progress. For agent-created workflows, send the full current items snapshot on every call and reuse the same workflow_id. Keep secrets and private data out of workflow fields. Mark items done only with observed validation evidence; use needs_attention for blockers; phase=complete requires every item done or skipped. " + "Every item needs input, expected output, and concrete validation criteria. Completed items also need observed validation_evidence. The system-owned version_adoption workflow has its own durable checklist.",
+    description: "Report structured progress for a substantial multi-step task. Use only when the task has several dependent phases, likely spans turns, or needs explicit verification; skip simple tasks and work already covered by native tool progress. For agent-created workflows, send the full current items snapshot on every call and reuse the same workflow_id. Keep secrets and private data out of workflow fields. Mark items done only with observed validation evidence; use needs_attention for blockers; phase=complete requires every item done or skipped. " + "A rejected update, or a step left checking or needs_attention at the end of the turn, is retried automatically (at most 3 attempts per step); set needs_user=true on a step that only the user can unblock. " + "Every item needs input, expected output, and concrete validation criteria. Completed items also need observed validation_evidence. The system-owned version_adoption workflow has its own durable checklist.",
     schema: workflowProgressSchema
 });
 (0,langchain_package/* registerLangChainPackage */.p)({
@@ -9222,11 +9132,6 @@ var optional_package = __webpack_require__(71239);
 const msTodoReadTools = (0,optional_package/* optionalTools */.am)("@circuitwall/ms-todo-langchain", "msTodoReadTools");
 const msTodoWriteTools = (0,optional_package/* optionalTools */.am)("@circuitwall/ms-todo-langchain", "msTodoWriteTools");
 const setAuthResolver = (0,optional_package/* optionalFunction */.rz)("@circuitwall/ms-todo-langchain", "setAuthResolver", ()=>undefined);
-// Exposed for the integrations test endpoint, matching the gmail/outlook
-// `_resolveXxxAuth` probe convention.
-function _resolveMsTodoAuth() {
-    return resolveMicrosoftAuth();
-}
 // Bridge: the package calls this on every tool invocation. We resolve
 // the user's Microsoft credentials from Jarela's encrypted store (or env
 // vars) and exchange them for a short-lived access token via the shared
@@ -9473,8 +9378,8 @@ const msPeopleResolveTool = (0,tools/* tool */.z6)(async (args)=>{
     }
 });
 
-// EXTERNAL MODULE: ./lib/agents/run-thread.ts + 22 modules
-var run_thread = __webpack_require__(90424);
+// EXTERNAL MODULE: ./lib/agents/run-thread.ts + 23 modules
+var run_thread = __webpack_require__(91388);
 // EXTERNAL MODULE: ./lib/agents/model-router.ts + 1 modules
 var model_router = __webpack_require__(56236);
 // EXTERNAL MODULE: ./lib/agents/stream-collector.ts
@@ -9906,7 +9811,7 @@ const listToolsTool = (0,tools/* tool */.z6)(async ({ query, names, category, ca
     })
 });
 async function loadInputSchemas() {
-    const tools = await runtime_getAllToolsAsync();
+    const tools = await getAllToolsAsync();
     return new Map(toOpenAITools(tools).map((toolDef)=>[
             toolDef.function.name,
             toolDef.function.parameters
@@ -12925,7 +12830,7 @@ function getAllTools(policy) {
         ...ext.tools.filter((t)=>!(0,disabled_dropin_tools/* isDropinDisabled */.H)(t.name)).map(wallclock/* wrapWithWallclock */.ZW)
     ], policy);
 }
-async function runtime_getAllToolsAsync(policy) {
+async function getAllToolsAsync(policy) {
     try {
         await (0,langchain_packages/* loadLangChainPackages */.Jv)();
     } catch (err) {
@@ -13069,9 +12974,6 @@ function getToolSource(name) {
     if (catalog_loadExternal().tools.some((t)=>t.name === name)) return "external";
     return "mcp";
 }
-function getToolCapability(name) {
-    return registeredCapability(name) ?? "execute";
-}
 function getToolCategory(name) {
     const builtin = (0,registry/* registeredCategory */.RY)(name);
     if (builtin) return builtin;
@@ -13081,15 +12983,6 @@ function getToolCategory(name) {
     const mcpCat = (0,client/* getMcpToolMeta */.k2)(name)?.category;
     return (0,categories/* normalizeToolCategory */.eb)(mcpCat);
 }
-function getToolGroup(name) {
-    const cat = getToolCategory(name);
-    if (cat === "MCP") return null;
-    const builtinGroup = registeredGroup(name);
-    if (builtinGroup !== undefined) return builtinGroup;
-    const mcpGroup = getMcpToolMeta(name)?.group;
-    if (mcpGroup !== undefined) return mcpGroup;
-    return groupForCategory(cat);
-}
 function getToolCredentialsRequired(name) {
     if (registeredCategory(name)) return [];
     const ext = catalog_loadExternal().credentialsRequired.get(name);
@@ -13122,10 +13015,6 @@ function unconfiguredReason(entry) {
 function getDefaultAgentToolNames() {
     return getAllTools().filter((t)=>isDefaultBasicTool(t.name, getToolCategory(t.name))).map((t)=>t.name);
 }
-async function getDefaultAgentToolNamesAsync() {
-    const tools = await getAllToolsAsync();
-    return tools.filter((t)=>isDefaultBasicTool(t.name, getToolCategory(t.name))).map((t)=>t.name);
-}
 function isDefaultBasicTool(name, category) {
     return (0,categories/* isBasicToolCategory */.D6)(category) && !DEFAULT_EXCLUDED_BASIC_TOOLS.has(name);
 }
@@ -14575,7 +14464,7 @@ function cookiePathMatches(reqPath, cookiePath) {
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   V: () => (/* binding */ collectStream)
 /* harmony export */ });
-/* harmony import */ var _lib_agents_run_thread__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(90424);
+/* harmony import */ var _lib_agents_run_thread__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(91388);
 /* harmony import */ var _lib_utils_error__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(22032);
 // Shared collector for agent stream consumers.
 //
@@ -14720,7 +14609,7 @@ function cookiePathMatches(reqPath, cookiePath) {
 /* harmony export */   $: () => (/* binding */ moveThreadContextBoundary)
 /* harmony export */ });
 /* harmony import */ var _lib_stores_threads__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(83042);
-/* harmony import */ var _lib_agents_warm_summary_background__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(79640);
+/* harmony import */ var _lib_agents_warm_summary_background__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(36923);
 
 
 // Every caller of moveThreadContextBoundary represents a user-initiated
@@ -15407,7 +15296,7 @@ async function spillFileBuffer(raw, media_type, filename) {
 /* harmony export */   runAgentTurn: () => (/* binding */ runAgentTurn)
 /* harmony export */ });
 /* unused harmony export AgentTurnStreamError */
-/* harmony import */ var _lib_agents_run_thread__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(90424);
+/* harmony import */ var _lib_agents_run_thread__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(91388);
 /* harmony import */ var _lib_agents_transcript_draft__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(87627);
 /* harmony import */ var _api_message_content__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(9104);
 /* harmony import */ var _lib_agents_model_router__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(56236);
@@ -15581,436 +15470,6 @@ class AgentTurnStreamError extends Error {
 }
 
 
-/***/ }),
-
-/***/ 62174:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   $V: () => (/* binding */ getLatestMessageUsageForThread),
-/* harmony export */   kw: () => (/* binding */ getMessageUsageByIds),
-/* harmony export */   up: () => (/* binding */ recordMessageUsage)
-/* harmony export */ });
-/* harmony import */ var _lib_db__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(46);
-// ADR-0041. Immutable per-assistant-turn snapshot of LLM usage.
-//
-// Written once when an assistant turn is persisted (see
-// `persistAssistantMessage` in lib/agents/run-thread.ts). Never updated.
-// The dashboard reads this table in preference to recomputing tokens /
-// cost from `messages.content` + current agent_configs joins.
-
-function recordMessageUsage(input) {
-    const db = (0,_lib_db__WEBPACK_IMPORTED_MODULE_0__/* .getDb */ .Lf)();
-    const t = input.tier_usage ?? null;
-    db.prepare(`INSERT OR IGNORE INTO message_usage (
-       message_id, thread_id, agent_id, agent_name, provider, model_id,
-       model_config_name, input_tokens, output_tokens,
-       input_rate_usd_per_mtok, output_rate_usd_per_mtok, cost_usd, created_at,
-       hot_tokens, warm_tokens, facts_tokens, overhead_tokens,
-       hot_budget_tokens, warm_budget_tokens, facts_budget_tokens, context_window_tokens,
-       cache_creation_input_tokens, cache_read_input_tokens, thinking_tokens
-     ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(input.message_id, input.thread_id, input.agent_id, input.agent_name, input.provider, input.model_id, input.model_config_name, input.input_tokens, input.output_tokens, input.input_rate_usd_per_mtok, input.output_rate_usd_per_mtok, input.cost_usd, new Date().toISOString(), t?.hot_tokens ?? null, t?.warm_tokens ?? null, t?.facts_tokens ?? null, t?.overhead_tokens ?? null, t?.hot_budget_tokens ?? null, t?.warm_budget_tokens ?? null, t?.facts_budget_tokens ?? null, t?.context_window_tokens ?? null, input.cache_creation_input_tokens ?? null, input.cache_read_input_tokens ?? null, input.thinking_tokens ?? null);
-}
-function getMessageUsageByIds(messageIds) {
-    const out = new Map();
-    if (messageIds.length === 0) return out;
-    const placeholders = messageIds.map(()=>"?").join(",");
-    const rows = (0,_lib_db__WEBPACK_IMPORTED_MODULE_0__/* .getDb */ .Lf)().prepare(`SELECT * FROM message_usage WHERE message_id IN (${placeholders})`).all(...messageIds);
-    for (const row of rows)out.set(row.message_id, row);
-    return out;
-}
-function getLatestMessageUsageForThread(threadId) {
-    return (0,_lib_db__WEBPACK_IMPORTED_MODULE_0__/* .getDb */ .Lf)().prepare("SELECT * FROM message_usage WHERE thread_id=? ORDER BY created_at DESC LIMIT 1").get(threadId) ?? null;
-}
-
-
-/***/ }),
-
-/***/ 66963:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-  w: () => (/* binding */ getCheckpointer)
-});
-
-// EXTERNAL MODULE: external "node:path"
-var external_node_path_ = __webpack_require__(76760);
-// EXTERNAL MODULE: ./lib/db/data-dir.ts
-var data_dir = __webpack_require__(57477);
-// EXTERNAL MODULE: external "node:sqlite"
-var external_node_sqlite_ = __webpack_require__(80099);
-// EXTERNAL MODULE: ./node_modules/@langchain/langgraph-checkpoint/dist/index.js + 86 modules
-var dist = __webpack_require__(8808);
-;// ./lib/agents/sqlite-checkpoint-saver.ts
-
-
-// In-tree LangGraph checkpoint saver backed by node:sqlite.
-//
-// Schema-compatible drop-in replacement for SqliteSaver from
-// @langchain/langgraph-checkpoint-sqlite. The DDL is byte-identical so an
-// existing checkpoints.db keeps working without migration.
-const VALID_FILTER_KEYS = [
-    "source",
-    "step",
-    "parents"
-];
-function buildLatestSelect(includeCheckpointId) {
-    return `
-  SELECT
-    thread_id,
-    checkpoint_ns,
-    checkpoint_id,
-    parent_checkpoint_id,
-    type,
-    checkpoint,
-    metadata,
-    (
-      SELECT
-        json_group_array(
-          json_object(
-            'task_id', pw.task_id,
-            'channel', pw.channel,
-            'type', pw.type,
-            'value', CAST(pw.value AS TEXT)
-          )
-        )
-      FROM writes as pw
-      WHERE pw.thread_id = checkpoints.thread_id
-        AND pw.checkpoint_ns = checkpoints.checkpoint_ns
-        AND pw.checkpoint_id = checkpoints.checkpoint_id
-    ) as pending_writes,
-    (
-      SELECT
-        json_group_array(
-          json_object(
-            'type', ps.type,
-            'value', CAST(ps.value AS TEXT)
-          )
-        )
-      FROM writes as ps
-      WHERE ps.thread_id = checkpoints.thread_id
-        AND ps.checkpoint_ns = checkpoints.checkpoint_ns
-        AND ps.checkpoint_id = checkpoints.parent_checkpoint_id
-        AND ps.channel = '${dist/* TASKS */.n3}'
-      ORDER BY ps.idx
-    ) as pending_sends
-  FROM checkpoints
-  WHERE thread_id = ? AND checkpoint_ns = ? ${includeCheckpointId ? "AND checkpoint_id = ?" : "ORDER BY checkpoint_id DESC LIMIT 1"}`;
-}
-// node:sqlite rejects `undefined` parameter binds; coerce to null.
-function nv(v) {
-    return v === undefined ? null : v;
-}
-class NodeSqliteSaver extends dist/* BaseCheckpointSaver */.R1 {
-    constructor(db, serde){
-        super(serde), this.isSetup = false;
-        this.db = db;
-    }
-    static fromConnString(connStringOrLocalPath) {
-        return new NodeSqliteSaver(new external_node_sqlite_.DatabaseSync(connStringOrLocalPath));
-    }
-    setup() {
-        if (this.isSetup) return;
-        this.db.exec("PRAGMA journal_mode=WAL");
-        this.db.exec(`
-CREATE TABLE IF NOT EXISTS checkpoints (
-  thread_id TEXT NOT NULL,
-  checkpoint_ns TEXT NOT NULL DEFAULT '',
-  checkpoint_id TEXT NOT NULL,
-  parent_checkpoint_id TEXT,
-  type TEXT,
-  checkpoint BLOB,
-  metadata BLOB,
-  PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id)
-);`);
-        this.db.exec(`
-CREATE TABLE IF NOT EXISTS writes (
-  thread_id TEXT NOT NULL,
-  checkpoint_ns TEXT NOT NULL DEFAULT '',
-  checkpoint_id TEXT NOT NULL,
-  task_id TEXT NOT NULL,
-  idx INTEGER NOT NULL,
-  channel TEXT NOT NULL,
-  type TEXT,
-  value BLOB,
-  PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id, task_id, idx)
-);`);
-        this.withoutCheckpoint = this.db.prepare(buildLatestSelect(false));
-        this.withCheckpoint = this.db.prepare(buildLatestSelect(true));
-        this.isSetup = true;
-    }
-    txn(fn) {
-        this.db.exec("BEGIN");
-        try {
-            const result = fn();
-            this.db.exec("COMMIT");
-            return result;
-        } catch (err) {
-            try {
-                this.db.exec("ROLLBACK");
-            } catch  {
-            // ignore rollback failure; surface the original error
-            }
-            throw err;
-        }
-    }
-    async decodeRowState(row) {
-        const pendingWrites = await Promise.all(JSON.parse(String(row.pending_writes ?? "[]")).map(async (write)=>{
-            return [
-                write.task_id,
-                write.channel,
-                await this.serde.loadsTyped(write.type ?? "json", write.value ?? "")
-            ];
-        }));
-        const checkpoint = await this.serde.loadsTyped(row.type ?? "json", row.checkpoint);
-        if (checkpoint.v < 4 && row.parent_checkpoint_id != null) {
-            await this.migratePendingSends(checkpoint, row.thread_id, row.parent_checkpoint_id);
-        }
-        const metadata = await this.serde.loadsTyped(row.type ?? "json", row.metadata);
-        return {
-            pendingWrites,
-            checkpoint,
-            metadata
-        };
-    }
-    async getTuple(config) {
-        this.setup();
-        const { thread_id, checkpoint_ns = "", checkpoint_id } = config.configurable ?? {};
-        const args = [
-            nv(thread_id),
-            checkpoint_ns
-        ];
-        if (checkpoint_id) args.push(checkpoint_id);
-        const stmt = checkpoint_id ? this.withCheckpoint : this.withoutCheckpoint;
-        const row = stmt.get(...args);
-        if (row === undefined) return undefined;
-        let finalConfig = config;
-        if (!checkpoint_id) {
-            finalConfig = {
-                configurable: {
-                    thread_id: row.thread_id,
-                    checkpoint_ns,
-                    checkpoint_id: row.checkpoint_id
-                }
-            };
-        }
-        if (finalConfig.configurable?.thread_id === undefined || finalConfig.configurable?.checkpoint_id === undefined) {
-            throw new Error("Missing thread_id or checkpoint_id");
-        }
-        const { pendingWrites, checkpoint, metadata } = await this.decodeRowState(row);
-        return {
-            checkpoint,
-            config: finalConfig,
-            metadata,
-            parentConfig: row.parent_checkpoint_id ? {
-                configurable: {
-                    thread_id: row.thread_id,
-                    checkpoint_ns,
-                    checkpoint_id: row.parent_checkpoint_id
-                }
-            } : undefined,
-            pendingWrites
-        };
-    }
-    async *list(config, options) {
-        const { limit, before, filter } = options ?? {};
-        this.setup();
-        const thread_id = config.configurable?.thread_id;
-        const checkpoint_ns = config.configurable?.checkpoint_ns;
-        let sql = `
-      SELECT
-        thread_id,
-        checkpoint_ns,
-        checkpoint_id,
-        parent_checkpoint_id,
-        type,
-        checkpoint,
-        metadata,
-        (
-          SELECT
-            json_group_array(
-              json_object(
-                'task_id', pw.task_id,
-                'channel', pw.channel,
-                'type', pw.type,
-                'value', CAST(pw.value AS TEXT)
-              )
-            )
-          FROM writes as pw
-          WHERE pw.thread_id = checkpoints.thread_id
-            AND pw.checkpoint_ns = checkpoints.checkpoint_ns
-            AND pw.checkpoint_id = checkpoints.checkpoint_id
-        ) as pending_writes,
-        (
-          SELECT
-            json_group_array(
-              json_object(
-                'type', ps.type,
-                'value', CAST(ps.value AS TEXT)
-              )
-            )
-          FROM writes as ps
-          WHERE ps.thread_id = checkpoints.thread_id
-            AND ps.checkpoint_ns = checkpoints.checkpoint_ns
-            AND ps.checkpoint_id = checkpoints.parent_checkpoint_id
-            AND ps.channel = '${dist/* TASKS */.n3}'
-          ORDER BY ps.idx
-        ) as pending_sends
-      FROM checkpoints\n`;
-        const whereClause = [];
-        if (thread_id !== undefined && thread_id !== null) whereClause.push("thread_id = ?");
-        if (checkpoint_ns !== undefined && checkpoint_ns !== null) {
-            whereClause.push("checkpoint_ns = ?");
-        }
-        if (before?.configurable?.checkpoint_id !== undefined) {
-            whereClause.push("checkpoint_id < ?");
-        }
-        const sanitizedFilter = Object.fromEntries(Object.entries(filter ?? {}).filter(([key, value])=>value !== undefined && VALID_FILTER_KEYS.includes(key)));
-        whereClause.push(...Object.entries(sanitizedFilter).map(([key])=>`jsonb(CAST(metadata AS TEXT))->'$.${key}' = ?`));
-        if (whereClause.length > 0) sql += `WHERE\n  ${whereClause.join(" AND\n  ")}\n`;
-        sql += "\nORDER BY checkpoint_id DESC";
-        if (limit) sql += ` LIMIT ${parseInt(String(limit), 10)}`;
-        const args = [
-            thread_id,
-            checkpoint_ns,
-            before?.configurable?.checkpoint_id,
-            ...Object.values(sanitizedFilter).map((value)=>JSON.stringify(value))
-        ].filter((value)=>value !== undefined && value !== null);
-        const rows = this.db.prepare(sql).all(...args);
-        for (const row of rows){
-            const { pendingWrites, checkpoint, metadata } = await this.decodeRowState(row);
-            yield {
-                config: {
-                    configurable: {
-                        thread_id: row.thread_id,
-                        checkpoint_ns: row.checkpoint_ns,
-                        checkpoint_id: row.checkpoint_id
-                    }
-                },
-                checkpoint,
-                metadata,
-                parentConfig: row.parent_checkpoint_id ? {
-                    configurable: {
-                        thread_id: row.thread_id,
-                        checkpoint_ns: row.checkpoint_ns,
-                        checkpoint_id: row.parent_checkpoint_id
-                    }
-                } : undefined,
-                pendingWrites
-            };
-        }
-    }
-    async put(config, checkpoint, metadata) {
-        this.setup();
-        if (!config.configurable) throw new Error("Empty configuration supplied.");
-        const thread_id = config.configurable?.thread_id;
-        const checkpoint_ns = config.configurable?.checkpoint_ns ?? "";
-        const parent_checkpoint_id = config.configurable?.checkpoint_id;
-        if (!thread_id) {
-            throw new Error(`Missing "thread_id" field in passed "config.configurable".`);
-        }
-        const preparedCheckpoint = (0,dist/* copyCheckpoint */.IE)(checkpoint);
-        const [[type1, serializedCheckpoint], [type2, serializedMetadata]] = await Promise.all([
-            this.serde.dumpsTyped(preparedCheckpoint),
-            this.serde.dumpsTyped(metadata)
-        ]);
-        if (type1 !== type2) {
-            throw new Error("Failed to serialized checkpoint and metadata to the same type.");
-        }
-        this.db.prepare(`INSERT OR REPLACE INTO checkpoints (thread_id, checkpoint_ns, checkpoint_id, parent_checkpoint_id, type, checkpoint, metadata) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(thread_id, checkpoint_ns, checkpoint.id, nv(parent_checkpoint_id), type1, serializedCheckpoint, serializedMetadata);
-        return {
-            configurable: {
-                thread_id,
-                checkpoint_ns,
-                checkpoint_id: checkpoint.id
-            }
-        };
-    }
-    async putWrites(config, writes, taskId) {
-        this.setup();
-        if (!config.configurable) throw new Error("Empty configuration supplied.");
-        if (!config.configurable?.thread_id) {
-            throw new Error("Missing thread_id field in config.configurable.");
-        }
-        if (!config.configurable?.checkpoint_id) {
-            throw new Error("Missing checkpoint_id field in config.configurable.");
-        }
-        const stmt = this.db.prepare(`
-      INSERT OR REPLACE INTO writes
-      (thread_id, checkpoint_ns, checkpoint_id, task_id, idx, channel, type, value)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-        const rows = await Promise.all(writes.map(async (write, idx)=>{
-            const [type, serializedWrite] = await this.serde.dumpsTyped(write[1]);
-            return [
-                config.configurable?.thread_id,
-                config.configurable?.checkpoint_ns ?? "",
-                config.configurable?.checkpoint_id,
-                taskId,
-                idx,
-                write[0],
-                type,
-                serializedWrite
-            ];
-        }));
-        this.txn(()=>{
-            for (const row of rows)stmt.run(...row);
-        });
-    }
-    async deleteThread(threadId) {
-        this.setup();
-        this.txn(()=>{
-            this.db.prepare(`DELETE FROM checkpoints WHERE thread_id = ?`).run(threadId);
-            this.db.prepare(`DELETE FROM writes WHERE thread_id = ?`).run(threadId);
-        });
-    }
-    async migratePendingSends(checkpoint, threadId, parentCheckpointId) {
-        const row = this.db.prepare(`
-          SELECT
-            checkpoint_id,
-            json_group_array(
-              json_object(
-                'type', ps.type,
-                'value', CAST(ps.value AS TEXT)
-              )
-            ) as pending_sends
-          FROM writes as ps
-          WHERE ps.thread_id = ?
-            AND ps.checkpoint_id = ?
-            AND ps.channel = '${dist/* TASKS */.n3}'
-          ORDER BY ps.idx
-        `).get(threadId, parentCheckpointId);
-        const pendingSendsJson = String(row?.pending_sends ?? "[]");
-        const mutable = checkpoint;
-        mutable.channel_values ??= {};
-        mutable.channel_values[dist/* TASKS */.n3] = await Promise.all(JSON.parse(pendingSendsJson).map(({ type, value })=>this.serde.loadsTyped(type ?? "json", value ?? "")));
-        mutable.channel_versions[dist/* TASKS */.n3] = Object.keys(checkpoint.channel_versions).length > 0 ? (0,dist/* maxChannelVersion */.qU)(...Object.values(checkpoint.channel_versions)) : this.getNextVersion(undefined);
-    }
-}
-
-;// ./lib/agents/checkpointer.ts
-
-
-
-// Persistent graph state per thread_id. Multi-step plans, scratchpad messages,
-// and any pending tool-call sequence survive process restarts and resume on
-// the next agent.stream() with the same thread_id.
-//
-// Stored in a separate DB file (~/.jarela/checkpoints.db) so LangGraph
-// manages its own schema independently of our own migrations under
-// lib/db/. Both files use WAL mode via the same node:sqlite driver.
-const CHECKPOINT_PATH = (0,external_node_path_.join)((0,data_dir/* getDataDir */.o)(), "checkpoints.db");
-let _saver = null;
-function getCheckpointer() {
-    if (!_saver) {
-        _saver = NodeSqliteSaver.fromConnString(CHECKPOINT_PATH);
-    }
-    return _saver;
-}
-
-
 /***/ }),
 
 /***/ 67032:
@@ -16163,387 +15622,6 @@ function setUserPreset(preset) {
 }
 
 
-/***/ }),
-
-/***/ 68564:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   AD: () => (/* binding */ startRun),
-/* harmony export */   B1: () => (/* binding */ subscribe),
-/* harmony export */   Cs: () => (/* binding */ waitForRun),
-/* harmony export */   ES: () => (/* binding */ abortAllRuns),
-/* harmony export */   JH: () => (/* binding */ finishRun),
-/* harmony export */   KD: () => (/* binding */ abortRun),
-/* harmony export */   Mh: () => (/* binding */ getRun),
-/* harmony export */   QK: () => (/* binding */ drainSteering),
-/* harmony export */   mq: () => (/* binding */ broadcast),
-/* harmony export */   mx: () => (/* binding */ pushSteering)
-/* harmony export */ });
-/* unused harmony export waitForRunsToSettle */
-/* harmony import */ var _lib_env_config__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(67500);
-/* harmony import */ var _lib_utils_global_state__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(15559);
-
-
-// Read once at module init. JARELA_RUN_BUFFER_SIZE / JARELA_RUN_REGISTRY_TTL_MS
-// override the defaults.
-const MAX_BUFFERED = (0,_lib_env_config__WEBPACK_IMPORTED_MODULE_0__/* .getConfig */ .z)().runBufferSize;
-const RECENT_TTL_MS = (0,_lib_env_config__WEBPACK_IMPORTED_MODULE_0__/* .getConfig */ .z)().runRegistryTtlMs;
-// Idle (no-progress) ceiling and wall-clock ceiling: read fresh per-run
-// from getConfig() so non-restart-required env reloads take effect.
-function runIdleMs() {
-    return (0,_lib_env_config__WEBPACK_IMPORTED_MODULE_0__/* .getConfig */ .z)().runIdleMs;
-}
-function runMaxMs() {
-    return (0,_lib_env_config__WEBPACK_IMPORTED_MODULE_0__/* .getConfig */ .z)().runMaxMs;
-}
-const registryState = (0,_lib_utils_global_state__WEBPACK_IMPORTED_MODULE_1__/* .getOrCreateGlobal */ .X)("__jarela_active_run_registry", ()=>({
-        runs: new Map(),
-        waiters: new Map()
-    }));
-const runs = registryState.runs;
-// Cold-attach waiters: subscribers that opened a GET /run before the
-// server-side run actually called startRun (typical for triggers /
-// scheduler / watcher, which submit through `after()` + the per-thread
-// queue, so there's a real delay between the user clicking "Run now"
-// and the registry entry appearing). Resolved by `startRun` below.
-const waiters = registryState.waiters;
-/** Wait up to `timeoutMs` for a run to be registered on `thread_id`.
- *  Resolves immediately with the current run if one is already active,
- *  with the new run when `startRun` fires inside the window, or with
- *  `null` on timeout. `timeoutMs <= 0` short-circuits to the current
- *  state without waiting. Caller is responsible for closing the SSE
- *  stream when this resolves null. */ function waitForRun(thread_id, timeoutMs) {
-    const existing = runs.get(thread_id);
-    if (existing) return Promise.resolve(existing);
-    if (timeoutMs <= 0) return Promise.resolve(null);
-    return new Promise((resolve)=>{
-        let set = waiters.get(thread_id);
-        if (!set) {
-            set = new Set();
-            waiters.set(thread_id, set);
-        }
-        const fn = (run)=>{
-            clearTimeout(timer);
-            resolve(run);
-        };
-        set.add(fn);
-        const timer = setTimeout(()=>{
-            const cur = waiters.get(thread_id);
-            cur?.delete(fn);
-            if (cur && cur.size === 0) waiters.delete(thread_id);
-            resolve(null);
-        }, timeoutMs);
-        timer.unref?.();
-    });
-}
-function startRun(thread_id, agent_id) {
-    // If a stale completed run exists, drop it before starting a new one.
-    const existing = runs.get(thread_id);
-    if (existing && existing.status === "running") {
-        throw new Error(`A run is already active for thread ${thread_id}`);
-    }
-    const now = Date.now();
-    const run = {
-        thread_id,
-        agent_id,
-        started_at: now,
-        finished_at: null,
-        status: "running",
-        events: [],
-        subscribers: new Set(),
-        final_text: "",
-        abort: new AbortController(),
-        last_chunk_at: now,
-        inflight_tools: new Set(),
-        tool_started_at: new Map(),
-        tool_time_ms_done: 0,
-        steering: []
-    };
-    runs.set(thread_id, run);
-    // Wake any GET subscribers that attached before the run was registered.
-    const pending = waiters.get(thread_id);
-    if (pending) {
-        waiters.delete(thread_id);
-        for (const fn of pending){
-            try {
-                fn(run);
-            } catch  {}
-        }
-    }
-    scheduleIdleWatchdog(run);
-    scheduleMaxWatchdog(run);
-    return run;
-}
-// Synthesise a typed error chunk for the watchdog termination paths and
-// fan it out to subscribers BEFORE flipping `status` to "error". The order
-// matters: `broadcast()`'s status guard drops any chunk delivered after
-// `finishRun()` has run, so calling finishRun first would silently swallow
-// the error and the client's EventSource would just see the connection
-// close with no terminal event — bubble keeps spinning, no toast. Doing
-// it the other way around lets the client receive a real error event,
-// render a "Run timed out" toast, and (if the consumer wires it up)
-// trigger an auto-retry path. Followed by `done` so the consumer's
-// for-await loop can break cleanly without waiting for an EOF.
-function emitWatchdogTermination(run, code, message) {
-    if (run.status !== "running") return;
-    // Direct registry mutation so the broadcast goes through the regular
-    // path (subscribers + buffer + seq stamp) without re-entering any of
-    // the watchdog scheduling. Mirrors broadcast() but bypasses the
-    // status check we'd otherwise be racing against.
-    run.last_chunk_at = Date.now();
-    const errChunk = {
-        type: "error",
-        data: {
-            message,
-            code
-        }
-    };
-    if (run.events.length < MAX_BUFFERED) run.events.push(errChunk);
-    for (const fn of run.subscribers){
-        try {
-            fn(errChunk);
-        } catch  {}
-    }
-    // Pair with a synthetic `done` so the client's consume() loop breaks
-    // on a terminal event rather than waiting for the EventSource to close.
-    const doneChunk = {
-        type: "done",
-        data: {}
-    };
-    if (run.events.length < MAX_BUFFERED) run.events.push(doneChunk);
-    for (const fn of run.subscribers){
-        try {
-            fn(doneChunk);
-        } catch  {}
-    }
-}
-// Self-rearming idle watchdog. Fires when no chunk has arrived for
-// `idleMs`; otherwise reschedules itself for `(last_chunk_at + idleMs) -
-// now`. We never carry a handle on the run — the closure just bails if
-// the run is no longer the registry's entry or no longer running.
-function scheduleIdleWatchdog(run) {
-    const idleMs = runIdleMs();
-    const fireIn = Math.max(0, run.last_chunk_at + idleMs - Date.now());
-    setTimeout(()=>{
-        const cur = runs.get(run.thread_id);
-        if (cur !== run) return;
-        if (run.status !== "running") return;
-        const idle = Date.now() - run.last_chunk_at;
-        if (idle < idleMs) {
-            scheduleIdleWatchdog(run);
-            return;
-        }
-        if (run.inflight_tools.size > 0) {
-            // Tool execution in progress — silence here is the tool working,
-            // not a wedged provider stream. Skip the kill, re-check in idleMs.
-            // The tool_result will bump last_chunk_at when it lands.
-            setTimeout(()=>scheduleIdleWatchdog(run), idleMs).unref?.();
-            return;
-        }
-        console.warn(`[run-registry] idle watchdog: force-finishing stalled run for thread ${run.thread_id} after ${idle}ms of no progress`);
-        emitWatchdogTermination(run, "run_idle_timeout", `Run timed out — no progress for ${Math.round(idle / 1000)}s. The provider stream went silent before the agent finished. Try again, or split the request into smaller steps.`);
-        try {
-            run.abort.abort("run_idle_timeout");
-        } catch  {}
-        finishRun(run, "error");
-    }, fireIn).unref?.();
-}
-// Wall-clock elapsed minus time spent inside tool calls (both completed and
-// currently in flight). The wall-clock watchdog uses this so a 5-minute
-// shell exec or a slow MCP roundtrip doesn't burn the agent's budget;
-// tools enforce their own timeouts. See ActiveRun.tool_started_at for the
-// rationale.
-function effectiveElapsedMs(run, now) {
-    let inflightToolMs = 0;
-    for (const startedAt of run.tool_started_at.values()){
-        inflightToolMs += Math.max(0, now - startedAt);
-    }
-    return Math.max(0, now - run.started_at - run.tool_time_ms_done - inflightToolMs);
-}
-function scheduleMaxWatchdog(run) {
-    const max = runMaxMs();
-    const now = Date.now();
-    const fireIn = Math.max(0, max - effectiveElapsedMs(run, now));
-    setTimeout(()=>{
-        const cur = runs.get(run.thread_id);
-        if (cur !== run) return;
-        if (run.status !== "running") return;
-        const elapsed = effectiveElapsedMs(run, Date.now());
-        if (elapsed < max) {
-            // Tool time pushed the effective elapsed back below the ceiling —
-            // re-arm for the remaining budget. Without this, a tool that runs
-            // for longer than `max` between firing and resolving would let
-            // the next setTimeout overshoot.
-            scheduleMaxWatchdog(run);
-            return;
-        }
-        console.warn(`[run-registry] wall-clock watchdog: force-finishing run for thread ${run.thread_id} after ${elapsed}ms of agent time (excluding tool execution)`);
-        emitWatchdogTermination(run, "run_max_timeout", `Run exceeded the wall-clock limit (${Math.round(max / 1000)}s of agent time, excluding tool execution). The agent was force-stopped. Try a smaller scope or raise JARELA_RUN_MAX_MS if this is expected.`);
-        try {
-            run.abort.abort("run_watchdog_timeout");
-        } catch  {}
-        finishRun(run, "error");
-    }, fireIn).unref?.();
-}
-function broadcast(run, chunk) {
-    // Identity-check: a superseded run must not smear trailing chunks onto
-    // the replacement entry in the registry.
-    if (runs.get(run.thread_id) !== run) return;
-    run.last_chunk_at = Date.now();
-    // Heartbeats exist solely to reset the idle watchdog when the provider
-    // is producing chunks that don't surface downstream (most commonly
-    // partial tool-call args while the model streams a large file_write
-    // body). The last_chunk_at bump above is the entire payload — don't
-    // buffer, don't fan out to subscribers, or the SSE wire would carry
-    // meaningless tick events.
-    if (chunk.type === "heartbeat") return;
-    if (chunk.type === "text_delta") {
-        run.final_text += chunk.data.delta ?? "";
-    } else if (chunk.type === "reset_text") {
-        // Output-validator retry (ADR-0037) discarding a flagged completed
-        // reply — see StreamChunk in base.ts.
-        run.final_text = "";
-    } else if (chunk.type === "tool_call") {
-        const id = chunk.data.id;
-        if (id) {
-            run.inflight_tools.add(id);
-            run.tool_started_at.set(id, Date.now());
-        }
-    } else if (chunk.type === "tool_result") {
-        const id = chunk.data.id;
-        if (id) {
-            run.inflight_tools.delete(id);
-            const startedAt = run.tool_started_at.get(id);
-            if (startedAt !== undefined) {
-                run.tool_time_ms_done += Math.max(0, Date.now() - startedAt);
-                run.tool_started_at.delete(id);
-                // The tool just gave the agent its budget back; re-arm the
-                // wall-clock watchdog against the new effective elapsed.
-                scheduleMaxWatchdog(run);
-            }
-        }
-    }
-    if (run.events.length < MAX_BUFFERED) {
-        run.events.push(chunk);
-    }
-    for (const fn of run.subscribers){
-        try {
-            fn(chunk);
-        } catch  {}
-    }
-}
-function finishRun(run, status) {
-    // Identity-check: a stale run finishing late must not flip the
-    // replacement's status or evict it from the registry.
-    if (runs.get(run.thread_id) !== run) return;
-    run.status = status;
-    run.finished_at = Date.now();
-    // Drop subscribers — late attachers should NOT keep getting events on a
-    // dead run. They'll get the buffered events on subscribe and that's it.
-    run.subscribers.clear();
-    // Auto-evict after TTL so memory doesn't grow with every conversation.
-    setTimeout(()=>{
-        const cur = runs.get(run.thread_id);
-        if (cur === run) runs.delete(run.thread_id);
-    }, RECENT_TTL_MS).unref?.();
-}
-function getRun(thread_id) {
-    return runs.get(thread_id) ?? null;
-}
-// Signal the agent stream to cancel. The stream loop in the route is wired
-// to listen on the AbortController and exit early, emitting an error chunk
-// the client (and the queue-drain hook) can react to. Idempotent.
-function abortRun(thread_id, reason = "user_interrupted") {
-    const run = runs.get(thread_id);
-    if (!run || run.status !== "running") return false;
-    if (!run.abort.signal.aborted) {
-        try {
-            run.abort.abort(reason);
-        } catch  {}
-    }
-    return true;
-}
-// Queue a user message typed while `thread_id` is streaming (ADR-0080).
-// Returns false when there is nothing to steer, so the caller can fall back
-// to starting a fresh turn.
-function pushSteering(thread_id, text) {
-    const run = runs.get(thread_id);
-    if (!run || run.status !== "running" || run.abort.signal.aborted) return false;
-    const trimmed = text.trim();
-    if (!trimmed) return false;
-    run.steering.push(trimmed);
-    return true;
-}
-// Take everything queued so far, in arrival order. Deliberately not merged
-// into a summary — collapsing several messages loses the user's intent.
-function drainSteering(thread_id) {
-    const run = runs.get(thread_id);
-    if (!run || run.steering.length === 0) return [];
-    return run.steering.splice(0, run.steering.length);
-}
-// Abort every currently-running run. Used by the graceful-shutdown path so
-// LangGraph stream loops bail out instead of continuing past process exit.
-// Returns the number of runs that were signalled.
-function abortAllRuns(reason = "server_shutdown") {
-    let count = 0;
-    for (const run of runs.values()){
-        if (run.status !== "running") continue;
-        if (run.abort.signal.aborted) continue;
-        try {
-            run.abort.abort(reason);
-            count++;
-        } catch  {}
-    }
-    return count;
-}
-// Poll until every run has transitioned out of "running" (or until the
-// caller-supplied deadline elapses). Used during graceful shutdown after
-// `abortAllRuns()` so the stream `finally` blocks have a chance to flush
-// the trailing error chunk and call `finishRun()`. Resolves to the count
-// of runs still stuck in "running" when the deadline hit (0 = clean).
-async function waitForRunsToSettle(timeoutMs) {
-    const deadline = Date.now() + Math.max(0, timeoutMs);
-    while(Date.now() < deadline){
-        let stillRunning = 0;
-        for (const run of runs.values())if (run.status === "running") stillRunning++;
-        if (stillRunning === 0) return 0;
-        await new Promise((resolve)=>setTimeout(resolve, 50));
-    }
-    let stillRunning = 0;
-    for (const run of runs.values())if (run.status === "running") stillRunning++;
-    return stillRunning;
-}
-// Replays buffered events synchronously, then subscribes for live ones.
-// Returns an unsubscribe fn. Caller is responsible for calling it.
-function subscribe(thread_id, onEvent) {
-    const run = runs.get(thread_id);
-    if (!run) return {
-        run: null,
-        unsubscribe: ()=>{}
-    };
-    // Replay buffered events first (so the new subscriber catches up).
-    for (const ev of run.events){
-        try {
-            onEvent(ev);
-        } catch  {}
-    }
-    if (run.status !== "running") {
-        return {
-            run,
-            unsubscribe: ()=>{}
-        };
-    }
-    run.subscribers.add(onEvent);
-    return {
-        run,
-        unsubscribe: ()=>{
-            run.subscribers.delete(onEvent);
-        }
-    };
-}
-
-
 /***/ }),
 
 /***/ 69428:
@@ -17977,7 +17055,7 @@ function persistAssistantDraftChunk(draft, chunk) {
 
 /***/ }),
 
-/***/ 90424:
+/***/ 91388:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 
@@ -20133,8 +19211,8 @@ var registry = __webpack_require__(32068);
 var attachments_reference = __webpack_require__(43424);
 // EXTERNAL MODULE: ./lib/agents/thread-compaction.ts
 var thread_compaction = __webpack_require__(5209);
-// EXTERNAL MODULE: ./lib/agents/warm-summary-background.ts
-var warm_summary_background = __webpack_require__(79640);
+// EXTERNAL MODULE: ./lib/agents/warm-summary-background.ts + 1 modules
+var warm_summary_background = __webpack_require__(36923);
 // EXTERNAL MODULE: ./lib/agents/context-boundary.ts
 var context_boundary = __webpack_require__(39583);
 // EXTERNAL MODULE: ./lib/api/foreground-presence.ts
@@ -20311,6 +19389,194 @@ const SUMMARY_PATTERNS = [
 
 
 
+;// ./lib/agents/workflow-step-retry.ts
+// Workflow-step contract enforcement. Every workflow_progress step promises
+// an input, an output, and a validation check; a model can still end a turn
+// with a rejected update, a step left mid-flight, or a step whose validation
+// failed. This module detects those breaches from the turn's own tool results
+// (code, not model judgement) and builds the targeted auto-retry nudge.
+/** Total attempts per step: the original attempt plus two automatic retries. */ const WORKFLOW_STEP_MAX_ATTEMPTS = 3;
+const WORKFLOW_STEP_AUTO_RETRIES = WORKFLOW_STEP_MAX_ATTEMPTS - 1;
+/** Hard cap on automatic workflow retries in one turn, across all steps. */ const WORKFLOW_TURN_AUTO_RETRY_LIMIT = 6;
+function asObject(value) {
+    if (typeof value === "string") {
+        try {
+            return asObject(JSON.parse(value));
+        } catch  {
+            return null;
+        }
+    }
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        const obj = value;
+        // LangChain ToolMessage-ish wrappers carry the JSON string in `content`
+        // or `kwargs.content`.
+        if (obj.workflow_id === undefined) {
+            // invoke_tool envelope: { ok, tool, status, result }.
+            if (obj.tool === "workflow_progress" && obj.result !== undefined) return asObject(obj.result);
+            const kwargs = asPlainObject(obj.kwargs);
+            const content = obj.content ?? kwargs?.content;
+            if (typeof content === "string") return asObject(content);
+        }
+        return obj;
+    }
+    return null;
+}
+function asPlainObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function str(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+/** Normalizes a direct workflow_progress call or an invoke_tool proxy of one. */ function workflowProgressArgs(name, args) {
+    const obj = asPlainObject(args);
+    if (!obj) return null;
+    if (name === "workflow_progress") return obj;
+    if (name === "invoke_tool" && obj.name === "workflow_progress") {
+        const inner = obj.args_json ?? obj.args;
+        return asObject(inner);
+    }
+    return null;
+}
+function labelFor(itemId, items) {
+    if (!itemId) return "workflow update";
+    if (Array.isArray(items)) {
+        for (const raw of items){
+            const item = asPlainObject(raw);
+            if (item?.id === itemId && str(item.label)) return str(item.label);
+        }
+    }
+    return itemId.replace(/[_-]/g, " ");
+}
+function rejectedItemId(args) {
+    if (!args) return null;
+    if (str(args.item_id)) return str(args.item_id);
+    if (Array.isArray(args.items)) {
+        for (const raw of args.items){
+            const item = asPlainObject(raw);
+            if (item?.status === "done" && !str(item.validation_evidence) && str(item.id)) return str(item.id);
+        }
+    }
+    return null;
+}
+/**
+ * Returns the contract breaches still standing at the end of the turn, in
+ * the order the workflows were last touched. A later accepted update for the
+ * same workflow clears an earlier rejection.
+ */ function collectWorkflowContractFailures(observations) {
+    const latest = new Map();
+    for (const { args, result } of observations){
+        const payload = asObject(result);
+        const callArgs = asPlainObject(args);
+        const workflowId = str(payload?.workflow_id) ?? str(callArgs?.workflow_id);
+        if (!workflowId) continue;
+        const previous = latest.get(workflowId) ?? {
+            rejected: null,
+            checklist: [],
+            phase: null,
+            error: null,
+            needsUser: new Set()
+        };
+        latest.delete(workflowId);
+        if (payload?.ok === false) {
+            const itemId = rejectedItemId(callArgs);
+            latest.set(workflowId, {
+                ...previous,
+                rejected: {
+                    itemId,
+                    label: labelFor(itemId, callArgs?.items ?? previous.checklist),
+                    error: str(payload.error) ?? "the update was rejected"
+                }
+            });
+            continue;
+        }
+        const state = asPlainObject(payload?.state);
+        const needsUser = new Set(previous.needsUser);
+        const updatedItemId = str(callArgs?.item_id);
+        if (updatedItemId) {
+            if (callArgs?.needs_user === true) needsUser.add(updatedItemId);
+            else needsUser.delete(updatedItemId);
+        }
+        latest.set(workflowId, {
+            rejected: null,
+            checklist: Array.isArray(state?.checklist) ? state.checklist : previous.checklist,
+            phase: typeof state?.phase === "string" ? state.phase : null,
+            error: str(state?.error),
+            needsUser
+        });
+    }
+    const failures = [];
+    for (const [workflowId, entry] of latest){
+        if (entry.rejected) {
+            const { itemId, label, error } = entry.rejected;
+            failures.push({
+                key: `${workflowId}:${itemId ?? "*"}`,
+                workflowId,
+                itemId,
+                label,
+                reason: `workflow_progress rejected the update: ${error}`
+            });
+            continue;
+        }
+        if (entry.phase === "complete") continue;
+        for (const raw of entry.checklist){
+            const item = asPlainObject(raw);
+            const itemId = str(item?.id);
+            if (!item || !itemId || item.needs_user === true || entry.needsUser.has(itemId)) continue;
+            const label = str(item.label) ?? itemId;
+            if (item.status === "checking") {
+                failures.push({
+                    key: `${workflowId}:${itemId}`,
+                    workflowId,
+                    itemId,
+                    label,
+                    reason: "the step was started but the turn ended before its output was validated"
+                });
+            } else if (item.status === "needs_attention") {
+                const why = entry.error;
+                failures.push({
+                    key: `${workflowId}:${itemId}`,
+                    workflowId,
+                    itemId,
+                    label,
+                    reason: `the step's validation did not pass (needs_attention${why ? `: ${why}` : ""})`
+                });
+            }
+        }
+    }
+    return failures;
+}
+/** Splits failures into those with automatic retries left and those exhausted. */ function planWorkflowStepRetries(failures, spent = {}) {
+    const retry = [];
+    const exhausted = [];
+    for (const failure of failures){
+        const used = spent[failure.key] ?? 0;
+        if (used < WORKFLOW_STEP_AUTO_RETRIES) retry.push({
+            ...failure,
+            attempt: used + 2
+        });
+        else exhausted.push(failure);
+    }
+    return {
+        retry,
+        exhausted
+    };
+}
+function workflowStepRetryInstruction(workflowId, itemId, label) {
+    if (!itemId) {
+        return `Resend the \`workflow_progress\` update for workflow \`${workflowId}\` so it satisfies the contract.`;
+    }
+    const progressUpdate = workflowId === "version_adoption" ? `Call \`workflow_progress\` with \`workflow_id: "version_adoption"\`, \`item_id: "${itemId}"\`, and \`status: "checking"\`` : `Call \`workflow_progress\` for workflow \`${workflowId}\` with the complete items snapshot, setting this step to \`checking\``;
+    return `${progressUpdate}, then redo "${label}" from its stated input and run its validation again. Finally mark it \`done\` with newly observed \`validation_evidence\`, or \`needs_attention\` with the reason.`;
+}
+function buildWorkflowStepRetryNudge(retries) {
+    const lines = retries.map((failure)=>`- "${failure.label}" in \`${failure.workflowId}\` (attempt ${failure.attempt} of ${WORKFLOW_STEP_MAX_ATTEMPTS}): ${failure.reason}. ${workflowStepRetryInstruction(failure.workflowId, failure.itemId, failure.label)}`);
+    return [
+        `↻ Auto-retry: ${retries.length === 1 ? "a workflow step has" : `${retries.length} workflow steps have`} not met the step contract (input → output → validation):`,
+        ...lines,
+        "Work only on these steps and leave the others unchanged. Do not reuse earlier evidence or claim a result you did not observe. If a step is genuinely paused for the user's approval or input, mark it `needs_attention` with `needs_user: true` and say what you need instead of retrying."
+    ].join("\n");
+}
+
 // EXTERNAL MODULE: external "node:os"
 var external_node_os_ = __webpack_require__(48161);
 var external_node_os_default = /*#__PURE__*/__webpack_require__.n(external_node_os_);
@@ -20769,7 +20035,7 @@ function buildSharedToolCatalogContext() {
     return [
         "--- Tool usage SOP ---",
         "Static cross-agent procedure. The per-turn bound list and counts appear later under \"Enabled tools\".",
-        `0. Classify the request. Informational answers may be direct; read/retrieve requests need a read tool; write/change requests need a state-changing tool; destructive requests also need the required confirmation. ${(0,action_vocabulary/* formatActionVocabularyInstruction */.q2)()} For substantial tasks with several dependent phases, likely cross-turn progress, or explicit verification, use workflow_progress to create and update a concise checklist; skip simple tasks and work already covered by native tool progress. This contract applies to every built-in Jarela workflow and every workflow you create or follow: each step must state its input, expected output, and concrete validation criteria; validate each output before passing it to a later step. Prefer executable checks whenever code can verify the result, and record observed validation_evidence before marking an item done. Keep a stable workflow_id, send the complete current item list on each update, and keep secrets or private data out of checklist fields. Use needs_attention for blockers; set phase=complete only when all items are done or skipped. Never claim an output or validation result that you did not observe.`,
+        `0. Classify the request. Informational answers may be direct; read/retrieve requests need a read tool; write/change requests need a state-changing tool; destructive requests also need the required confirmation. ${(0,action_vocabulary/* formatActionVocabularyInstruction */.q2)()} For substantial tasks with several dependent phases, likely cross-turn progress, or explicit verification, use workflow_progress to create and update a concise checklist; skip simple tasks and work already covered by native tool progress. This contract applies to every built-in Jarela workflow and every workflow you create or follow: each step must state its input, expected output, and concrete validation criteria; validate each output before passing it to a later step. Prefer executable checks whenever code can verify the result, and record observed validation_evidence before marking an item done. Keep a stable workflow_id, send the complete current item list on each update, and keep secrets or private data out of checklist fields. Use needs_attention for blockers, with needs_user=true when only the user can unblock the step; a rejected update or a step you leave checking or needs_attention without needs_user is retried automatically, up to 3 attempts per step. Set phase=complete only when all items are done or skipped. Never claim an output or validation result that you did not observe.`,
         "1. Bound first. If a tool listed under \"Enabled tools\" fits the task, call it directly.",
         "2. Otherwise look it up. Names of permitted tools that are not bound this turn are listed after the bound tools under \"Enabled tools\", capped, with no definitions. A name that is not listed there may still exist, so never conclude a capability does not exist from the bound list alone. Call list_tools with service/object/action keywords: scope=\"enabled\" searches executable tools, scope=\"all\" also returns disabled, unavailable and cap-omitted tools with flags.",
         "3. Named target. When a skill, harness or instruction names an exact tool, call list_tools names=[\"exact_name\"] include_schema=true instead of a keyword query. Exact lookup ignores every other filter, so it also describes tools you cannot currently execute.",
@@ -21023,11 +20289,16 @@ function buildMemoryContext(budget) {
     const writeGuidance = policy === "important" ? "Store only explicit preferences, verified facts, durable decisions, constraints, and project context. Do not store inferred details, routine status, contacts, or transient tasks." : policy === "detailed" ? "Store relevant durable details, including recurring workflow context and task state, but never secrets or raw private transcripts. Prefer concise records over duplicates." : "Store explicit preferences, verified facts, durable decisions, constraints, and project context. Store task details only when they will matter across sessions.";
     return [
         "--- Memory & recall ---",
-        "You have long-term memory across sessions.",
+        "You have long-term memory across sessions, shared with every other Jarela agent. A record you save is available to other agents immediately. Background compaction also extracts facts later, but it runs late and can miss details, so it is a backstop, not your save step.",
         `- Hot conversation history is budgeted by model context size: ${(0,context_budget/* formatContextBudgetSummary */.qm)(budget)}.`,
         `- Active memory policy: ${policy}. ${writeGuidance}`,
-        "- Use memory_upsert proactively for structured records. Use namespace='facts', concise tags, confidence='explicit' for user-stated information, observed_at when the information was true, and expires_at for temporary facts. Keep memory_write only for legacy/free-form notes.",
-        "- Use memory_search proactively when relevant saved facts or prior conversations could help. Use memory_read / memory_list to inspect known entries."
+        "- Use memory_search proactively when relevant saved facts or prior conversations could help. Use memory_read / memory_list to inspect known entries.",
+        "Proactive save procedure — run it whenever information fits the active memory policy, without waiting to be asked:",
+        "1. Trigger: the user states a preference, a fact about themselves or their work, a decision, a constraint, or a correction to something saved; or a tool result verifies a durable fact. Routine status, one-off chatter, secrets, credentials, and raw transcripts never qualify.",
+        "2. Check: memory_search (or memory_read for a known key) for an existing record on the same subject. Update that stable key rather than creating a duplicate or contradictory copy.",
+        "3. Write: call memory_upsert in the same turn, before your final reply, with namespace='facts', a stable descriptive key, standalone content, concise tags, confidence='explicit' for user-stated information ('verified' when tool-backed, 'inferred' only when useful and reversible), observed_at when the information became true, and expires_at for temporary facts. Keep memory_write only for legacy/free-form notes.",
+        "4. Validate: the memory_upsert result must contain ok:true and the key you sent. If it failed, correct the arguments and retry once; if it still fails, tell the user it was not saved.",
+        "5. Cite: end your reply with one short line naming each saved key, for example 'Saved to memory: facts/answer-format-preference'. Omit the line when nothing was saved."
     ].join("\n");
 }
 function buildAutomaticRecallGuidance(autoRecallEnabled, autoFactsEnabled) {
@@ -21893,6 +21164,7 @@ var transaction = __webpack_require__(99043);
 
 
 
+
 
 
 const SELF_CONFIG_TOOLS = [
@@ -22702,6 +21974,10 @@ async function* stallRetryStream(inner, originalReq, allowedTools, retriesLeft,
     // turns where the model's claimed action didn't actually happen.
     const toolCallIds = new Map();
     const failedProxyCallIds = new Set();
+    // workflow_progress calls (direct or proxied) awaiting their result, so the
+    // step contract can be checked from observed tool output at turn end.
+    const pendingWorkflowArgs = new Map();
+    const workflowObservations = [];
     let loopedToolName = null;
     let doneChunk = null;
     let sawError = false;
@@ -22717,7 +21993,11 @@ async function* stallRetryStream(inner, originalReq, allowedTools, retriesLeft,
             const name = unwrapInvokedToolName(rawName, args);
             if (name) {
                 toolNames.push(name);
-                if (typeof data?.id === "string") toolCallIds.set(data.id, name);
+                if (typeof data?.id === "string") {
+                    toolCallIds.set(data.id, name);
+                    const workflowArgs = workflowProgressArgs(rawName, args);
+                    if (workflowArgs) pendingWorkflowArgs.set(data.id, workflowArgs);
+                }
                 const sig = toolCallSignature(rawName, args);
                 const count = (signatureCounts.get(sig) ?? 0) + 1;
                 signatureCounts.set(sig, count);
@@ -22745,6 +22025,13 @@ async function* stallRetryStream(inner, originalReq, allowedTools, retriesLeft,
                     failedProxyCallIds.add(data.id);
                 }
             }
+            if (typeof data?.id === "string" && pendingWorkflowArgs.has(data.id)) {
+                workflowObservations.push({
+                    args: pendingWorkflowArgs.get(data.id),
+                    result: data.result
+                });
+                pendingWorkflowArgs.delete(data.id);
+            }
             const summary = summarizeRetryValue(data?.result).trim();
             if (summary) {
                 const clipped = summary.length > 240 ? `${summary.slice(0, 237)}...` : summary;
@@ -22860,6 +22147,10 @@ async function* stallRetryStream(inner, originalReq, allowedTools, retriesLeft,
     }
     const citationFail = uncitedHighClaims.length > 0;
     if (!stalled && !looped && fabrication.ok && !citationFail) {
+        if (!sawError && workflowObservations.length > 0) {
+            yield* workflowStepRetryStream(workflowObservations, originalReq, retriesLeft, attemptAbort, doneChunk, textBuf, toolNames, toolResultSummaries);
+            return;
+        }
         if (doneChunk) yield doneChunk;
         return;
     }
@@ -22978,6 +22269,64 @@ async function* stallRetryStream(inner, originalReq, allowedTools, retriesLeft,
         }
     }
 }
+// Workflow step contract auto-retry. Runs only after every other quality
+// gate passed, and has its own per-step budget (WORKFLOW_STEP_MAX_ATTEMPTS)
+// so a stall retry earlier in the turn never starves it. The retry is an
+// append-mode continuation: the turn's work stays visible, followed by the
+// model redoing only the failed steps.
+async function* workflowStepRetryStream(observations, originalReq, stallRetriesLeft, attemptAbort, doneChunk, textBuf, toolNames, toolResultSummaries) {
+    const spent = originalReq._workflow_step_retries ?? {};
+    const failures = collectWorkflowContractFailures(observations);
+    const { retry, exhausted } = planWorkflowStepRetries(failures, spent);
+    const spentTotal = Object.values(spent).reduce((sum, n)=>sum + n, 0);
+    if (retry.length === 0 || spentTotal >= WORKFLOW_TURN_AUTO_RETRY_LIMIT) {
+        const unresolved = [
+            ...exhausted,
+            ...retry
+        ];
+        if (unresolved.length > 0) {
+            console.warn(`[workflow-retry] contract still failing after auto-retry: ${unresolved.map((f)=>f.key).join(", ")} thread=${originalReq.thread_id}`);
+            yield {
+                type: "text_delta",
+                data: {
+                    delta: `\n\n*⚠️ Workflow step${unresolved.length === 1 ? "" : "s"} still failing the step contract after automatic retries: ${unresolved.slice(0, 4).map((f)=>`"${f.label}"`).join(", ")}. Use the step's retry button or review it manually.*`
+                }
+            };
+        }
+        if (doneChunk) yield doneChunk;
+        return;
+    }
+    console.warn(`[workflow-retry] retrying ${retry.map((f)=>`${f.key}#${f.attempt}`).join(", ")} thread=${originalReq.thread_id}`);
+    yield {
+        type: "text_delta",
+        data: {
+            delta: "\n\n↻ "
+        }
+    };
+    const nudge = buildWorkflowStepRetryNudge(retry);
+    const retryContext = buildRetryContextSummary(textBuf, [
+        ...toolNames
+    ], [
+        ...toolResultSummaries
+    ]);
+    const nudgeWithContext = retryContext ? `${nudge}\n\n${retryContext}` : nudge;
+    const nextSpent = {
+        ...spent
+    };
+    for (const failure of retry)nextSpent[failure.key] = (nextSpent[failure.key] ?? 0) + 1;
+    attemptAbort.abort("workflow_step_retry");
+    const next = await prepareThreadRun({
+        ...originalReq,
+        message: nudgeWithContext,
+        attachments: undefined,
+        _stall_retries_left: stallRetriesLeft,
+        _workflow_step_retries: nextSpent,
+        _retry_count: (originalReq._retry_count ?? 0) + 1,
+        _skip_persist_message: true,
+        _history_append_message: nudgeWithContext
+    });
+    for await (const chunk of next.stream)yield chunk;
+}
 // Footer appended to an assistant message that was cut off by the user
 // (Stop button or steer-while-streaming). Both human readers and the LLM
 // see this on the next turn — the agent treats it as "the previous reply
@@ -23832,4 +23181,4 @@ function recordWatcherPollError(id, error) {
 
 };
 ;
-//# sourceMappingURL=424.js.map
+//# sourceMappingURL=1388.js.map