@supergrowthai/tq 1.0.11 → 1.0.13

package/dist/index.cjs

@@ -45,12 +45,13 @@ var __callDispose = (stack, error, hasError) => {
   return next();
 };
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const PrismaAdapter = require("./PrismaAdapter-CvM_XNtE.cjs");
+const PrismaAdapter = require("./PrismaAdapter-CUIWhjms.cjs");
 const mq = require("@supergrowthai/mq");
-const client = require("./client-DgdG7pT6.cjs");
+const client = require("./client-BxG7LzLv.cjs");
 const utils_taskIdGen = require("./utils/task-id-gen.cjs");
 const core_Actions = require("./core/Actions.cjs");
-const core_async_AsyncActions = require("./core/async/AsyncActions.cjs");
+const core_async_AsyncActions = require("./AsyncActions-BOO1ikWz.cjs");
+const node_async_hooks = require("node:async_hooks");
 const moment = require("moment");
 const os = require("os");
 const core_async_AsyncTaskManager = require("./core/async/AsyncTaskManager.cjs");
@@ -161,7 +162,10 @@ class TaskStore {
       created_at: task.created_at || /* @__PURE__ */ new Date(),
       updated_at: task.updated_at || /* @__PURE__ */ new Date(),
       processing_started_at: task.processing_started_at || /* @__PURE__ */ new Date(),
-      force_store: task.force_store
+      force_store: task.force_store,
+      metadata: task.metadata,
+      partition_key: task.partition_key,
+      entity: task.entity
     }));
     return await this.databaseAdapter.addTasksToScheduled(transformedTasks);
   }
@@ -669,14 +673,25 @@ class DisposableLockBatch {
     );
   }
 }
+const als = new node_async_hooks.AsyncLocalStorage();
+client.Logger.setContextProvider(() => als.getStore());
+function runWithLogContext(store, fn) {
+  return als.run(store, fn);
+}
+function getLogContext() {
+  return als.getStore();
+}
 class TaskRunner {
-  constructor(messageQueue, taskQueue, taskStore, cacheProvider, generateId, lifecycleProvider, lifecycleConfig) {
+  constructor(messageQueue, taskQueue, taskStore, cacheProvider, generateId, lifecycleProvider, lifecycleConfig, entityProjection, entityProjectionConfig, flowMiddleware) {
     this.messageQueue = messageQueue;
     this.taskQueue = taskQueue;
     this.taskStore = taskStore;
     this.generateId = generateId;
     this.lifecycleProvider = lifecycleProvider;
     this.lifecycleConfig = lifecycleConfig;
+    this.entityProjection = entityProjection;
+    this.entityProjectionConfig = entityProjectionConfig;
+    this.flowMiddleware = flowMiddleware;
     this.taskStartTimes = /* @__PURE__ */ new Map();
     this.logger = new client.Logger("TaskRunner", client.LogLevel.INFO);
     this.lockManager = new LockManager(cacheProvider, {
@@ -684,6 +699,29 @@ class TaskRunner {
       defaultTimeout: 30 * 60
     });
   }
+  // ============ Log Context Helpers (RFC-005) ============
+  /**
+   * Build ALS log store for a single task execution.
+   * Runtime keys (task_id, task_type, worker_id) override user-supplied log_context.
+   */
+  buildLogStore(task, workerId) {
+    return {
+      ...task.metadata?.log_context || {},
+      task_id: task.id?.toString() || utils_taskIdGen.tId(task),
+      task_type: task.type,
+      worker_id: workerId
+    };
+  }
+  /**
+   * Build ALS log store for a multi-task (batch) execution.
+   * Only runtime keys — no user log_context (ambiguous across tasks).
+   */
+  buildBatchLogStore(tasks, workerId) {
+    return {
+      worker_id: workerId,
+      batch_size: String(tasks.length)
+    };
+  }
   // ============ Lifecycle Helpers ============
   async run(taskRunnerId, tasksRaw, asyncTaskManager, abortSignal) {
     var _stack = [];
@@ -692,7 +730,7 @@ class TaskRunner {
       this.logger.info(`[${taskRunnerId}] Processing ${tasksRaw.length} provided tasks`);
       if (abortSignal?.aborted) {
         this.logger.info(`[${taskRunnerId}] AbortSignal already aborted, returning empty results`);
-        return { successTasks: [], failedTasks: [], newTasks: [], ignoredTasks: [], asyncTasks: [] };
+        return { successTasks: [], failedTasks: [], newTasks: [], ignoredTasks: [], asyncTasks: [], flowProjections: [] };
       }
       const tasks = await this.lockManager.filterLocked(tasksRaw, utils_taskIdGen.tId);
       this.logger.info(`[${taskRunnerId}] Found ${tasks.length} not locked tasks to process`);
@@ -713,6 +751,14 @@ class TaskRunner {
         return acc;
       }, []);
       this.logger.info(`[${taskRunnerId}] Task groups: ${groupedTasksArray.map((g) => `${g.type}: ${g.tasks.length}`).join(", ")}`);
+      if (this.entityProjection) {
+        try {
+          const processingProjections = tasks.filter((t) => t.entity && !t.execution_stats?.retry_count).map((t) => core_async_AsyncActions.buildProjection(t, "processing", { includePayload: this.entityProjectionConfig?.includePayload })).filter((p) => p !== null);
+          await core_async_AsyncActions.syncProjections(processingProjections, this.entityProjection, this.logger);
+        } catch (err) {
+          this.logger.error(`[TQ] Entity projection failed (non-fatal): ${err}`);
+        }
+      }
       const actions = new core_Actions.Actions(taskRunnerId);
       const asyncTasks = [];
       const processedTaskIds = /* @__PURE__ */ new Set();
@@ -749,7 +795,18 @@ class TaskRunner {
         taskGroup.tasks.forEach((task) => processedTaskIds.add(utils_taskIdGen.tId(task)));
         this.logger.info(`[${taskRunnerId}] Processing ${taskGroup.tasks.length} tasks of type: ${taskGroup.type}`);
         if (executor.multiple) {
-          await executor.onTasks(taskGroup.tasks, actions).catch((err) => this.logger.error(`[${taskRunnerId}] executor.onTasks failed: ${err}`));
+          const batchStore = this.buildBatchLogStore(taskGroup.tasks, taskRunnerId);
+          await runWithLogContext(
+            batchStore,
+            () => executor.onTasks(taskGroup.tasks, actions).catch((err) => {
+              this.logger.error(`[${taskRunnerId}] executor.onTasks failed: ${err}`);
+              for (const task of taskGroup.tasks) {
+                if (actions.getTaskResultStatus(utils_taskIdGen.tId(task)) === "pending") {
+                  actions.fail(task, err instanceof Error ? err : new Error(String(err)));
+                }
+              }
+            })
+          );
         } else {
           if (executor.parallel) {
             const chunks = chunk(taskGroup.tasks, executor.chunkSize);
@@ -760,14 +817,24 @@ class TaskRunner {
               }
               const chunkPromises = [];
               for (let j = 0; j < taskChunk.length; j++) {
-                const taskActions = actions.forkForTask(taskChunk[j]);
-                chunkPromises.push(executor.onTask(taskChunk[j], taskActions).catch((err) => this.logger.error(`[${taskRunnerId}] executor.onTask failed: ${err}`)));
+                const task = taskChunk[j];
+                const taskActions = actions.forkForTask(task);
+                const logStore = this.buildLogStore(task, taskRunnerId);
+                chunkPromises.push(runWithLogContext(
+                  logStore,
+                  () => executor.onTask(task, taskActions).catch((err) => {
+                    this.logger.error(`[${taskRunnerId}] executor.onTask failed: ${err}`);
+                    if (actions.getTaskResultStatus(utils_taskIdGen.tId(task)) === "pending") {
+                      actions.fail(task, err instanceof Error ? err : new Error(String(err)));
+                    }
+                  })
+                ));
               }
               await Promise.all(chunkPromises);
               for (const task of taskChunk) {
                 const resultStatus = actions.getTaskResultStatus(utils_taskIdGen.tId(task));
                 if (resultStatus === "success") {
-                  this.emitTaskCompleted(task, taskRunnerId);
+                  this.emitTaskCompleted(task, taskRunnerId, actions.getTaskResult(utils_taskIdGen.tId(task)));
                 } else if (resultStatus === "fail") {
                   const retryCount = task.execution_stats?.retry_count || 0;
                   const maxRetries = task.retries ?? executor.default_retries ?? 0;
@@ -783,10 +850,19 @@ class TaskRunner {
               if (!timeoutMs) {
                 this.emitTaskStarted(task, taskRunnerId);
                 const taskActions = actions.forkForTask(task);
-                await executor.onTask(task, taskActions).catch((err) => this.logger.error(`[${taskRunnerId}] executor.onTask failed: ${err}`));
+                const logStore = this.buildLogStore(task, taskRunnerId);
+                await runWithLogContext(
+                  logStore,
+                  () => executor.onTask(task, taskActions).catch((err) => {
+                    this.logger.error(`[${taskRunnerId}] executor.onTask failed: ${err}`);
+                    if (actions.getTaskResultStatus(utils_taskIdGen.tId(task)) === "pending") {
+                      actions.fail(task, err instanceof Error ? err : new Error(String(err)));
+                    }
+                  })
+                );
                 const resultStatus = actions.getTaskResultStatus(utils_taskIdGen.tId(task));
                 if (resultStatus === "success") {
-                  this.emitTaskCompleted(task, taskRunnerId);
+                  this.emitTaskCompleted(task, taskRunnerId, actions.getTaskResult(utils_taskIdGen.tId(task)));
                 } else if (resultStatus === "fail") {
                   const retryCount = task.execution_stats?.retry_count || 0;
                   const maxRetries = task.retries ?? executor.default_retries ?? 0;
@@ -797,9 +873,16 @@ class TaskRunner {
                 this.emitTaskStarted(task, taskRunnerId);
                 const startTime = Date.now();
                 const taskActions = actions.forkForTask(task);
-                const taskPromise = executor.onTask(task, taskActions).catch((err) => {
-                  this.logger.error(`[${taskRunnerId}] executor.onTask failed: ${err}`);
-                });
+                const logStore = this.buildLogStore(task, taskRunnerId);
+                const taskPromise = runWithLogContext(
+                  logStore,
+                  () => executor.onTask(task, taskActions).catch((err) => {
+                    this.logger.error(`[${taskRunnerId}] executor.onTask failed: ${err}`);
+                    if (actions.getTaskResultStatus(utils_taskIdGen.tId(task)) === "pending") {
+                      actions.fail(task, err instanceof Error ? err : new Error(String(err)));
+                    }
+                  })
+                );
                 let timeoutId;
                 const timeoutPromise = new Promise((resolve) => {
                   timeoutId = setTimeout(() => {
@@ -813,7 +896,7 @@ class TaskRunner {
                 if (result !== "~~~timeout") {
                   const resultStatus = actions.getTaskResultStatus(utils_taskIdGen.tId(task));
                   if (resultStatus === "success") {
-                    this.emitTaskCompleted(task, taskRunnerId);
+                    this.emitTaskCompleted(task, taskRunnerId, actions.getTaskResult(utils_taskIdGen.tId(task)));
                   } else if (resultStatus === "fail") {
                     const retryCount = task.execution_stats?.retry_count || 0;
                     const maxRetries = task.retries ?? executor.default_retries ?? 0;
@@ -829,7 +912,15 @@ class TaskRunner {
                   if (!task.id) {
                     this.logger.error(`[${taskRunnerId}] Cannot hand off task without id (type: ${task.type}). Task will continue but won't be tracked.`);
                   } else {
-                    const asyncActions = new core_async_AsyncActions.AsyncActions(this.messageQueue, this.taskStore, this.taskQueue, actions, task, this.generateId);
+                    const asyncLifecycleEmitter = this.lifecycleProvider ? {
+                      onCompleted: (t, result2) => {
+                        this.emitTaskCompleted(t, taskRunnerId, result2);
+                      },
+                      onFailed: (t, error, willRetry) => {
+                        this.emitTaskFailed(t, taskRunnerId, error, willRetry);
+                      }
+                    } : void 0;
+                    const asyncActions = new core_async_AsyncActions.AsyncActions(this.messageQueue, this.taskStore, this.taskQueue, actions, task, this.generateId, asyncLifecycleEmitter, this.entityProjection, this.entityProjectionConfig, this.flowMiddleware);
                     const asyncPromise = taskPromise.finally(async () => {
                       try {
                         await asyncActions.onPromiseFulfilled();
@@ -888,7 +979,8 @@ class TaskRunner {
       attempt: retryCount + 1,
       max_retries: maxRetries,
       scheduled_at: task.created_at || /* @__PURE__ */ new Date(),
-      worker_id: workerId
+      worker_id: workerId,
+      log_context: task.metadata?.log_context
     };
   }
   emitTaskStarted(task, workerId) {
@@ -985,7 +1077,10 @@ class TaskHandler {
       this.cacheAdapter,
       databaseAdapter.generateId.bind(databaseAdapter),
       this.config.lifecycleProvider,
-      this.config.lifecycle
+      this.config.lifecycle,
+      this.config.entityProjection,
+      this.config.entityProjectionConfig,
+      this.config.flowMiddleware
     );
   }
   // ============ Lifecycle Event Helpers ============
@@ -995,7 +1090,38 @@ class TaskHandler {
   get workerProvider() {
     return this.config.workerProvider;
   }
+  get entityProjectionProvider() {
+    return this.config.entityProjection;
+  }
+  /**
+   * Validate and sanitize log_context on a task (RFC-005).
+   * - >10 keys: truncate to first 10 alphabetically, warn
+   * - >1024 bytes total: drop entire context, warn
+   */
+  validateLogContext(task) {
+    const logCtx = task.metadata?.log_context;
+    if (!logCtx) return task;
+    let validatedCtx = logCtx;
+    const keys = Object.keys(logCtx).sort();
+    if (keys.length > 10) {
+      this.logger.warn(`[TQ] log_context has ${keys.length} keys (max 10), truncating for task type ${task.type}`);
+      const truncated = {};
+      for (let i = 0; i < 10; i++) truncated[keys[i]] = logCtx[keys[i]];
+      validatedCtx = truncated;
+    }
+    const serialized = JSON.stringify(validatedCtx);
+    if (serialized.length > 1024) {
+      this.logger.warn(`[TQ] log_context exceeds 1KB (${serialized.length} chars), dropping for task type ${task.type}`);
+      const { log_context: _, ...restMeta } = task.metadata;
+      return { ...task, metadata: Object.keys(restMeta).length > 0 ? restMeta : void 0 };
+    }
+    if (validatedCtx !== logCtx) {
+      return { ...task, metadata: { ...task.metadata, log_context: validatedCtx } };
+    }
+    return task;
+  }
   async addTasks(tasks) {
+    tasks = tasks.map((t) => this.validateLogContext(t));
     const diffedItems = tasks.reduce(
       (acc, { force_store, ...task }) => {
         const currentTime = /* @__PURE__ */ new Date();
@@ -1027,8 +1153,18 @@ class TaskHandler {
         const executor = this.taskQueuesManager.getExecutor(task.queue_id, task.type);
         const shouldStoreOnFailure = executor?.store_on_failure ?? false;
         const id = shouldStoreOnFailure ? { id: this.databaseAdapter.generateId() } : {};
-        return { ...id, ...task };
+        const partitionKey = executor?.getPartitionKey?.(task);
+        return { ...id, ...task, ...partitionKey ? { partition_key: partitionKey } : {} };
       });
+      if (this.entityProjectionProvider) {
+        try {
+          const includePayload = this.config.entityProjectionConfig?.includePayload;
+          const entityProjections = queueTasks.filter((t) => t.entity).map((t) => core_async_AsyncActions.buildProjection(t, "scheduled", { includePayload })).filter((p) => p !== null);
+          await core_async_AsyncActions.syncProjections(entityProjections, this.entityProjectionProvider, this.logger);
+        } catch (err) {
+          this.logger.error(`[TQ] Entity projection failed (non-fatal): ${err}`);
+        }
+      }
       await this.messageQueue.addMessages(queue, queueTasks);
       if (this.lifecycleProvider?.onTaskScheduled) {
         for (const task of queueTasks) {
@@ -1047,8 +1183,18 @@ class TaskHandler {
         return { ...id, ...task, status: "processing", processing_started_at: /* @__PURE__ */ new Date() };
       });
       await this.taskStore.addTasksToScheduled(queueTasks);
+      if (this.entityProjectionProvider) {
+        try {
+          const includePayload = this.config.entityProjectionConfig?.includePayload;
+          const entityProjections = queueTasks.filter((t) => t.entity).map((t) => core_async_AsyncActions.buildProjection(t, "scheduled", { includePayload })).filter((p) => p !== null);
+          await core_async_AsyncActions.syncProjections(entityProjections, this.entityProjectionProvider, this.logger);
+        } catch (err) {
+          this.logger.error(`[TQ] Entity projection failed (non-fatal): ${err}`);
+        }
+      }
+      const mqTasks = queueTasks.map((t) => ({ ...t, status: "scheduled" }));
       try {
-        await this.messageQueue.addMessages(queue, queueTasks);
+        await this.messageQueue.addMessages(queue, mqTasks);
       } catch (mqError) {
         this.logger.error(`MQ write failed for forceStoreImmediate tasks, resetting to scheduled: ${mqError}`);
         const taskIds = queueTasks.map((t) => t.id).filter(Boolean);
@@ -1080,6 +1226,15 @@ class TaskHandler {
         return { ...id, ...task };
       });
       await this.taskStore.addTasksToScheduled(queueTasks);
+      if (this.entityProjectionProvider) {
+        try {
+          const includePayload = this.config.entityProjectionConfig?.includePayload;
+          const entityProjections = queueTasks.filter((t) => t.entity).map((t) => core_async_AsyncActions.buildProjection(t, "scheduled", { includePayload })).filter((p) => p !== null);
+          await core_async_AsyncActions.syncProjections(entityProjections, this.entityProjectionProvider, this.logger);
+        } catch (err) {
+          this.logger.error(`[TQ] Entity projection failed (non-fatal): ${err}`);
+        }
+      }
       if (this.lifecycleProvider?.onTaskScheduled) {
         for (const task of queueTasks) {
           this.emitLifecycleEvent(
@@ -1090,6 +1245,9 @@ class TaskHandler {
       }
     }
   }
+  // TODO(P2): Wrap retry upsert → new tasks → mark failed → mark success in a
+  //   transaction. If an intermediate step fails, tasks can be lost or re-executed
+  //   after 2-day stale recovery. Reorder to mark success first as a quick win.
   async postProcessTasks({
     failedTasks: failedTasksRaw,
     newTasks,
@@ -1097,11 +1255,11 @@ class TaskHandler {
   }) {
     const tasksToRetry = [];
     const finalFailedTasks = [];
-    let discardedTasksCount = 0;
+    const discardedTasks = [];
     const MAX_RETRY_DELAY_MS = 5 * 60 * 1e3;
     for (const task of failedTasksRaw) {
       const taskRetryCount = task.execution_stats && typeof task.execution_stats.retry_count === "number" ? task.execution_stats.retry_count : 0;
-      const taskRetryAfter = task.retry_after || 2e3;
+      const taskRetryAfter = Math.max(task.retry_after || 2e3, 0);
       const calculatedDelay = taskRetryAfter * Math.pow(taskRetryCount + 1, 2);
       const retryAfter = Math.min(calculatedDelay, MAX_RETRY_DELAY_MS);
       const executeAt = Date.now() + retryAfter;
@@ -1143,7 +1301,7 @@ class TaskHandler {
           }]);
         }
       } else {
-        discardedTasksCount++;
+        discardedTasks.push(task);
         this.logger.info(`Discarding task of type ${task.type} after ${taskRetryCount} retries`);
         if (this.lifecycleProvider?.onTaskExhausted) {
           const ctx = this.buildTaskContext(task);
@@ -1164,14 +1322,29 @@ class TaskHandler {
         }
       }
     }
-    if (discardedTasksCount > 0) {
-      await this.trackDiscardedTasks(discardedTasksCount);
+    if (discardedTasks.length > 0) {
+      await this.trackDiscardedTasks(discardedTasks.length);
     }
     if (tasksToRetry.length > 0) {
-      await this.taskStore.updateTasksForRetry(tasksToRetry);
-    }
-    if (newTasks.length > 0) {
-      await this.addTasks(newTasks);
+      const dbRetryTasks = tasksToRetry.map((t) => ({
+        ...t,
+        status: "processing",
+        processing_started_at: /* @__PURE__ */ new Date()
+      }));
+      await this.taskStore.updateTasksForRetry(dbRetryTasks);
+      const retryByQueue = /* @__PURE__ */ new Map();
+      for (const task of tasksToRetry) {
+        const queue = task.queue_id;
+        if (!retryByQueue.has(queue)) retryByQueue.set(queue, []);
+        retryByQueue.get(queue).push(task);
+      }
+      for (const [queue, retryQueueTasks] of retryByQueue) {
+        try {
+          await this.messageQueue.addMessages(queue, retryQueueTasks);
+        } catch (mqErr) {
+          this.logger.error(`[TQ] Failed to re-enqueue retry tasks to MQ (stale recovery will handle): ${mqErr}`);
+        }
+      }
     }
     if (finalFailedTasks.length > 0) {
       await this.taskStore.markTasksAsFailed(finalFailedTasks);
@@ -1179,6 +1352,56 @@ class TaskHandler {
     if (successTasks.length > 0) {
       await this.taskStore.markTasksAsSuccess(successTasks);
     }
+    if (this.entityProjectionProvider) {
+      try {
+        const includePayload = this.config.entityProjectionConfig?.includePayload;
+        const terminalProjections = [];
+        for (const task of successTasks) {
+          const p = core_async_AsyncActions.buildProjection(task, "executed", {
+            includePayload,
+            result: task.execution_result
+          });
+          if (p) terminalProjections.push(p);
+        }
+        for (const task of finalFailedTasks) {
+          const p = core_async_AsyncActions.buildProjection(task, "failed", {
+            includePayload,
+            error: task.execution_stats?.last_error || "Task failed"
+          });
+          if (p) terminalProjections.push(p);
+        }
+        for (const task of discardedTasks) {
+          try {
+            const p = core_async_AsyncActions.buildProjection(task, "failed", {
+              includePayload,
+              error: task.execution_stats?.last_error || "Task exhausted all retries"
+            });
+            if (p) terminalProjections.push(p);
+          } catch (projErr) {
+            this.logger.error(`[TQ] Entity projection build failed (non-fatal): ${projErr}`);
+          }
+        }
+        await core_async_AsyncActions.syncProjections(terminalProjections, this.entityProjectionProvider, this.logger);
+      } catch (err) {
+        this.logger.error(`[TQ] Entity projection failed (non-fatal): ${err}`);
+      }
+    }
+    if (this.config.flowMiddleware) {
+      try {
+        const flowResult = await this.config.flowMiddleware.onPostProcess({ successTasks, failedTasks: finalFailedTasks });
+        if (flowResult.projections.length > 0 && this.entityProjectionProvider) {
+          await core_async_AsyncActions.syncProjections(flowResult.projections, this.entityProjectionProvider, this.logger);
+        }
+        if (flowResult.joinTasks.length > 0) {
+          await this.addTasks(flowResult.joinTasks);
+        }
+      } catch (err) {
+        this.logger.error(`[TQ] Flow middleware failed (non-fatal): ${err}`);
+      }
+    }
+    if (newTasks.length > 0) {
+      await this.addTasks(newTasks);
+    }
   }
   startConsumingTasks(streamName, abortSignal) {
     return this.messageQueue.consumeMessagesStream(streamName, async (id, tasks) => {
@@ -1204,10 +1427,18 @@ class TaskHandler {
         newTasks,
         successTasks,
         asyncTasks,
-        ignoredTasks
+        ignoredTasks,
+        flowProjections
       } = await this.taskRunner.run(id, tasks, this.asyncTaskManager, abortSignal).catch((err) => {
-        this.logger.error("Failed to execute tasks?", err);
-        return { failedTasks: [], newTasks: [], successTasks: [], asyncTasks: [], ignoredTasks: [] };
+        this.logger.error("Failed to execute tasks, returning all as failed for retry:", err);
+        return {
+          failedTasks: tasks,
+          newTasks: [],
+          successTasks: [],
+          asyncTasks: [],
+          ignoredTasks: [],
+          flowProjections: []
+        };
       });
       if (asyncTasks.length > 0 && !this.asyncTaskManager) {
         throw new Error("Async tasks detected but AsyncTaskManager not initialized!");
@@ -1215,7 +1446,9 @@ class TaskHandler {
       if (asyncTasks.length > 0) {
         this.logger.info(`Handling ${asyncTasks.length} async tasks for stream ${streamName}`);
         for (const asyncTask of asyncTasks) {
-          const accepted = this.asyncTaskManager.handoffTask(asyncTask.task, asyncTask.promise);
+          const executor = this.taskQueuesManager.getExecutor(asyncTask.task.queue_id, asyncTask.task.type);
+          const taskTimeout = executor?.asyncConfig?.handoffTimeout ? executor.asyncConfig.handoffTimeout * 2 : void 0;
+          const accepted = this.asyncTaskManager.handoffTask(asyncTask.task, asyncTask.promise, taskTimeout);
           if (!accepted) {
             this.logger.warn(`Async queue full, requeueing task ${asyncTask.task.id} with 30s delay`);
             await this.addTasks([{
@@ -1231,6 +1464,9 @@ class TaskHandler {
           this.logger.error("Failed to mark tasks as ignored", err);
         });
       }
+      if (this.entityProjectionProvider && flowProjections?.length > 0) {
+        await core_async_AsyncActions.syncProjections(flowProjections, this.entityProjectionProvider, this.logger);
+      }
       await this.postProcessTasks({ failedTasks, newTasks, successTasks }).catch((err) => {
         this.logger.error("Failed to postProcessTasks", err);
         throw err;
@@ -1438,7 +1674,8 @@ class TaskHandler {
       payload: this.config.lifecycle?.include_payload ? payload : {},
       attempt: retryCount + 1,
       max_retries: maxRetries,
-      scheduled_at: task.created_at || /* @__PURE__ */ new Date()
+      scheduled_at: task.created_at || /* @__PURE__ */ new Date(),
+      log_context: task.metadata?.log_context
     };
   }
   processBatch(queueId, processor, limit, abortSignal) {
@@ -1608,6 +1845,245 @@ class TaskQueuesManager {
     return Array.from(queueMap.keys());
   }
 }
+class InMemoryFlowBarrierProvider {
+  constructor() {
+    this.barriers = /* @__PURE__ */ new Map();
+  }
+  async initBarrier(flowId, totalSteps) {
+    if (this.barriers.has(flowId)) return;
+    this.barriers.set(flowId, {
+      remaining: totalSteps,
+      status: "active",
+      results: /* @__PURE__ */ new Map()
+    });
+  }
+  async batchDecrementAndCheck(flowId, results) {
+    const state = this.barriers.get(flowId);
+    if (!state) {
+      return { remaining: -1 };
+    }
+    if (state.status === "aborted" || state.status === "complete") {
+      return { remaining: -1 };
+    }
+    let actualNew = 0;
+    for (const result of results) {
+      if (!state.results.has(result.step_index)) {
+        state.results.set(result.step_index, result);
+        actualNew++;
+      }
+    }
+    state.remaining -= actualNew;
+    if (state.remaining <= 0) {
+      state.remaining = 0;
+      state.status = "complete";
+    }
+    return { remaining: state.remaining };
+  }
+  async getStepResults(flowId) {
+    const state = this.barriers.get(flowId);
+    if (!state) return [];
+    return Array.from(state.results.values()).sort((a, b) => a.step_index - b.step_index);
+  }
+  async markAborted(flowId) {
+    const state = this.barriers.get(flowId);
+    if (!state) return false;
+    if (state.status === "aborted") {
+      return false;
+    }
+    state.status = "aborted";
+    return true;
+  }
+  async isComplete(flowId) {
+    const state = this.barriers.get(flowId);
+    if (!state) return false;
+    return state.status === "complete";
+  }
+}
+function getFlowMeta(task) {
+  return task.metadata?.flow_meta;
+}
+function getFlowMetaRequired(task) {
+  return task.metadata.flow_meta;
+}
+class FlowMiddleware {
+  constructor(barrierProvider, generateId) {
+    this.barrierProvider = barrierProvider;
+    this.generateId = generateId;
+  }
+  /**
+   * Process completed tasks for flow orchestration.
+   * Called from TaskHandler.postProcessTasks after markFailed/markSuccess.
+   *
+   * @param input Categorized terminal tasks — success and final-failed (no retries left)
+   * @returns Join tasks to dispatch and entity projections to sync
+   */
+  async onPostProcess(input) {
+    const joinTasks = [];
+    const projections = [];
+    const successTaskSet = new Set(input.successTasks);
+    const allTasks = [...input.successTasks, ...input.failedTasks];
+    const joinCompletions = [];
+    const timeoutTasks = [];
+    const stepTasks = [];
+    for (const task of allTasks) {
+      const flowMeta = getFlowMeta(task);
+      if (!flowMeta) continue;
+      const isSuccess = successTaskSet.has(task);
+      if (flowMeta.is_join) {
+        joinCompletions.push(task);
+      } else if (flowMeta.is_timeout) {
+        timeoutTasks.push(task);
+      } else {
+        stepTasks.push({ task, isSuccess });
+      }
+    }
+    for (const task of joinCompletions) {
+      const flowMeta = getFlowMetaRequired(task);
+      const isSuccess = successTaskSet.has(task);
+      if (flowMeta.entity) {
+        try {
+          const status = isSuccess ? "executed" : "failed";
+          const error = !isSuccess ? task.execution_stats?.last_error || "Join task failed" : void 0;
+          const p = core_async_AsyncActions.buildProjection(
+            {
+              ...task,
+              id: flowMeta.flow_id,
+              entity: flowMeta.entity
+            },
+            status,
+            { result: task.execution_result, error }
+          );
+          if (p) projections.push(p);
+        } catch {
+        }
+      }
+    }
+    for (const task of timeoutTasks) {
+      const flowMeta = getFlowMetaRequired(task);
+      const flowId = flowMeta.flow_id;
+      await this.barrierProvider.initBarrier(flowId, flowMeta.total_steps);
+      const isComplete = await this.barrierProvider.isComplete(flowId);
+      if (isComplete) continue;
+      const isFirstAbort = await this.barrierProvider.markAborted(flowId);
+      if (!isFirstAbort) continue;
+      const partialResults = await this.barrierProvider.getStepResults(flowId);
+      const flowResults = {
+        flow_id: flowId,
+        steps: partialResults,
+        timed_out: true
+      };
+      const joinTask = this.buildJoinTask(flowMeta, flowResults);
+      joinTasks.push(joinTask);
+      if (flowMeta.entity) {
+        try {
+          const p = core_async_AsyncActions.buildProjection(
+            {
+              ...joinTask,
+              id: flowId,
+              entity: flowMeta.entity
+            },
+            "failed",
+            { error: "flow_timeout" }
+          );
+          if (p) projections.push(p);
+        } catch {
+        }
+      }
+    }
+    const stepsByFlow = /* @__PURE__ */ new Map();
+    for (const entry of stepTasks) {
+      const flowMeta = getFlowMetaRequired(entry.task);
+      const group = stepsByFlow.get(flowMeta.flow_id) || [];
+      group.push(entry);
+      stepsByFlow.set(flowMeta.flow_id, group);
+    }
+    for (const [flowId, entries] of stepsByFlow) {
+      const firstFlowMeta = getFlowMetaRequired(entries[0].task);
+      await this.barrierProvider.initBarrier(flowId, firstFlowMeta.total_steps);
+      if (firstFlowMeta.failure_policy === "abort") {
+        const hasFailure = entries.some((e) => !e.isSuccess);
+        if (hasFailure) {
+          const isFirstAbort = await this.barrierProvider.markAborted(flowId);
+          if (isFirstAbort) {
+            const stepResults2 = this.buildStepResults(entries);
+            await this.barrierProvider.batchDecrementAndCheck(flowId, stepResults2);
+            const allResults = await this.barrierProvider.getStepResults(flowId);
+            const flowResults = {
+              flow_id: flowId,
+              steps: allResults,
+              aborted: true
+            };
+            const joinTask = this.buildJoinTask(firstFlowMeta, flowResults);
+            joinTasks.push(joinTask);
+            if (firstFlowMeta.entity) {
+              try {
+                const p = core_async_AsyncActions.buildProjection(
+                  {
+                    ...joinTask,
+                    id: flowId,
+                    entity: firstFlowMeta.entity
+                  },
+                  "failed",
+                  { error: "flow_aborted" }
+                );
+                if (p) projections.push(p);
+              } catch {
+              }
+            }
+          }
+          continue;
+        }
+      }
+      const stepResults = this.buildStepResults(entries);
+      const { remaining } = await this.barrierProvider.batchDecrementAndCheck(flowId, stepResults);
+      if (remaining === 0) {
+        const allResults = await this.barrierProvider.getStepResults(flowId);
+        const flowResults = {
+          flow_id: flowId,
+          steps: allResults
+        };
+        const joinTask = this.buildJoinTask(firstFlowMeta, flowResults);
+        joinTasks.push(joinTask);
+      }
+    }
+    return { joinTasks, projections };
+  }
+  buildStepResults(entries) {
+    return entries.map(({ task, isSuccess }) => {
+      const flowMeta = getFlowMetaRequired(task);
+      return {
+        step_index: flowMeta.step_index,
+        status: isSuccess ? "success" : "fail",
+        result: task.execution_result,
+        error: !isSuccess ? task.execution_stats?.last_error || "Step failed" : void 0
+      };
+    });
+  }
+  buildJoinTask(flowMeta, flowResults) {
+    const now = /* @__PURE__ */ new Date();
+    const joinFlowMeta = {
+      ...flowMeta,
+      is_join: true,
+      is_timeout: void 0,
+      step_index: -1
+    };
+    return {
+      id: this.generateId(),
+      type: flowMeta.join.type,
+      queue_id: flowMeta.join.queue_id,
+      payload: { flow_results: flowResults },
+      execute_at: now,
+      status: "scheduled",
+      created_at: now,
+      updated_at: now,
+      force_store: true,
+      metadata: {
+        flow_meta: joinFlowMeta
+      },
+      ...flowMeta.entity ? { entity: flowMeta.entity } : {}
+    };
+  }
+}
 class ConsoleHealthProvider {
   constructor(prefix = "[Health]") {
     this.prefix = prefix;
@@ -1670,11 +2146,17 @@ exports.PrismaAdapter = PrismaAdapter.PrismaAdapter;
 exports.tId = utils_taskIdGen.tId;
 exports.Actions = core_Actions.Actions;
 exports.AsyncActions = core_async_AsyncActions.AsyncActions;
+exports.buildProjection = core_async_AsyncActions.buildProjection;
+exports.syncProjections = core_async_AsyncActions.syncProjections;
 exports.AsyncTaskManager = core_async_AsyncTaskManager.AsyncTaskManager;
 exports.ConsoleHealthProvider = ConsoleHealthProvider;
+exports.FlowMiddleware = FlowMiddleware;
+exports.InMemoryFlowBarrierProvider = InMemoryFlowBarrierProvider;
 exports.TaskHandler = TaskHandler;
 exports.TaskQueuesManager = TaskQueuesManager;
 exports.TaskRunner = TaskRunner;
 exports.TaskStore = TaskStore;
 exports.getEnabledQueues = getEnabledQueues;
+exports.getLogContext = getLogContext;
+exports.runWithLogContext = runWithLogContext;
 //# sourceMappingURL=index.cjs.map