@ai-setting/roy-agent-core 1.6.12 → 1.6.13

package/dist/shared/@ai-setting/{roy-agent-core-0n2a8cbn.js → roy-agent-core-0crh2g0m.js}

@@ -7,7 +7,7 @@ import {
 import {
   AgentComponentAdapter,
   init_agent_component_adapter
-} from "./roy-agent-core-jenchn33.js";
+} from "./roy-agent-core-24rmf17n.js";
 import {
   TemplateResolver,
   init_template_resolver
@@ -40,7 +40,7 @@ import {
 import {
   DAGManager,
   init_dag_manager
-} from "./roy-agent-core-4yq23m5g.js";
+} from "./roy-agent-core-vcjq65nz.js";
 import {
   AskUserError,
   createNodeInterruptEvent,
@@ -154,238 +154,259 @@ var init_event_bus = __esm(() => {
 });
 
 // src/env/workflow/engine/scheduler.ts
-class Scheduler {
-  dagManager;
-  options;
-  pending = new Set;
-  ready = new Set;
-  running = new Set;
-  completed = new Set;
-  failed = new Set;
-  skipped = new Set;
-  constructor(dagManager, options) {
-    this.dagManager = dagManager;
-    const parallelLimit = options?.parallelLimit;
-    this.options = {
-      parallelLimit: parallelLimit === undefined ? 1 : parallelLimit
-    };
-    const analysis = dagManager.analyze();
-    for (const nodeId of analysis.dependencies.keys()) {
-      this.pending.add(nodeId);
+var logger2, Scheduler;
+var init_scheduler = __esm(() => {
+  init_logger();
+  init_decorator();
+  logger2 = createLogger("workflow.scheduler");
+  Scheduler = class Scheduler {
+    dagManager;
+    options;
+    pending = new Set;
+    ready = new Set;
+    running = new Set;
+    completed = new Set;
+    failed = new Set;
+    skipped = new Set;
+    constructor(dagManager, options) {
+      this.dagManager = dagManager;
+      const parallelLimit = options?.parallelLimit;
+      this.options = {
+        parallelLimit: parallelLimit === undefined ? 1 : parallelLimit
+      };
+      const analysis = dagManager.analyze();
+      for (const nodeId of analysis.dependencies.keys()) {
+        this.pending.add(nodeId);
+      }
+      this.updateReadyNodes(new Set);
+    }
+    getReadyNodes(completedNodes) {
+      const allCompleted = new Set(completedNodes);
+      for (const nodeId of this.completed) {
+        allCompleted.add(nodeId);
+      }
+      const readyFromDag = this.dagManager.getReadyNodes(allCompleted);
+      const ready = [];
+      for (const nodeId of readyFromDag) {
+        const isProcessed = this.running.has(nodeId) || this.completed.has(nodeId) || this.failed.has(nodeId) || this.skipped.has(nodeId);
+        if (!isProcessed) {
+          ready.push(nodeId);
+        }
+      }
+      return ready.sort();
     }
-    this.updateReadyNodes(new Set);
-  }
-  getReadyNodes(completedNodes) {
-    const allCompleted = new Set(completedNodes);
-    for (const nodeId of this.completed) {
-      allCompleted.add(nodeId);
+    getRunningCount() {
+      return this.running.size;
+    }
+    canStartMore() {
+      if (this.options.parallelLimit === null) {
+        return true;
+      }
+      if (this.options.parallelLimit <= 0) {
+        return false;
+      }
+      return this.running.size < this.options.parallelLimit;
     }
-    const readyFromDag = this.dagManager.getReadyNodes(allCompleted);
-    const ready = [];
-    for (const nodeId of readyFromDag) {
-      const isProcessed = this.running.has(nodeId) || this.completed.has(nodeId) || this.failed.has(nodeId) || this.skipped.has(nodeId);
-      if (!isProcessed) {
-        ready.push(nodeId);
+    markStarted(nodeId) {
+      if (!this.running.has(nodeId)) {
+        this.running.add(nodeId);
+        this.ready.delete(nodeId);
+        this.pending.delete(nodeId);
       }
     }
-    return ready.sort();
-  }
-  getRunningCount() {
-    return this.running.size;
-  }
-  canStartMore() {
-    if (this.options.parallelLimit === null) {
-      return true;
+    isRunning(nodeId) {
+      return this.running.has(nodeId);
     }
-    if (this.options.parallelLimit <= 0) {
-      return false;
+    isCompleted(nodeId) {
+      return this.completed.has(nodeId);
     }
-    return this.running.size < this.options.parallelLimit;
-  }
-  markStarted(nodeId) {
-    if (!this.running.has(nodeId)) {
-      this.running.add(nodeId);
+    isFailed(nodeId) {
+      return this.failed.has(nodeId);
+    }
+    isPending(nodeId) {
+      return this.pending.has(nodeId);
+    }
+    isReady(nodeId) {
+      return this.ready.has(nodeId);
+    }
+    markCompleted(nodeId) {
+      if (nodeId === "__end__" || nodeId === "__END__") {
+        logger2.debug(`[Scheduler] Workflow marked as completed via __end__`);
+        return;
+      }
+      this.running.delete(nodeId);
       this.ready.delete(nodeId);
       this.pending.delete(nodeId);
+      this.failed.delete(nodeId);
+      this.skipped.delete(nodeId);
+      this.completed.add(nodeId);
     }
-  }
-  isRunning(nodeId) {
-    return this.running.has(nodeId);
-  }
-  isCompleted(nodeId) {
-    return this.completed.has(nodeId);
-  }
-  isFailed(nodeId) {
-    return this.failed.has(nodeId);
-  }
-  isPending(nodeId) {
-    return this.pending.has(nodeId);
-  }
-  isReady(nodeId) {
-    return this.ready.has(nodeId);
-  }
-  markCompleted(nodeId) {
-    if (nodeId === "__end__" || nodeId === "__END__") {
-      logger2.debug(`[Scheduler] Workflow marked as completed via __end__`);
-      return;
-    }
-    this.running.delete(nodeId);
-    this.ready.delete(nodeId);
-    this.pending.delete(nodeId);
-    this.failed.delete(nodeId);
-    this.skipped.delete(nodeId);
-    this.completed.add(nodeId);
-  }
-  markFailed(nodeId) {
-    this.running.delete(nodeId);
-    this.ready.delete(nodeId);
-    this.pending.delete(nodeId);
-    this.completed.delete(nodeId);
-    this.skipped.delete(nodeId);
-    this.failed.add(nodeId);
-  }
-  markSkipped(nodeId) {
-    if (this.running.has(nodeId)) {
+    markFailed(nodeId) {
       this.running.delete(nodeId);
-    }
-    if (this.ready.has(nodeId)) {
       this.ready.delete(nodeId);
-    }
-    if (this.pending.has(nodeId)) {
       this.pending.delete(nodeId);
+      this.completed.delete(nodeId);
+      this.skipped.delete(nodeId);
+      this.failed.add(nodeId);
     }
-    this.skipped.add(nodeId);
-  }
-  unmarkSkipped(nodeId) {
-    if (!this.skipped.has(nodeId)) {
-      return;
+    markSkipped(nodeId) {
+      if (this.running.has(nodeId)) {
+        this.running.delete(nodeId);
+      }
+      if (this.ready.has(nodeId)) {
+        this.ready.delete(nodeId);
+      }
+      if (this.pending.has(nodeId)) {
+        this.pending.delete(nodeId);
+      }
+      this.skipped.add(nodeId);
     }
-    this.skipped.delete(nodeId);
-    this.pending.add(nodeId);
-  }
-  resetNodeForReEntry(nodeId) {
-    this.running.delete(nodeId);
-    this.completed.delete(nodeId);
-    this.failed.delete(nodeId);
-    this.skipped.delete(nodeId);
-    this.ready.delete(nodeId);
-    this.pending.add(nodeId);
-  }
-  reset() {
-    this.running.clear();
-    this.completed.clear();
-    this.failed.clear();
-    this.skipped.clear();
-    const analysis = this.dagManager.analyze();
-    this.pending.clear();
-    this.ready.clear();
-    for (const nodeId of analysis.dependencies.keys()) {
+    unmarkSkipped(nodeId) {
+      if (!this.skipped.has(nodeId)) {
+        return;
+      }
+      this.skipped.delete(nodeId);
       this.pending.add(nodeId);
     }
-    this.updateReadyNodes(new Set);
-  }
-  getState() {
-    this.updateReadyNodes(new Set);
-    return {
-      pending: Array.from(this.pending).sort(),
-      ready: Array.from(this.ready).sort(),
-      running: Array.from(this.running).sort(),
-      completed: Array.from(this.completed).sort(),
-      failed: Array.from(this.failed).sort(),
-      skipped: Array.from(this.skipped).sort()
-    };
-  }
-  markCompletedFromRestore(nodeIds) {
-    for (const nodeId of nodeIds) {
-      this.markCompleted(nodeId);
+    resetNodeForReEntry(nodeId) {
+      this.running.delete(nodeId);
+      this.completed.delete(nodeId);
+      this.failed.delete(nodeId);
+      this.skipped.delete(nodeId);
+      this.ready.delete(nodeId);
+      this.pending.add(nodeId);
     }
-  }
-  updateReadyNodes(completedNodes) {
-    const allCompleted = new Set(completedNodes);
-    for (const nodeId of this.completed) {
-      allCompleted.add(nodeId);
-    }
-    const analysis = this.dagManager.analyze();
-    const allNodeIds = Array.from(analysis.dependencies.keys());
-    this.ready.clear();
-    for (const nodeId of allNodeIds) {
-      if (this.running.has(nodeId) || this.completed.has(nodeId) || this.failed.has(nodeId) || this.skipped.has(nodeId)) {
-        continue;
-      }
-      if (this.dagManager.areDependenciesMet(nodeId, allCompleted)) {
-        this.ready.add(nodeId);
+    reset() {
+      this.running.clear();
+      this.completed.clear();
+      this.failed.clear();
+      this.skipped.clear();
+      const analysis = this.dagManager.analyze();
+      this.pending.clear();
+      this.ready.clear();
+      for (const nodeId of analysis.dependencies.keys()) {
+        this.pending.add(nodeId);
+      }
+      this.updateReadyNodes(new Set);
+    }
+    getState() {
+      this.updateReadyNodes(new Set);
+      return {
+        pending: Array.from(this.pending).sort(),
+        ready: Array.from(this.ready).sort(),
+        running: Array.from(this.running).sort(),
+        completed: Array.from(this.completed).sort(),
+        failed: Array.from(this.failed).sort(),
+        skipped: Array.from(this.skipped).sort()
+      };
+    }
+    markCompletedFromRestore(nodeIds) {
+      for (const nodeId of nodeIds) {
+        this.markCompleted(nodeId);
       }
     }
-  }
-  getParallelLimit() {
-    return this.options.parallelLimit;
-  }
-  setParallelLimit(limit) {
-    this.options.parallelLimit = limit;
-  }
-  getOutgoingEdges(nodeId, edges) {
-    return edges.filter((edge) => edge.from === nodeId);
-  }
-  processEdgesAfterCompletion(completedNodeId, edges, templateResolver, loopEnabled) {
-    const result = {
-      toStart: [],
-      reEntries: [],
-      skipped: [],
-      resetNodes: []
-    };
-    const completedNode = this.dagManager.getNode(completedNodeId);
-    if (completedNode?.condition) {
-      const conditionMet = templateResolver.evaluateCondition(completedNode.condition);
-      if (!conditionMet) {
-        for (const edge of this.getOutgoingEdges(completedNodeId, edges)) {
-          this.markSkipped(edge.to);
-          result.skipped.push({
-            nodeId: edge.to,
-            reason: `Inline condition false on node "${completedNodeId}"`
-          });
+    updateReadyNodes(completedNodes) {
+      const allCompleted = new Set(completedNodes);
+      for (const nodeId of this.completed) {
+        allCompleted.add(nodeId);
+      }
+      const analysis = this.dagManager.analyze();
+      const allNodeIds = Array.from(analysis.dependencies.keys());
+      this.ready.clear();
+      for (const nodeId of allNodeIds) {
+        if (this.running.has(nodeId) || this.completed.has(nodeId) || this.failed.has(nodeId) || this.skipped.has(nodeId)) {
+          continue;
+        }
+        if (this.dagManager.areDependenciesMet(nodeId, allCompleted)) {
+          this.ready.add(nodeId);
         }
-        return result;
       }
     }
-    const outgoingEdges = this.getOutgoingEdges(completedNodeId, edges);
-    for (const edge of outgoingEdges) {
-      const conditionMet = !edge.when || templateResolver.evaluateCondition(edge.when);
-      if (conditionMet) {
-        if (this.skipped.has(edge.to)) {
-          this.unmarkSkipped(edge.to);
-        }
-        const isReEntry = loopEnabled && this.completed.has(edge.to);
-        const canStart = loopEnabled ? !this.running.has(edge.to) && !this.failed.has(edge.to) : !this.completed.has(edge.to) && !this.running.has(edge.to) && !this.failed.has(edge.to);
-        if (canStart) {
-          if (isReEntry) {
-            const downstream = this.dagManager.getDownstreamUntil(edge.to, completedNodeId);
-            for (const nodeId of downstream) {
-              this.resetNodeForReEntry(nodeId);
-              result.resetNodes.push(nodeId);
-            }
-            this.resetNodeForReEntry(edge.to);
-            result.resetNodes.push(edge.to);
-            result.reEntries.push(edge.to);
+    getParallelLimit() {
+      return this.options.parallelLimit;
+    }
+    setParallelLimit(limit) {
+      this.options.parallelLimit = limit;
+    }
+    getOutgoingEdges(nodeId, edges) {
+      return edges.filter((edge) => edge.from === nodeId);
+    }
+    processEdgesAfterCompletion(completedNodeId, edges, templateResolver, loopEnabled) {
+      const result = {
+        toStart: [],
+        reEntries: [],
+        skipped: [],
+        resetNodes: []
+      };
+      const completedNode = this.dagManager.getNode(completedNodeId);
+      if (completedNode?.condition) {
+        const conditionMet = templateResolver.evaluateCondition(completedNode.condition);
+        if (!conditionMet) {
+          for (const edge of this.getOutgoingEdges(completedNodeId, edges)) {
+            this.markSkipped(edge.to);
+            result.skipped.push({
+              nodeId: edge.to,
+              reason: `Inline condition false on node "${completedNodeId}"`
+            });
           }
-          result.toStart.push(edge.to);
+          return result;
         }
-      } else {
-        if (!this.skipped.has(edge.to)) {
-          result.skipped.push({
-            nodeId: edge.to,
-            reason: edge.when ? `Edge condition false: ${edge.when}` : "Edge condition false"
-          });
+      }
+      const outgoingEdges = this.getOutgoingEdges(completedNodeId, edges);
+      for (const edge of outgoingEdges) {
+        const conditionMet = !edge.when || templateResolver.evaluateCondition(edge.when);
+        if (conditionMet) {
+          if (this.skipped.has(edge.to)) {
+            this.unmarkSkipped(edge.to);
+          }
+          const isReEntry = loopEnabled && this.completed.has(edge.to);
+          const canStart = loopEnabled ? !this.running.has(edge.to) && !this.failed.has(edge.to) : !this.completed.has(edge.to) && !this.running.has(edge.to) && !this.failed.has(edge.to);
+          if (canStart) {
+            if (isReEntry) {
+              const downstream = this.dagManager.getDownstreamUntil(edge.to, completedNodeId);
+              for (const nodeId of downstream) {
+                this.resetNodeForReEntry(nodeId);
+                result.resetNodes.push(nodeId);
+              }
+              this.resetNodeForReEntry(edge.to);
+              result.resetNodes.push(edge.to);
+              result.reEntries.push(edge.to);
+              result.toStart.push(edge.to);
+            } else {
+              const completedSoFar = new Set(this.completed);
+              completedSoFar.add(completedNodeId);
+              if (this.dagManager.areDependenciesMet(edge.to, completedSoFar)) {
+                result.toStart.push(edge.to);
+              }
+            }
+          }
+        } else {
+          if (!this.skipped.has(edge.to)) {
+            result.skipped.push({
+              nodeId: edge.to,
+              reason: edge.when ? `Edge condition false: ${edge.when}` : "Edge condition false"
+            });
+          }
+          this.markSkipped(edge.to);
         }
-        this.markSkipped(edge.to);
       }
+      return result;
     }
-    return result;
-  }
-}
-var logger2;
-var init_scheduler = __esm(() => {
-  init_logger();
-  logger2 = createLogger("workflow.scheduler");
+  };
+  __legacyDecorateClassTS([
+    TracedAs("workflow.scheduler.getReadyNodes", {
+      recordParams: true,
+      recordResult: true,
+      log: true
+    })
+  ], Scheduler.prototype, "getReadyNodes", null);
+  __legacyDecorateClassTS([
+    TracedAs("workflow.scheduler.processEdgesAfterCompletion", {
+      recordParams: true,
+      recordResult: true,
+      log: true
+    })
+  ], Scheduler.prototype, "processEdgesAfterCompletion", null);
 });
 
 // src/env/workflow/engine/executor.ts
@@ -418,7 +439,9 @@ var init_executor = __esm(() => {
       await this.writeNodeStart(context.sessionId, nodeId, nodeType, context.input, agentSessionId);
       const abortController = new AbortController;
       this.abortControllers.set(nodeId, abortController);
-      context.abortSignal ??= abortController.signal;
+      const incomingSignal = context.abortSignal;
+      const composedSignal = incomingSignal ? AbortSignal.any([incomingSignal, abortController.signal]) : abortController.signal;
+      context.abortSignal = composedSignal;
       const ctxCfg = context.config;
       const cfgTimeout = ctxCfg && typeof ctxCfg.timeout === "number" && ctxCfg.timeout > 0 ? ctxCfg.timeout : undefined;
       const timeout = definition.timeout ?? cfgTimeout ?? this.options.globalTimeout ?? undefined;
@@ -505,6 +528,7 @@ var init_executor = __esm(() => {
           const result = await node.execute(context);
           return {
             output: result.output,
+            error: result.error,
             durationMs: Date.now() - startTime
           };
         } catch (error) {
@@ -523,32 +547,25 @@ var init_executor = __esm(() => {
       const retryConfig = definition.retry;
       let lastError;
       let delay = retryConfig.initial_delay;
-      const signal = abortController.signal;
+      const signal = context.abortSignal ?? abortController.signal;
       for (let attempt = 1;attempt <= retryConfig.max_attempts; attempt++) {
         if (signal.aborted) {
+          const reason = signal.reason;
           return {
             output: undefined,
-            error: new Error("Execution aborted"),
+            error: reason instanceof Error ? reason : new Error(typeof reason === "string" && reason ? reason : "Execution aborted"),
             durationMs: 0
           };
         }
         const attemptAbort = new AbortController;
         const combinedSignal = this.combineAbortSignals(signal, attemptAbort.signal);
-        const combinedController = new AbortController;
-        combinedSignal.addEventListener("abort", () => {
-          if (!combinedController.signal.aborted) {
-            combinedController.abort(combinedSignal.reason);
-          }
-        });
         const attemptAbortController = {
           get signal() {
             return combinedSignal;
           },
           abort: (reason) => {
-            attemptAbort.abort(reason);
-            if (!combinedController.signal.aborted) {
-              combinedController.abort(reason);
-            }
+            if (!attemptAbort.signal.aborted)
+              attemptAbort.abort(reason);
           }
         };
         try {
@@ -561,7 +578,15 @@ var init_executor = __esm(() => {
           lastError = error instanceof Error ? error : new Error(String(error));
         }
         if (attempt < retryConfig.max_attempts) {
-          await this.sleep(delay);
+          try {
+            await this.sleep(delay, signal);
+          } catch (e) {
+            return {
+              output: undefined,
+              error: e instanceof Error ? e : new Error(String(e)),
+              durationMs: 0
+            };
+          }
           if (retryConfig.backoff === "exponential") {
             delay *= 2;
           }
@@ -587,13 +612,29 @@ var init_executor = __esm(() => {
       this.abortControllers.clear();
     }
     combineAbortSignals(signal1, signal2) {
-      const controller = new AbortController;
-      signal1.addEventListener("abort", () => controller.abort());
-      signal2.addEventListener("abort", () => controller.abort());
-      return controller.signal;
+      return AbortSignal.any([signal1, signal2]);
     }
-    sleep(ms) {
-      return new Promise((resolve) => setTimeout(resolve, ms));
+    sleep(ms, signal) {
+      return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+          reject(signal.reason ?? new Error("aborted"));
+          return;
+        }
+        const handle = setTimeout(() => {
+          if (signal) {
+            signal.removeEventListener("abort", onAbort);
+          }
+          resolve();
+        }, ms);
+        if (typeof handle.unref === "function") {
+          handle.unref();
+        }
+        const onAbort = () => {
+          clearTimeout(handle);
+          reject(signal.reason ?? new Error("aborted"));
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+      });
     }
     async writeNodeStart(sessionId, nodeId, nodeType, input, agentSessionId) {
       if (!this.sessionComponent)
@@ -1108,6 +1149,10 @@ var init_agent_node = __esm(() => {
           nodeId: this.definition.id,
           agentSessionId
         };
+        const ctxScope = context.cancellationScope;
+        if (ctxScope && !agentConfig.cancellationScope) {
+          agentConfig.cancellationScope = ctxScope;
+        }
         const resumeOptions = {
           userQuery,
           agentSessionId
@@ -1378,9 +1423,131 @@ function mapNonTerminal(agentSessions, terminalStatus) {
 }
 var init_agent_session_metadata = () => {};
 
+// src/env/workflow/runtime/runtime-cancellation-scope.ts
+var RuntimeCancellationScope;
+var init_runtime_cancellation_scope = __esm(() => {
+  init_decorator();
+  RuntimeCancellationScope = class RuntimeCancellationScope {
+    gracefulController = new AbortController;
+    forceController = new AbortController;
+    signal;
+    forceSignal;
+    _level = "running";
+    trackedWork = new Map;
+    forceHandlers = [];
+    forceHandlerErrors = [];
+    constructor() {
+      this.signal = AbortSignal.any([
+        this.gracefulController.signal,
+        this.forceController.signal
+      ]);
+      this.forceSignal = this.forceController.signal;
+    }
+    get level() {
+      return this._level;
+    }
+    track(label, work) {
+      this.trackedWork.set(work, { label });
+      work.finally(() => {
+        this.trackedWork.delete(work);
+      });
+      return work;
+    }
+    onForce(label, handler) {
+      const entry = { label, fn: handler };
+      this.forceHandlers.push(entry);
+      return () => {
+        const idx = this.forceHandlers.indexOf(entry);
+        if (idx >= 0) {
+          this.forceHandlers.splice(idx, 1);
+        }
+      };
+    }
+    async cancel(reason, options = {}) {
+      const force = options.force === true;
+      if (force) {
+        if (!this.gracefulController.signal.aborted) {
+          this.gracefulController.abort(reason);
+          this._level = "graceful";
+        }
+        if (!this.forceController.signal.aborted) {
+          this.forceController.abort(reason);
+          this._level = "force";
+        } else {
+          return {
+            completed: this.trackedWork.size === 0,
+            pendingLabels: Array.from(this.trackedWork.values()).map((v) => v.label),
+            errors: [...this.forceHandlerErrors]
+          };
+        }
+      } else {
+        if (!this.gracefulController.signal.aborted) {
+          this.gracefulController.abort(reason);
+          this._level = "graceful";
+        }
+        return {
+          completed: this.trackedWork.size === 0,
+          pendingLabels: Array.from(this.trackedWork.values()).map((v) => v.label),
+          errors: [...this.forceHandlerErrors]
+        };
+      }
+      const handlers = [...this.forceHandlers];
+      for (const { label, fn } of handlers) {
+        try {
+          await fn();
+        } catch (e) {
+          const err = e instanceof Error ? e.message : String(e);
+          this.forceHandlerErrors.push({ label, error: err });
+        }
+      }
+      return {
+        completed: this.trackedWork.size === 0,
+        pendingLabels: Array.from(this.trackedWork.values()).map((v) => v.label),
+        errors: [...this.forceHandlerErrors]
+      };
+    }
+    async waitForCleanup(timeoutMs) {
+      const pendingPromises = Array.from(this.trackedWork.keys());
+      if (pendingPromises.length === 0) {
+        return {
+          completed: true,
+          pendingLabels: [],
+          errors: [...this.forceHandlerErrors]
+        };
+      }
+      const settled = Promise.allSettled(pendingPromises).then(() => {
+        return;
+      });
+      let timer;
+      const timeoutPromise = new Promise((resolve) => {
+        timer = setTimeout(resolve, timeoutMs);
+      });
+      try {
+        await Promise.race([settled, timeoutPromise]);
+      } finally {
+        if (timer)
+          clearTimeout(timer);
+      }
+      return {
+        completed: this.trackedWork.size === 0,
+        pendingLabels: Array.from(this.trackedWork.values()).map((v) => v.label),
+        errors: [...this.forceHandlerErrors]
+      };
+    }
+  };
+  __legacyDecorateClassTS([
+    TracedAs("workflow.runtime.cancel", { recordParams: true, recordResult: true })
+  ], RuntimeCancellationScope.prototype, "cancel", null);
+  __legacyDecorateClassTS([
+    TracedAs("workflow.runtime.waitForCleanup", { recordParams: true, recordResult: true })
+  ], RuntimeCancellationScope.prototype, "waitForCleanup", null);
+});
+
 // src/env/workflow/engine/engine.ts
 import { EventEmitter } from "events";
-var logger3, WorkflowEngine;
+import { execFile as execFileCb } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync, logger3, WorkflowEngine;
 var init_engine = __esm(() => {
   init_event();
   init_workflow_hil();
@@ -1394,6 +1561,8 @@ var init_engine = __esm(() => {
   init_decorator();
   init_template_resolver();
   init_workflow_error();
+  init_runtime_cancellation_scope();
+  execFileAsync = promisify(execFileCb);
   logger3 = createLogger("workflow:engine");
   WorkflowEngine = class WorkflowEngine extends EventEmitter {
     activeSessions = new Map;
@@ -1616,6 +1785,7 @@ var init_engine = __esm(() => {
         nodeConfig: options?.nodeConfig ?? {}
       };
       const abortController = new AbortController;
+      const cancellationScope = new RuntimeCancellationScope;
       let resolveCompleted;
       let rejectCompleted;
       const completedPromise = new Promise((resolve, reject) => {
@@ -1635,6 +1805,7 @@ var init_engine = __esm(() => {
         nodeRegistry: this.nodeRegistry,
         nodeOutputs: new Map,
         config,
+        cancellationScope,
         abortController,
         completedPromise,
         resolveCompleted,
@@ -1642,7 +1813,8 @@ var init_engine = __esm(() => {
         workflowHistory: [],
         agentSessions: new Map,
         edges: dagManager.buildEdges(definition.edges || []),
-        loopIterationCount: 0
+        loopIterationCount: 0,
+        loopGuardCounters: new Map
       };
       this.setupEventHandlers(sessionState);
       return sessionState;
@@ -1680,6 +1852,17 @@ var init_engine = __esm(() => {
         const completedNodeIds = Array.from(resumeInfo.nodeOutputs.keys());
         sessionState.scheduler.markCompletedFromRestore(completedNodeIds);
       }
+      const resolveStoppedOnce = () => {
+        if (sessionState.status === "stopped") {
+          try {
+            sessionState.resolveCompleted({
+              runId: this.getRunIdFromSessionId(sessionState.sessionId),
+              status: "stopped"
+            });
+          } catch {}
+        }
+      };
+      sessionState.cancellationScope?.signal.addEventListener("abort", resolveStoppedOnce, { once: true });
       this.scheduleAndExecute(sessionState, {
         input: inputForExecution,
         pendingNodeId,
@@ -1721,11 +1904,16 @@ var init_engine = __esm(() => {
       await sessionState.eventBus.publish(createWorkflowEvent("workflow.paused", this.getRunIdFromSessionId(sessionId), {}));
       logger3.info(`[WorkflowEngine] Workflow paused: ${sessionId}`);
     }
-    async stop(sessionId, reason) {
+    async stop(sessionId, reason, options = {}) {
+      const force = options.force === true;
+      const stopReason = reason ?? (force ? "Force stop requested" : "User requested stop");
       const sessionState = this.activeSessions.get(sessionId);
       if (!sessionState) {
         if (this.sessionComponent) {
           const metadata = await this.getSessionMetadata(sessionId);
+          if (metadata?.status === "completed" || metadata?.status === "failed") {
+            return;
+          }
           await this.sessionComponent.update(sessionId, {
             metadata: {
               ...metadata,
@@ -1733,33 +1921,114 @@ var init_engine = __esm(() => {
               agentSessions: markAllAgentSessionsStopped(metadata.agentSessions)
             }
           });
+          await this.propagateStopToChildSessions(sessionId, stopReason);
         }
         return;
       }
+      if (sessionState.status === "completed" || sessionState.status === "failed") {
+        return;
+      }
       sessionState.status = "stopped";
-      sessionState.abortController.abort();
+      if (sessionState.cancellationScope) {
+        await sessionState.cancellationScope.cancel(stopReason, { force });
+      }
+      if (!sessionState.abortController.signal.aborted) {
+        sessionState.abortController.abort(stopReason);
+      }
       sessionState.executor.cancelAll();
       if (this.sessionComponent) {
         const metadata = await this.getSessionMetadata(sessionId);
+        const updatedAgentSessions = markAllAgentSessionsStopped(metadata.agentSessions);
         await this.sessionComponent.update(sessionId, {
           metadata: {
             ...metadata,
             status: "stopped",
-            agentSessions: markAllAgentSessionsStopped(metadata.agentSessions)
+            agentSessions: updatedAgentSessions
           }
         });
+        await this.propagateStopToChildSessions(sessionId, stopReason);
       }
       await sessionState.eventBus.publish(createWorkflowEvent("workflow.stopped", this.getRunIdFromSessionId(sessionId), {
-        reason: reason ?? "User requested stop"
+        reason: stopReason
       }));
-      this.cleanupSession(sessionState);
+      try {
+        await sessionState.cancellationScope?.waitForCleanup(force ? 500 : 1500);
+      } catch {}
+      if (force || !sessionState.cancellationScope) {
+        this.cleanupSession(sessionState);
+      } else {
+        const GRACE_MS = 2000;
+        const timer = setTimeout(() => {
+          const current = this.activeSessions.get(sessionId);
+          if (current === sessionState && current.status === "stopped") {
+            this.cleanupSession(current);
+          }
+        }, GRACE_MS);
+        if (typeof timer.unref === "function") {
+          timer.unref();
+        }
+      }
     }
     getSessionStatus(sessionId) {
       const sessionState = this.activeSessions.get(sessionId);
       return sessionState?.status ?? null;
     }
+    async propagateStopToChildSessions(workflowSessionId, reason) {
+      if (!this.sessionComponent?.list || !this.sessionComponent.update)
+        return;
+      let allChildSessions;
+      try {
+        const PAGE = 1000;
+        const HARD_CAP = 50000;
+        const allSessions = [];
+        let offset = 0;
+        while (allSessions.length < HARD_CAP) {
+          const batch = await this.sessionComponent.list({
+            limit: PAGE,
+            offset
+          });
+          allSessions.push(...batch);
+          if (batch.length < PAGE)
+            break;
+          offset += PAGE;
+        }
+        allChildSessions = allSessions.filter((s) => s?.parentSessionId === workflowSessionId).map((s) => ({ id: s.id, metadata: s.metadata }));
+      } catch (err) {
+        logger3.warn(`[WorkflowEngine] propagateStopToChildSessions list failed: ${err instanceof Error ? err.message : String(err)}`);
+        return;
+      }
+      if (!allChildSessions?.length)
+        return;
+      for (const ref of allChildSessions) {
+        if (!ref?.id)
+          continue;
+        try {
+          const child = await this.sessionComponent.get(ref.id);
+          if (!child)
+            continue;
+          const childMeta = child.metadata ?? {};
+          const currentStatus = childMeta.status;
+          if (currentStatus === "completed" || currentStatus === "failed" || currentStatus === "stopped") {
+            continue;
+          }
+          await this.sessionComponent.update(ref.id, {
+            metadata: {
+              ...childMeta,
+              status: "stopped",
+              stopReason: reason,
+              stoppedAt: Date.now()
+            }
+          });
+        } catch (err) {
+          logger3.warn(`[WorkflowEngine] propagateStopToChildSessions failed for ${ref.id}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    }
     isSessionActive(sessionId) {
-      return this.activeSessions.has(sessionId);
+      const s = this.activeSessions.get(sessionId);
+      if (!s)
+        return false;
+      return s.status === "running" || s.status === "paused";
     }
     setupEventHandlers(sessionState) {
       const { sessionId, eventBus, scheduler } = sessionState;
@@ -1878,7 +2147,7 @@ var init_engine = __esm(() => {
       } else {
         await scheduleAvailableNodes();
       }
-      while (sessionState.status === "running" && !abortController.signal.aborted) {
+      while (sessionState.status === "running" && !abortController.signal.aborted && !sessionState.cancellationScope?.signal.aborted) {
         const state = scheduler.getState();
         if (state.pending.length === 0 && state.running.length === 0) {
           break;
@@ -2053,6 +2322,41 @@ var init_engine = __esm(() => {
         scheduler.markFailed(nodeId);
       }
     }
+    async checkLoopGuardWithSnapshot(sessionState, templateResolver, reEntryId, _snapshotPreviousOutput) {
+      const guard = sessionState.dagManager.getLoopGuard(reEntryId);
+      if (!guard) {
+        return { trip: false, counterKey: "", nextCount: 0 };
+      }
+      const counterKey = `_loop_guard_consecutive_${reEntryId}`;
+      const previousCount = sessionState.loopGuardCounters.get(reEntryId) ?? 0;
+      const previousValue = templateResolver.resolveValue(guard.previous_signal);
+      const cwd = guard.cwd ?? sessionState.config.workflowInput?.project_path ?? process.cwd();
+      let currentValue;
+      try {
+        const { stdout } = await execFileAsync("/bin/sh", ["-c", guard.current_signal_command], {
+          cwd,
+          timeout: 1e4
+        });
+        currentValue = stdout.trim();
+      } catch (err) {
+        logger3.warn(`[WorkflowEngine] loop_guard command failed for ${reEntryId}: ${err instanceof Error ? err.message : String(err)}. Allowing re-entry.`);
+        return { trip: false, counterKey, nextCount: 0 };
+      }
+      if (previousValue === undefined) {
+        return { trip: false, counterKey, nextCount: 0 };
+      }
+      const isUnchanged = JSON.stringify(previousValue) === JSON.stringify(currentValue);
+      if (!isUnchanged) {
+        return { trip: false, counterKey, nextCount: 0 };
+      }
+      const nextCount = previousCount + 1;
+      const maxAllowed = guard.max_consecutive_no_progress;
+      if (nextCount >= maxAllowed) {
+        const failMessage = guard.fail_message ?? `no progress: loop_guard detected unchanged signal for ${reEntryId} after ${nextCount} consecutive re-entries`;
+        return { trip: true, failMessage, counterKey, nextCount };
+      }
+      return { trip: false, counterKey, nextCount };
+    }
     async processConditionalEdgesAfterCompletion(sessionState, completedNodeId) {
       if (!sessionState.edges || sessionState.edges.length === 0) {
         return;
@@ -2066,6 +2370,14 @@ var init_engine = __esm(() => {
       logger3.debug(`[WorkflowEngine] Processing edges after "${completedNodeId}" completed. edges=${JSON.stringify(sessionState.edges)}`);
       const edgeResult = scheduler.processEdgesAfterCompletion(completedNodeId, sessionState.edges, templateResolver, sessionState.config.loopEnabled);
       logger3.debug(`[WorkflowEngine] Edge processing result: ${JSON.stringify(edgeResult)}`);
+      const loopGuardSnapshots = new Map;
+      for (const reEntryId of edgeResult.reEntries) {
+        const guard = sessionState.dagManager.getLoopGuard(reEntryId);
+        if (!guard)
+          continue;
+        const previousOutput = sessionState.nodeOutputs.get(reEntryId) ?? {};
+        loopGuardSnapshots.set(reEntryId, previousOutput);
+      }
       const resetNodeIds = edgeResult.reEntries.length > 0 ? edgeResult.resetNodes.filter((nodeId) => nodeId !== completedNodeId) : edgeResult.resetNodes;
       for (const nodeId of resetNodeIds) {
         sessionState.nodeOutputs.delete(nodeId);
@@ -2090,8 +2402,46 @@ var init_engine = __esm(() => {
         }
         logger3.debug(`[WorkflowEngine] Loop iteration #${sessionState.loopIterationCount}: re-entering ${edgeResult.reEntries.join(", ")}`);
       }
+      const loopGuardTripped = new Set;
+      for (const reEntryId of edgeResult.reEntries) {
+        const guard = sessionState.dagManager.getLoopGuard(reEntryId);
+        if (!guard)
+          continue;
+        const snapshotPreviousOutput = loopGuardSnapshots.get(reEntryId) ?? {};
+        const previousOutputsForGuard = new Map(sessionState.nodeOutputs);
+        previousOutputsForGuard.set(reEntryId, snapshotPreviousOutput);
+        const guardResolver = new TemplateResolver({
+          input: sessionState.config.workflowInput || {},
+          previousOutputs: previousOutputsForGuard
+        });
+        const verdict = await this.checkLoopGuardWithSnapshot(sessionState, guardResolver, reEntryId, snapshotPreviousOutput);
+        if (verdict.trip) {
+          const failOutput = {
+            ...snapshotPreviousOutput,
+            _loop_guard_triggered: true,
+            fail_reason: verdict.failMessage,
+            [verdict.counterKey]: verdict.nextCount
+          };
+          sessionState.nodeOutputs.set(reEntryId, failOutput);
+          sessionState.loopGuardCounters.set(reEntryId, verdict.nextCount);
+          scheduler.markFailed(reEntryId);
+          loopGuardTripped.add(reEntryId);
+          logger3.warn(`[WorkflowEngine] loop_guard tripped for ${reEntryId} after ${verdict.nextCount} consecutive no-progress re-entries: ${verdict.failMessage}`);
+          await eventBus.publish(createWorkflowEvent("node.failed", runId, {
+            node_id: reEntryId,
+            error: {
+              message: verdict.failMessage
+            }
+          }));
+        } else if (verdict.nextCount > 0) {
+          sessionState.loopGuardCounters.set(reEntryId, verdict.nextCount);
+        }
+      }
       const workflowInput = sessionState.config.workflowInput || {};
       for (const targetId of edgeResult.toStart) {
+        if (loopGuardTripped.has(targetId)) {
+          continue;
+        }
         if (targetId === "__end__" || targetId === "__END__") {
           logger3.info(`[WorkflowEngine] Workflow terminated via __end__ edge from node "${completedNodeId}"`);
           scheduler.markCompleted("__end__");
@@ -2142,7 +2492,9 @@ var init_engine = __esm(() => {
         },
         workflowInput,
         templateResolver,
-        resolvedConfig: templateResolver.resolveValue(effectiveConfig)
+        resolvedConfig: templateResolver.resolveValue(effectiveConfig),
+        abortSignal: sessionState.cancellationScope?.signal ?? sessionState.abortController.signal,
+        ...sessionState.cancellationScope ? { cancellationScope: sessionState.cancellationScope } : {}
       };
       return context;
     }
@@ -2224,10 +2576,15 @@ var init_engine = __esm(() => {
         error: { message: error.message, stack: error.stack },
         failed_at: new Date().toISOString()
       }), true);
+      const partialOutput = {};
+      for (const [nodeId, nodeOutput] of sessionState.nodeOutputs) {
+        partialOutput[nodeId] = nodeOutput;
+      }
       sessionState.resolveCompleted({
         runId,
         status: "failed",
         error: error.message,
+        output: partialOutput,
         durationMs
       });
       this.cleanupSession(sessionState);