power-loop 6.45.0__tar.gz → 6.46.0__tar.gz

{power_loop-6.45.0 → power_loop-6.46.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: power-loop
-Version: 6.45.0
+Version: 6.46.0
 Summary: Embeddable agent execution kernel — LLM loop, hooks, events, tools, dynamic sub-agents.
 Author-email: zhangran <zhangran24@126.com>
 License: MIT

{power_loop-6.45.0 → power_loop-6.46.0}/power_loop/__init__.py

@@ -15,7 +15,7 @@ Stability tiers
 无版本承诺，可随时变更或删除。
 """
 
-__version__ = "6.45.0"
+__version__ = "6.46.0"
 
 # Public LLM contract (SDK-free) re-exported so callers (e.g. writing llm.* hooks or
 # a custom LLMService) don't reach into the internal vendored transport package (H3.4).

{power_loop-6.45.0 → power_loop-6.46.0}/power_loop/agent/stateful_loop.py

@@ -187,6 +187,8 @@ class _SessionSync:
     # waiting tools await it); cleared when the inbox is claimed.
     steer: asyncio.Event = field(default_factory=asyncio.Event)
     refs: set[int] = field(default_factory=set)
+    # 运行中追加的轮数（6.46，extend_rounds）：正在跑的这个 send 在下一轮开始时把它加到轮数上限上。
+    round_bonus: int = 0
 
 
 # session_id -> _SessionSync. PROCESS-GLOBAL and deliberately NOT per-instance state.
@@ -208,6 +210,17 @@ class _SessionSync:
 # session driven from two event loops (e.g. mixing the sync API's runner thread with direct async
 # calls) is already broken today with per-instance locks. This changes nothing there.
 _SESSION_SYNC: dict[str, _SessionSync] = {}
+
+
+def take_round_bonus(session_id: str | None) -> int:
+    """取走这个会话运行中追加的轮数（6.46，extend_rounds）；流水线每轮开始时调。"""
+    if not session_id:
+        return 0
+    entry = _SESSION_SYNC.get(session_id)
+    if entry is None or entry.round_bonus <= 0:
+        return 0
+    n, entry.round_bonus = entry.round_bonus, 0
+    return n
 # Guards only registry mutation (dict insert/delete) — instances may be constructed from several
 # threads. Never held across an await.
 _SESSION_SYNC_GUARD = threading.Lock()
@@ -871,6 +884,15 @@ class StatefulAgentLoop:
         store = await self._ensure_store()
         return await store.inbox_counts(session_id)
 
+    def extend_rounds(self, session_id: str, rounds: int) -> bool:
+        """给**正在跑**的会话加轮数（6.46，DeepTalk design/170）：它在下一轮开始时把轮数上限加上 ``rounds``。
+        会话没在跑（锁没被占）返回 False——空闲的会话用 follow_up / send 的 max_rounds。"""
+        entry = _SESSION_SYNC.get(session_id)
+        if entry is None or not entry.lock.locked() or int(rounds) <= 0:
+            return False
+        entry.round_bonus += int(rounds)
+        return True
+
     def steer_event(self, session_id: str) -> asyncio.Event:
         """The session's "steering is waiting" event (set while a ``mode="steer"`` item this
         process accepted is undelivered). Interrupt points and waiting tools await it."""

{power_loop-6.45.0 → power_loop-6.46.0}/power_loop/core/pipeline.py

@@ -1600,6 +1600,10 @@ class AgentPipeline:
         round_idx = -1
         while True:
             round_idx += 1
+            from power_loop.agent.stateful_loop import take_round_bonus
+            _bonus = take_round_bonus(self.session_id)
+            if _bonus:
+                self._round_limit += _bonus   # 宿主在运行中加了轮数（extend_rounds）
             if round_idx >= self._round_limit:
                 # ── Hook: COMPLETE_DECIDE (round budget exhausted) ──
                 # A SHORT_CIRCUIT with inject extends the budget and keeps

{power_loop-6.45.0 → power_loop-6.46.0}/power_loop/runtime/spec.py

@@ -238,6 +238,10 @@ def _publish_subagent_event(
 _USAGE_SINK: ContextVar[dict[str, int] | None] = ContextVar("power_loop_usage_sink", default=None)
 
 
+#: 子会话建好时的回调（6.46）：``cb(child_session_id)``，可以是协程函数。workflow 引擎用它记「节点 → 叶子会话」。
+_ON_CHILD_SESSION: ContextVar[Any] = ContextVar("power_loop_on_child_session", default=None)
+
+
 def _add_usage(into: dict[str, int], usage: dict[str, Any] | None) -> None:
     for k, v in (usage or {}).items():
         if isinstance(v, (int, float)) and not isinstance(v, bool):
@@ -369,6 +373,16 @@ async def run_agent_spec(
         # name, not the raw session UUID (subagent-coordination-3): blackboard._author reads metadata.
         metadata={**dict(spec.metadata), "spec_name": spec.name},
     )
+    # 子会话建好就告诉设了回调的那一层（6.46：workflow 引擎把「节点 → 叶子会话」记进 journal，重启后 resume 接着原会话跑）。
+    # 只告诉最外层：这次子运行期间把回调清掉，叶子自己再派的子 agent 不会被当成叶子会话。
+    _session_cb = _ON_CHILD_SESSION.get()
+    if _session_cb is not None:
+        try:
+            _r = _session_cb(child_sid)
+            if hasattr(_r, "__await__"):
+                await _r
+        except Exception:  # noqa: BLE001 — 观测回调失败不毁子运行
+            pass
 
     child_row = await store.get_session(child_sid)
     depth = child_row.spawn_depth if child_row is not None else 1
@@ -424,11 +438,13 @@ async def run_agent_spec(
             _outer_sink = _USAGE_SINK.get()
             _my_sink: dict[str, int] = {}
             _sink_tok = _USAGE_SINK.set(_my_sink)
+            _cb_tok = _ON_CHILD_SESSION.set(None)
             try:
                 result = await child_loop.send(
                     user_input, session_id=child_sid, stop_event=stop_event
                 )
             finally:
+                _ON_CHILD_SESSION.reset(_cb_tok)
                 _USAGE_SINK.reset(_sink_tok)
             _total_usage: dict[str, int] = {}
             _add_usage(_total_usage, dict(result.usage or {}))

{power_loop-6.45.0 → power_loop-6.46.0}/power_loop/workflow/__init__.py

@@ -65,6 +65,7 @@ from .spec import (
     BranchNode,
     ContinuationPolicy,
     ForeachNode,
+    LoopNode,
     ParallelNode,
     RetryPolicy,
     SequenceNode,
@@ -100,6 +101,7 @@ __all__ = [
     "SequenceNode",
     "ParallelNode",
     "ForeachNode",
+    "LoopNode",
     "BranchNode",
     # engine
     "WorkflowEngine",

{power_loop-6.45.0 → power_loop-6.46.0}/power_loop/workflow/engine.py

@@ -38,7 +38,7 @@ from typing import Any, Protocol
 
 from power_loop.core.agent_context import reset_session_id, set_session_id
 from power_loop.runtime.cancellation import CancellationLike, CancellationToken
-from power_loop.runtime.spec import AgentSpec, run_agent_spec
+from power_loop.runtime.spec import _ON_CHILD_SESSION, AgentSpec, run_agent_spec
 from power_loop.runtime.structured import StructuredOutputError, parse_structured
 
 from .result import AgentResult, SharedBudget, WorkflowResult
@@ -48,12 +48,16 @@ from .spec import (
     AgentNode,
     BranchNode,
     ForeachNode,
+    LoopNode,
     ParallelNode,
     SequenceNode,
     WorkflowNode,
     WorkflowSpec,
 )
 
+#: 循环信息在 env 里的键（模板变量正则匹配不到它，不会被当成 {{变量}}）
+_LOOP_KEY = "\x00loop"
+
 __all__ = ["Executor", "InProcessExecutor", "WorkflowEngine", "WorkflowRunError", "in_workflow"]
 
 logger = logging.getLogger(__name__)
@@ -65,6 +69,34 @@ MAX_TOTAL_LEAVES = 10_000
 
 #: ``{{var}}``（foreach 变量等）和 ``{{node.key}}``（上游节点结构化输出里的一个键，6.45：之前不认带点的名字，
 #: YAML 的 ``${{ needs.x.outputs.k }}`` 编成 ``{{x.k}}`` 后原样送给了模型）。节点 id 可以带短横线。
+def _agent_ids(node: WorkflowNode) -> list[str]:
+    out: list[str] = []
+    if isinstance(node, AgentNode):
+        return [node.id]
+    for child in (getattr(node, "steps", None) or getattr(node, "branches", None) or ()):
+        out += _agent_ids(child)
+    if isinstance(node, BranchNode):
+        for c in node.cases.values():
+            out += _agent_ids(c)
+        if node.default is not None:
+            out += _agent_ids(node.default)
+    if isinstance(node, (ForeachNode, LoopNode)):
+        out += _agent_ids(node.body)
+    return out
+
+
+def _loop_prompt(lc: dict[str, Any], user_input: str) -> str:
+    """循环第 2 轮起给 continue_nodes 的话：上一轮为什么没过、意见是什么、在已有成果上改。"""
+    return (f"第 {lc['iteration']}/{lc['max']} 轮：上一轮没通过（{lc.get('why') or ''}）。\n"
+            f"上一轮的意见：\n{lc.get('feedback') or ''}\n\n"
+            "按意见改。你上一轮做的都还在（会话、文件），在已有成果上改，不要从头重做。改完照原来的要求交卷。\n\n"
+            f"（这一轮的任务输入照旧附在下面）\n{user_input}")
+
+
+#: 重启后在原会话接着跑时给叶子的话（6.46）
+_RESUME_PROMPT = ("进程重启打断了你，你的会话、文件和半成品都还在。先看一眼自己做到哪了（todo、产出文件），"
+                  "接着把原来的任务做完，然后照原来的要求给出最终回复。")
+
 _VAR_RE = re.compile(r"\{\{\s*([a-zA-Z_][\w-]*(?:\.[a-zA-Z_]\w*)?)\s*\}\}")
 
 # Set while a workflow run is in flight. Propagates into child sub-agent tasks
@@ -249,6 +281,8 @@ class WorkflowEngine:
         close_driver: bool = True,
         allowed_tools: frozenset[str] | None = None,
         file_io: WorkflowFileIO | None = None,
+        on_node_session: Callable[[str, str], Awaitable[None]] | None = None,
+        resume_sessions: dict[str, str] | None = None,
     ) -> None:
         self._loop = parent_loop
         self._executor = executor or InProcessExecutor()
@@ -275,7 +309,17 @@ class WorkflowEngine:
         # Cooperative cancellation: forwarded into every in-flight leaf so they
         # stop at their next checkpoint, and checked before spawning new leaves
         # so a cancelled run stops fanning out.
-        self._cancel: CancellationToken = CancellationToken.from_any(stop_event)
+        # 6.46：引擎自己也持有一个令牌（run 超时用它停整个 run），和外面传进来的「谁取消都算」。
+        self._own_cancel = CancellationToken()
+        self._cancel: CancellationToken = CancellationToken.any_of(
+            CancellationToken.from_any(stop_event), self._own_cancel)
+        self._timed_out = False
+        # 单节点取消（6.46）：每个节点一个子令牌——取消它只停这个节点，run 和别的节点照跑。
+        self._node_tokens: dict[str, list[CancellationToken]] = {}
+        self._node_cancelled: set[str] = set()
+        # 叶子会话建好时的观察者（runner 把「节点 → 会话」记进 journal）；resume 时有会话的节点在原会话接着跑。
+        self._on_node_session = on_node_session
+        self._resume_sessions: dict[str, str] = dict(resume_sessions or {})
         # Resume support: results of already-completed nodes, keyed by node id,
         # rehydrated from a run's journal. A node whose id is here is replayed
         # (its cached result is returned) instead of re-executed. Foreach-body
@@ -325,6 +369,13 @@ class WorkflowEngine:
             env: dict[str, Any] = {"input": spec.input}
             status = "completed"
             guard = _IN_WORKFLOW.set(True)
+            watchdog: asyncio.Task[None] | None = None
+            if spec.timeout_s:
+                async def _watchdog(limit: float = float(spec.timeout_s)) -> None:
+                    await asyncio.sleep(limit)
+                    self._timed_out = True
+                    self._own_cancel.cancel(f"run timeout ({int(limit)}s)")
+                watchdog = asyncio.create_task(_watchdog(), name="workflow-timeout")
             try:
                 await self._exec(spec.root, env, driver_sid)
             except WorkflowRunError as exc:
@@ -332,7 +383,12 @@ class WorkflowEngine:
                 self._errors.append(str(exc))
             finally:
                 _IN_WORKFLOW.reset(guard)
-            if self._cancelled or self._cancel.is_cancelled():
+                if watchdog is not None:
+                    watchdog.cancel()
+            if self._timed_out:
+                status = "failed"
+                self._errors.append(f"run 超时（{int(spec.timeout_s or 0)} 秒）：没跑完的节点已停，没开始的不再启动")
+            elif self._cancelled or self._cancel.is_cancelled():
                 status = "cancelled"
             elif self._budget_hit:
                 status = "budget_exceeded"
@@ -345,7 +401,7 @@ class WorkflowEngine:
                 # （只认 "failed" 的老判定漏掉它；continuation 救回来的已经是 completed 了）。
                 broken = [
                     nid for nid, r in self._results.items()
-                    if r.status not in ("completed",) and nid not in self._tolerated
+                    if r.status not in ("completed", "skipped") and nid not in self._tolerated
                 ]
                 if broken:
                     status = "failed"
@@ -397,8 +453,63 @@ class WorkflowEngine:
             return await self._exec_foreach(node, env, driver_sid)
         if isinstance(node, BranchNode):
             return await self._exec_branch(node, env, driver_sid)
+        if isinstance(node, LoopNode):
+            return await self._exec_loop(node, env, driver_sid)
         raise WorkflowRunError(f"unknown node type: {type(node).__name__}")
 
+    async def _exec_loop(self, node: LoopNode, env: dict[str, Any], driver_sid: str) -> AgentResult:
+        """反复跑循环体直到 ``until`` 成立（6.46，design/170 第三批）。循环信息随 env 往下传（几个循环可以并行跑）。"""
+        replayed = self._replay.pop(node.id, None)
+        if replayed is not None:
+            # 整体重放：把最后一轮各节点的结果还原，循环之后对它们的引用照样能用
+            for nid, r in ((replayed.payload or {}).get("last") or {}).items():
+                self._results[nid] = AgentResult(node_id=nid, status=str(r.get("status") or "completed"),
+                                                 text=str(r.get("text") or ""), payload=r.get("payload"),
+                                                 session_id=r.get("session_id"))
+            self._results[node.id] = replayed
+            self._add_usage(replayed.usage)
+            return replayed
+        body_ids = _agent_ids(node.body)
+        feedback_node = str(node.until.get("ref") or "").split(".", 1)[0]
+        prev: dict[str, str] = {}
+        converged, why, iteration = False, "", 0
+        for iteration in range(1, node.max_iterations + 1):
+            if self._cancel.is_cancelled():
+                break
+            lc = {"loop_id": node.id, "iteration": iteration, "max": node.max_iterations,
+                  "continue": set(node.continue_nodes), "prev": dict(prev), "why": why,
+                  "feedback": self._loop_feedback(feedback_node) if iteration > 1 else ""}
+            await self._exec(node.body, {**env, _LOOP_KEY: lc, "loop_iteration": iteration}, driver_sid)
+            for nid in node.continue_nodes:
+                r = self._results.get(nid)
+                if r is not None and r.session_id:
+                    prev[nid] = r.session_id
+            converged, why = self._eval_when(node.until)
+            if converged:
+                break
+            logger.info("workflow loop %s: iteration %d/%d not done (%s)", node.id, iteration, node.max_iterations, why)
+        last = {nid: {"status": r.status, "text": (r.text or "")[:4000], "payload": r.payload, "session_id": r.session_id}
+                for nid in body_ids if (r := self._results.get(nid)) is not None}
+        payload = {"converged": converged, "iterations": iteration, "why": why, "last": last}
+        ok = converged or (node.on_exhausted == "continue" and not self._cancel.is_cancelled())
+        err = None if converged else (f"跑了 {iteration} 轮仍不满足 until：{why}" if not self._cancel.is_cancelled()
+                                      else "循环被取消")
+        res = AgentResult(node_id=node.id, status="completed" if ok else ("cancelled" if self._cancel.is_cancelled() else "failed"),
+                          text=f"循环 {node.id}：{'满足' if converged else '没满足'}（{iteration} 轮）：{why}",
+                          payload=payload, error=err)
+        self._results[node.id] = res
+        await self._emit_step(res)
+        return res
+
+    def _loop_feedback(self, node_id: str) -> str:
+        """上一轮 until 引用的那个节点交回的意见（结构化结果优先）。"""
+        r = self._results.get(node_id)
+        if r is None:
+            return "（上一轮没有意见）"
+        if r.payload is not None:
+            return json.dumps(r.payload, ensure_ascii=False)[:4000]
+        return (r.text or r.error or "")[:4000]
+
     async def _exec_agent(self, node: AgentNode, env: dict[str, Any], driver_sid: str) -> AgentResult:
         # Resume: a completed node is replayed from the journal, not re-run. Pop
         # so a body id that somehow leaked in can only ever replay once.
@@ -417,6 +528,14 @@ class WorkflowEngine:
             await self._emit_step(res)
             return res
 
+        if node.when is not None:
+            ok, why = self._eval_when(node.when)
+            if not ok:
+                res = AgentResult(node_id=node.id, status="skipped", text="", error=f"条件不成立，跳过：{why}")
+                self._results[node.id] = res
+                await self._emit_step(res)
+                return res
+
         if self._budget is not None and not self._budget.can_spawn():
             self._budget_hit = True
             res = AgentResult(node_id=node.id, status="budget_exceeded", text="",
@@ -441,7 +560,9 @@ class WorkflowEngine:
                 up = self._results.get(ref)
                 if up is None:
                     continue
-                if up.status != "completed":
+                if up.status == "skipped":
+                    extras.append(f"[上游节点 '{ref}' 条件不成立，跳过了：{up.error or ''}]")
+                elif up.status != "completed":
                     # 🔴 上游失败时**绝不能**给空字符串:下游模型会把「没说话」读成「没意见」,
                     # 进而在缺证据的情况下下结论。给一个显式的失败说明。
                     extras.append(
@@ -502,6 +623,34 @@ class WorkflowEngine:
             except Exception:  # noqa: BLE001 — observability must not fail the run
                 pass
 
+        node_tok = self._cancel.child()
+        self._node_tokens.setdefault(node.id, []).append(node_tok)
+        # 重启后接着跑（6.46）：这个节点上次有叶子会话、没做完 → 先在原会话补轮；补不了再照常开新会话。
+        resumed_raw: dict[str, Any] | None = None
+        rs = self._resume_sessions.pop(node.id, None) if not self._emit_suppressed else None
+        if rs:
+            try:
+                resumed_raw = await self._continue_leaf(
+                    rs, _RESUME_PROMPT, extra_rounds=max(int(node.spec.max_rounds or 30), 10), stop=node_tok)
+                resumed_raw.setdefault("session_id", rs)
+                logger.info("workflow leaf %s resumed in its original session %s", node.id, rs)
+            except Exception as exc:  # noqa: BLE001 — 会话丢了就照常重跑
+                logger.warning("workflow leaf %s: resume in session %s failed (%s); re-running", node.id, rs, exc)
+                resumed_raw = None
+
+        lc = env.get(_LOOP_KEY)
+        if (resumed_raw is None and lc and lc["iteration"] > 1 and node.id in lc["continue"]
+                and lc["prev"].get(node.id)):
+            prev_sid = lc["prev"][node.id]
+            try:
+                resumed_raw = await self._continue_leaf(
+                    prev_sid, _loop_prompt(lc, user_input), extra_rounds=max(int(node.spec.max_rounds or 30), 10), stop=node_tok)
+                resumed_raw.setdefault("session_id", prev_sid)
+            except Exception as exc:  # noqa: BLE001 — 接不上就照常新开会话
+                logger.warning("workflow loop %s: continuing %s in %s failed (%s); fresh run",
+                               lc["loop_id"], node.id, prev_sid, exc)
+                resumed_raw = None
+
         # ── 重试循环（design/64 §1）──────────────────────────────────────────────
         # 每次 attempt 都起**新的叶子会话**（失败会话的上下文可能已被半截的工具调用污染）。
         # idempotency_key 跨 attempt 不变（变了工具就没法去重），attempt 号单独进 metadata。
@@ -522,15 +671,24 @@ class WorkflowEngine:
                     # 第 N 次重试等 backoff_s * factor**(N-1)；factor=1 就是固定间隔。
                     delay = policy.backoff_s * (policy.backoff_factor ** (attempt - 2))
                     await asyncio.sleep(min(delay, MAX_BACKOFF_S))
-            raw = await self._executor.run_agent(
-                replace(spec, metadata={**spec.metadata, "attempt": attempt}),
-                user_input, parent_loop=self._loop, driver_sid=driver_sid,
-                stop_event=self._cancel,
-            )
+            if attempt == 1 and resumed_raw is not None:
+                raw = resumed_raw
+            else:
+                cb_tok = (_ON_CHILD_SESSION.set(self._session_cb(node.id))
+                          if self._on_node_session is not None and not self._emit_suppressed else None)
+                try:
+                    raw = await self._executor.run_agent(
+                        replace(spec, metadata={**spec.metadata, "attempt": attempt}),
+                        user_input, parent_loop=self._loop, driver_sid=driver_sid,
+                        stop_event=node_tok,
+                    )
+                finally:
+                    if cb_tok is not None:
+                        _ON_CHILD_SESSION.reset(cb_tok)
             if attempt >= max_attempts or not self._should_retry(raw, triggers):
                 break
             # 取消/预算耗尽时不再重试:那不是「这次没跑好」,是整个 run 该停了。
-            if self._cancel.is_cancelled() or (
+            if node_tok.is_cancelled() or (
                 self._budget is not None and not self._budget.can_spawn()
             ):
                 break
@@ -546,7 +704,7 @@ class WorkflowEngine:
             for c_i in range(1, cont.max_continuations + 1):
                 if str(raw.get("status")) not in ("hit_round_limit", "context_checkpoint") or not raw.get("session_id"):
                     break
-                if self._cancel.is_cancelled() or (
+                if node_tok.is_cancelled() or (
                     self._budget is not None and not self._budget.can_spawn()
                 ):
                     break
@@ -558,7 +716,7 @@ class WorkflowEngine:
                             node.id, c_i, cont.max_continuations, cont.extra_rounds)
                 try:
                     more = await self._continue_leaf(
-                        str(raw["session_id"]), prompt, extra_rounds=cont.extra_rounds)
+                        str(raw["session_id"]), prompt, extra_rounds=cont.extra_rounds, stop=node_tok)
                 except Exception as exc:  # noqa: BLE001 — 续跑失败不毁掉已有成果
                     logger.warning("workflow leaf %s continuation failed: %s", node.id, exc)
                     break
@@ -577,7 +735,12 @@ class WorkflowEngine:
                     self._budget.commit(more.get("usage") or {})
 
         if str(raw.get("status")) == "cancelled":
-            self._cancelled = True
+            if node_tok.is_cancelled() and not self._cancel.is_cancelled():
+                # 只取消了这一个节点（cancel_node）：run 照跑，这个节点按「放行的失败」记
+                self._node_cancelled.add(node.id)
+                raw = {**raw, "error": raw.get("error") or f"节点被单独取消：{node_tok.reason}"}
+            else:
+                self._cancelled = True
         payload: dict[str, Any] | None = None
         err: str | None = None
         if node.output_schema is not None and raw.get("status") == "completed":
@@ -624,11 +787,59 @@ class WorkflowEngine:
                 await self._emit_step(res)
                 return res
 
-        # continue_on_error:失败但明确放行——记下来,run 终态判定跳过它。
-        if res.status == "failed" and node.continue_on_error:
+        # continue_on_error:失败但明确放行——记下来,run 终态判定跳过它。被单独取消的节点同样放行。
+        if (res.status == "failed" and node.continue_on_error) or node.id in self._node_cancelled:
             self._tolerated.add(node.id)
         return res
 
+    def _session_cb(self, node_id: str) -> Callable[[str], Awaitable[None]]:
+        async def _cb(sid: str) -> None:
+            if self._on_node_session is not None:
+                try:
+                    await self._on_node_session(node_id, sid)
+                except Exception:  # noqa: BLE001 — 观测失败不毁叶子
+                    logger.debug("on_node_session failed for %s", node_id, exc_info=True)
+        return _cb
+
+    def cancel_node(self, node_id: str, reason: str = "cancelled by host") -> int:
+        """只取消一个节点（6.46）：它在跑就在下一个检查点停下，run 和别的节点照跑；被取消的节点按「放行的失败」记。
+        返回取消了几个在跑的叶子（foreach 的迭代共用一个 id，会一起停）。"""
+        n = 0
+        for tok in self._node_tokens.get(node_id) or []:
+            if not tok.is_cancelled():
+                tok.cancel(reason)
+                n += 1
+        return n
+
+    def _eval_when(self, when: dict[str, Any]) -> tuple[bool, str]:
+        """``when`` 成立吗？引用取不到（上游失败 / 跳过 / 没交结构化结果）按不成立。返回 (成立, 说明)。"""
+        ref = str(when.get("ref") or "")
+        op = str(when.get("op") or "truthy")
+        try:
+            value = self._resolve_ref(ref)
+        except WorkflowRunError as exc:
+            return False, f"取不到 {ref}（{exc}）"
+
+        def norm(x: Any) -> Any:
+            if isinstance(x, str) and x.strip().lower() in ("true", "false"):
+                return x.strip().lower() == "true"
+            return x
+
+        v = norm(value)
+        target = when.get("value")
+        if op == "truthy":
+            ok = bool(v)
+        elif op == "falsy":
+            ok = not bool(v)
+        elif op == "eq":
+            ok = v == norm(target) or str(value) == str(target)
+        elif op == "ne":
+            ok = not (v == norm(target) or str(value) == str(target))
+        else:  # in
+            ok = any(v == norm(x) or str(value) == str(x) for x in (target or []))
+        shown = json.dumps(value, ensure_ascii=False)[:80] if not isinstance(value, str) else value[:80]
+        return ok, f"{ref} = {shown}（要求 {op}{'' if op in ('truthy', 'falsy') else ' ' + json.dumps(target, ensure_ascii=False)[:60]}）"
+
     def _render_fileref(self, path: str, slice_expr: str) -> str:
         if self._file_io is None:
             return ""
@@ -651,14 +862,15 @@ class WorkflowEngine:
         except Exception:  # noqa: BLE001
             return []
 
-    async def _continue_leaf(self, session_id: str, prompt: str, *, extra_rounds: int) -> dict[str, Any]:
+    async def _continue_leaf(self, session_id: str, prompt: str, *, extra_rounds: int,
+                             stop: CancellationToken | None = None) -> dict[str, Any]:
         """原会话补轮。走 executor 的 ``continue_agent``（host 可换实现，如加自己的 guards）；
         没有该方法的旧 executor 退回 InProcessExecutor 的默认路径。"""
         fn = getattr(self._executor, "continue_agent", None)
         if fn is None:
             fn = InProcessExecutor().continue_agent
         return await fn(session_id, prompt, parent_loop=self._loop,
-                        extra_rounds=extra_rounds, stop_event=self._cancel)
+                        extra_rounds=extra_rounds, stop_event=stop or self._cancel)
 
     @staticmethod
     def _should_retry(raw: dict[str, Any], triggers: set[str]) -> bool:

{power_loop-6.45.0 → power_loop-6.46.0}/power_loop/workflow/journal.py

@@ -189,6 +189,23 @@ async def node_start(
     await store.mutate_runtime_state(parent_sid, run_key(run_id), _apply, default=None)
 
 
+async def node_session(
+    store: SessionStore, parent_sid: str, run_id: str, *, node_id: str, session_id: str
+) -> None:
+    """记下节点的叶子会话（``live_sessions[node_id] = session_id``，6.46）。进程重启后 resume 对没做完、
+    有会话的节点在原会话接着跑，不再从头开新会话（叶子的上下文和半成品都在）。"""
+    def _apply(jn: Any) -> Any:
+        if jn is None or _is_terminal(jn.get("status")):
+            return MUTATE_SKIP
+        ls = dict(jn.get("live_sessions") or {})
+        ls[node_id] = session_id
+        jn["live_sessions"] = ls
+        jn["updated_at_ms"] = _now_ms()
+        return jn
+
+    await store.mutate_runtime_state(parent_sid, run_key(run_id), _apply, default=None)
+
+
 async def record_step(
     store: SessionStore,
     parent_sid: str,

{power_loop-6.45.0 → power_loop-6.46.0}/power_loop/workflow/resume.py

@@ -42,6 +42,7 @@ from .runner import (
     _LIVE_RUN_IDS,
     OnComplete,
     is_run_live,
+    make_on_node_session,
     make_on_node_start,
     make_on_step,
     spawn_background,
@@ -50,6 +51,7 @@ from .spec import (
     AgentNode,
     BranchNode,
     ForeachNode,
+    LoopNode,
     ParallelNode,
     SequenceNode,
     WorkflowNode,
@@ -97,6 +99,12 @@ def _collect(node: WorkflowNode, *, in_foreach_body: bool, out: set[str]) -> Non
             out.add(node.id)  # the aggregate is atomically replayable
         _collect(node.body, in_foreach_body=True, out=out)  # body ids are not
         return
+    if isinstance(node, LoopNode):
+        # 循环整体重放（聚合里带着最后一轮的结果）；循环体里的节点不单独重放——没跑完的循环 resume 时从头再跑（6.46）
+        if not in_foreach_body:
+            out.add(node.id)
+        _collect(node.body, in_foreach_body=True, out=out)
+        return
     if isinstance(node, BranchNode):
         for c in node.cases.values():
             _collect(c, in_foreach_body=in_foreach_body, out=out)
@@ -143,6 +151,31 @@ async def rehydrate(
     return spec, replay, j
 
 
+def _session_resumable_ids(node: WorkflowNode, *, in_foreach: bool, out: set[str]) -> None:
+    """能在原会话接着跑的节点：foreach 体以外的 agent（循环体里的也算——循环重跑时第一轮接着原会话）。"""
+    if isinstance(node, AgentNode):
+        if not in_foreach:
+            out.add(node.id)
+        return
+    for child in (getattr(node, "steps", None) or getattr(node, "branches", None) or ()):
+        _session_resumable_ids(child, in_foreach=in_foreach, out=out)
+    if isinstance(node, BranchNode):
+        for c in node.cases.values():
+            _session_resumable_ids(c, in_foreach=in_foreach, out=out)
+        if node.default is not None:
+            _session_resumable_ids(node.default, in_foreach=in_foreach, out=out)
+    if isinstance(node, (ForeachNode, LoopNode)):
+        _session_resumable_ids(node.body, in_foreach=in_foreach or isinstance(node, ForeachNode), out=out)
+
+
+def resume_sessions(spec: WorkflowSpec, replay: dict[str, AgentResult], j: dict[str, Any]) -> dict[str, str]:
+    """没做完、但记下了叶子会话的节点（6.46）：resume 时在原会话接着跑，不从头开。foreach 迭代不在内（共用 id）。"""
+    ok: set[str] = set()
+    _session_resumable_ids(spec.root, in_foreach=False, out=ok)
+    return {nid: str(sid) for nid, sid in (j.get("live_sessions") or {}).items()
+            if nid in ok and nid not in replay and sid}
+
+
 def _journaled_clamp(j: dict[str, Any]) -> frozenset[str] | None:
     """The run's journaled capability clamp (see ``journal.new_journal``).
 
@@ -208,6 +241,8 @@ async def resume_run(
         loop, executor=executor, budget=budget,
         on_step=make_on_step(store, parent_sid, run_id),
         on_node_start=make_on_node_start(store, parent_sid, run_id),
+        on_node_session=make_on_node_session(store, parent_sid, run_id),
+        resume_sessions=resume_sessions(spec, replay, j),
         replay=replay, run_id=run_id,
         allowed_tools=_journaled_clamp(j),
         file_io=file_io,
@@ -259,6 +294,8 @@ async def resume_detached(
             loop, executor=executor, budget=budget,
             on_step=make_on_step(store, parent_sid, run_id),
             on_node_start=make_on_node_start(store, parent_sid, run_id),
+            on_node_session=make_on_node_session(store, parent_sid, run_id),
+            resume_sessions=resume_sessions(spec, replay, j),
             replay=replay, run_id=run_id, stop_event=cancel_token,
             allowed_tools=_journaled_clamp(j),
             file_io=file_io,