power-loop 6.46.4__tar.gz → 6.47.0__tar.gz

{power_loop-6.46.4 → power_loop-6.47.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: power-loop
-Version: 6.46.4
+Version: 6.47.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.46.4 → power_loop-6.47.0}/power_loop/__init__.py

@@ -15,7 +15,7 @@ Stability tiers
 无版本承诺，可随时变更或删除。
 """
 
-__version__ = "6.46.4"
+__version__ = "6.47.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.46.4 → power_loop-6.47.0}/power_loop/agent/stateful_loop.py

@@ -785,6 +785,7 @@ class StatefulAgentLoop:
         tools: Sequence[str] | ToolRegistry | None = None,
         system_prompt: str | None = None,
         max_rounds: int | None = None,
+        enqueue_only: bool = False,
     ) -> StatefulResult | FollowUpQueued:
         """Put ``items`` in front of the session's model — now, or as soon as it can take them.
 
@@ -798,6 +799,8 @@ class StatefulAgentLoop:
           them. Returns :class:`FollowUpQueued`.
         * idle → a fresh send runs with the waiting items as its input (everything pending —
           including items a cancelled run left behind — oldest first). Returns its result.
+        * ``enqueue_only=True`` → persist and return without starting an idle send;
+          the orchestration owner must drain it, including the terminal window.
         * nothing new (all duplicates) → :class:`FollowUpQueued` with ``accepted=0``.
 
         ``stop_event`` / ``tools`` / ``system_prompt`` / ``max_rounds`` apply only to a run this
@@ -824,7 +827,7 @@ class StatefulAgentLoop:
                 duplicates=len(rows) - len(accepted), accepted_ids=tuple(accepted),
             )
 
-        if not accepted or self._lock_for(sid).locked():
+        if enqueue_only or not accepted or self._lock_for(sid).locked():
             return await _queued()
         if self.config.distributed_sessions:
             # Idle HERE, but another process may be driving this session: its run claims the
@@ -847,6 +850,7 @@ class StatefulAgentLoop:
         tools: Sequence[str] | ToolRegistry | None = None,
         system_prompt: str | None = None,
         max_rounds: int | None = None,
+        enqueue_only: bool = False,
         kind: str = INBOX_KIND_USER,
         mode: str = "queue",
         item_id: str | None = None,
@@ -865,7 +869,7 @@ class StatefulAgentLoop:
         return await self.deliver(
             InboxItem(content=user_input, kind=kind, mode=mode, item_id=item_id),
             session_id, stop_event=stop_event, tools=tools, system_prompt=system_prompt,
-            max_rounds=max_rounds,
+            max_rounds=max_rounds, enqueue_only=enqueue_only,
         )
 
     def pending_follow_up_count(self, session_id: str) -> int:

{power_loop-6.46.4 → power_loop-6.47.0}/power_loop/agent/types.py

@@ -106,14 +106,10 @@ class AgentLoopConfig:
     #: 真实大小）≥ 它 → 以 ``context_checkpoint`` 优雅收尾本 send（COMPLETE_DECIDE 先给宿主收尾窗口）
     #: → 正常投影 → 宿主的续接机制在新 send 里接着干。与 ``max_tokens_per_run``（累计费用上限）正交。
     context_checkpoint_tokens: int | None = None
-    #: ``insend_distill_tokens``：send 内保险丝——**本 send 内新增**的上下文 ≥ 它时（6.27.0 起量的是
-    #: 增量：上一轮真实 prompt_tokens 减去本 send 第一轮的 prompt_tokens；拿不到真实用量就估算本 send
-    #: 新增的行），把当前 send 里热尾之外的冷工具结果**在内存里替换成它的投影行**（同一套
-    #: ToolDefinition.project 蒸馏 + ``recall_send`` 坐标），不落盘、不改 pl_messages。None → 关。
-    #: 6.27.0 之前量的是整个上下文（系统提示词 + 历史 + 本 send），一开局就可能超阈值、每轮都烧。
+    #: Total prompt threshold for in-send semantic distillation. When enabled,
+    #: context_checkpoint_tokens is ignored: fuse and cut are exclusive policies.
     insend_distill_tokens: int | None = None
-    #: 每次触发只蒸馏**最早**的 n 条尚未蒸馏的工具结果（逐轮递进：下一轮仍超阈值就再蒸馏下 n 条），
-    #: 且永远不动最近 ``hot_tail`` 条。触发依据优先用上一轮供应商返回的真实 prompt_tokens。
+    #: Deprecated compatibility field; does not limit the number of distilled calls.
     insend_distill_batch: int = 10
     insend_distill_hot_tail: int = 8
     #: 6.27.0 这些工具的**调用参数永不瘦身**（结果照旧）。给「模型自己说的话」用：send_message /

{power_loop-6.46.4 → power_loop-6.47.0}/power_loop/core/pipeline.py

@@ -882,76 +882,6 @@ class AgentPipeline:
 
     _DISTILL_MARK = "[distilled #"
 
-    #: 参数被瘦身后留在原位的标记（值本身仍是合法 JSON 字符串，工具早已执行完，
-    #: 这里只影响模型回看时读到什么）。
-    _ARGS_MARK = "⟨已移出上下文"
-    #: 单个参数字段超过它才瘦身：短字段（路径、开关、行号）留着才看得出这次调用干了什么。
-    _ARGS_KEEP_CHARS = 200
-
-    def _has_heavy_args(self, idx: int) -> bool:
-        """这一行是 assistant，且它的某个 tool_calls 参数里有还没瘦过的大字段。"""
-        m = self.history[idx]
-        if m.get("role") != "assistant":
-            return False
-        keep = set(getattr(self.config, "insend_distill_keep_tools", ()) or ())
-        for tc in m.get("tool_calls") or []:
-            fn = (tc or {}).get("function") or {}
-            if str(fn.get("name") or "") in keep:
-                continue
-            raw = fn.get("arguments")
-            if (
-                isinstance(raw, str)
-                and len(raw) > 300
-                and self._ARGS_MARK not in raw
-            ):
-                return True
-        return False
-
-    def _distill_tool_call_args(self, idx: int, seqs: list[Any]) -> int:
-        """把一行 assistant 的 tool_calls 参数里的大字段换成指针，**保持合法 JSON**。
-
-        为什么不套用投影那套逐工具规则：那边产出的是给人读的一行散文，而这里改的是
-        供应商要按 JSON 解析的 ``function.arguments``。所以规则通用——短字段原样留下
-        （路径、模式、行号这些才看得出这次调用干了什么），只有超过 ``_ARGS_KEEP_CHARS``
-        的长字符串换成一句带 ``recall_send`` 坐标的说明。工具早已执行完，改它不影响任何
-        副作用，只影响模型回看时读到什么。返回释放的估算 token。"""
-        m = self.history[idx]
-        seq = seqs[idx] if idx < len(seqs) else None
-        coord = (
-            f"recall_send(send_index={self.send_index}, seq={seq})"
-            if (self.send_index is not None and seq is not None)
-            else "recall_send"
-        )
-        freed = 0
-        keep = set(getattr(self.config, "insend_distill_keep_tools", ()) or ())
-        for tc in m.get("tool_calls") or []:
-            fn = (tc or {}).get("function") or {}
-            if str(fn.get("name") or "") in keep:
-                continue   # 模型自己的发言（send_message 之类）：瘦成占位符它会照样再发一遍
-            raw = fn.get("arguments")
-            if not isinstance(raw, str) or len(raw) <= 300 or self._ARGS_MARK in raw:
-                continue
-            try:
-                args = json.loads(raw)
-            except (TypeError, ValueError):
-                continue
-            if not isinstance(args, dict):
-                continue
-            slim = {
-                k: (
-                    f"{self._ARGS_MARK} {len(v)} 字符，需要时 {coord} 回取⟩"
-                    if isinstance(v, str) and len(v) > self._ARGS_KEEP_CHARS
-                    else v
-                )
-                for k, v in args.items()
-            }
-            new_raw = json.dumps(slim, ensure_ascii=False)
-            if len(new_raw) >= len(raw):
-                continue  # 没省下就别动（改了反而打断前缀缓存）
-            fn["arguments"] = new_raw
-            freed += (len(raw) - len(new_raw)) // 4
-        return freed
-
     def _context_profile(self, start: int, limit: int = 4) -> str:
         """本 send 的上下文被谁占着——`工具名:来源=字符数`，最大的几个。
 
@@ -978,106 +908,65 @@ class AgentPipeline:
         top = sorted(buckets.items(), key=lambda kv: -kv[1])[:limit]
         return " ".join(f"{k}={v // 1000}K" for k, v in top if v >= 1000) or "(无大项)"
 
-    def _distill_oldest_tool_rows(self, batch: int, hot_tail: int) -> int:
-        """把当前 send 里**最早的 batch 条**工具占用在内存里换成指针（6.10.0；6.25.0 起含调用参数）。
+    def _distill_oldest_tool_rows(self, batch: int, hot_tail: int, *, target_tokens: int | None = None) -> int:
+        """Distill complete calls oldest first; ``batch`` is ignored for compatibility.
 
-        「工具占用」有两块：结果在 tool 行、**参数在 assistant 行的 tool_calls 里**。两块按位置
-        统一排队、一起算进 batch，最早的先回收。
-
-        投影行 = 与 end-of-send 投影**同一套** ``ToolDefinition.project`` 蒸馏（找不到钩子就截断），
-        带 ``recall_send(send_index, seq)`` 坐标——原文永远在 pl_messages，要用就回取。不落盘、不改
-        数据库、不改行数（sink 的 index↔seq 对齐不受影响）。最近 ``hot_tail`` 条永不动。verbatim
-        模式不做（那边有就地压缩器）。返回本批释放的估算 token（≈字符/4）。"""
+        Protect invocation IDs, not result rows: parallel results may arrive out of order.
+        Only replace in-memory copies, keeping persisted audit records and seq alignment intact.
+        """
         rep = self.config.representation
-        if getattr(rep, "kind", "projection") == "verbatim":
+        distill = getattr(rep, "distill_tool_call", None)
+        if getattr(rep, "kind", "projection") == "verbatim" or distill is None:
             return 0
-        project_tool = getattr(rep, "_project_tool", None)
         seqs = getattr(self.sink, "_history_seqs", None) or []
-        # 6.27.0 只动**本 send** 追加的行：run 之前就在历史里的（上一个 send 留下的逐字行）归跨 send
-        # 投影管，保险丝碰它们等于两套机制抢同一段历史。
         start = min(int(getattr(self, "_send_start_len", 0) or 0), len(self.history))
-        tool_idx = [
-            i for i, m in enumerate(self.history)
-            if i >= start and m.get("role") == "tool" and isinstance(m.get("content"), str)
-        ]
-        # max(0, …)：本 send 的工具行少于 hot_tail 时，切片起点会是负数，Python 把它当成
-        # 「倒数第 |x| 条」绕回去——5 条工具行配 hot_tail=8 时只保住最后 3 条，最早 2 条
-        # 照样被蒸馏，而那 2 条正是模型手边的东西。本意是「不足 hot_tail 条就全保住」：
-        # 保险丝的前提是有旧结果可回收，没有旧的就什么都不该动，让它涨到切 send 阈值
-        # 优雅收尾即可（断片比切 send 贵得多）。
-        protected = (
-            set(tool_idx[max(0, len(tool_idx) - hot_tail):]) if hot_tail > 0 else set()
-        )
-        # 热尾的起点：它之后的任何一行（工具结果、assistant 的调用参数）都算「手边的东西」。
-        protect_from = min(protected) if protected else len(self.history)
-        result_ok = {
-            i for i in tool_idx
-            if i not in protected
-            and not str(self.history[i].get("content")).startswith(self._DISTILL_MARK)
-            and len(self.history[i].get("content") or "") > 300
-        }
-        # 工具在上下文里占两块：结果在 tool 行，**参数在 assistant 行的 tool_calls 里**。
-        # 参数从来没被保险丝碰过，而实测它占全库上下文的 29%——write_file 一个人 12.6MB，
-        # 单次最大 5.4 万字符：文件已经落盘了，正文却还在 prompt 里一轮轮重发。
-        # 跨 send 的投影早就把两块一起收掉了，缺的只是 send 内这一层。
-        candidates: list[tuple[str, int]] = sorted(
-            [("result", i) for i in result_ok]
-            + [("args", i) for i in range(start, protect_from) if self._has_heavy_args(i)],
-            key=lambda x: x[1],
-        )
-        picked_all = candidates[: max(1, batch)]
-        picked = [i for kind, i in picked_all if kind == "result"]
-        picked_args = [i for kind, i in picked_all if kind == "args"]
-        if not picked_all:
-            return 0
-        # tool_call_id → (name, args) 从前面的 assistant(tool_calls) 行反查。
-        # 只解析**本批选中的**那几个 id：以前是每次触发都把全历史所有 assistant 行的所有
-        # tool_calls 的 arguments 反序列化一遍建全表，只为查其中 batch 条（默认 10）。
-        # 保险丝一旦启动几乎每轮都触发，于是每轮做一次 O(历史) 的 json.loads。
-        wanted = {str(self.history[i].get("tool_call_id") or "") for i in picked}
-        wanted.discard("")
-        call_meta: dict[str, tuple[str, Any]] = {}
-        for m in self.history if wanted else ():
-            if m.get("role") != "assistant":
+        calls = []
+        results = {}
+        for i in range(start, len(self.history)):
+            row = self.history[i]
+            if row.get("role") == "assistant":
+                for j, tc in enumerate(row.get("tool_calls") or []):
+                    if tc.get("id"):
+                        calls.append((str(tc["id"]), i, j))
+            elif row.get("role") == "tool":
+                results[str(row.get("tool_call_id") or "")] = i
+        protected = {cid for cid, _, _ in calls[-hot_tail:]} if hot_tail > 0 else set()
+        keep = set(self.config.insend_distill_keep_tools or ())
+        freed_chars = 0
+        for cid, i, j in calls:
+            if cid in protected or cid not in results:
+                continue
+            ri = results[cid]
+            content = self.history[ri].get("content")
+            tc = self.history[i]["tool_calls"][j]
+            fn = tc.get("function") or {}
+            raw = fn.get("arguments")
+            name = str(fn.get("name") or "tool")
+            if (name in keep or not isinstance(content, str) or not isinstance(raw, str)
+                    or content.startswith(self._DISTILL_MARK)):
+                continue
+            try:
+                args = json.loads(raw)
+                line = distill(name, args, content, getattr(self, "tool_registry", None))
+            except Exception:  # a broken projector must not stop the run or starve later calls
+                logger.warning("in-send distillation failed for %s", name, exc_info=True)
                 continue
-            for tc in m.get("tool_calls") or []:
-                cid = str((tc or {}).get("id") or "")
-                if cid not in wanted or cid in call_meta:
-                    continue
-                fn = (tc or {}).get("function") or {}
-                args = fn.get("arguments")
-                if isinstance(args, str):
-                    try:
-                        args = json.loads(args)
-                    except (TypeError, ValueError):
-                        args = {"raw": args[:200]}
-                call_meta[cid] = (str(fn.get("name") or "tool"), args)
-            if len(call_meta) == len(wanted):
-                break
-        freed = 0
-        for i in picked:
-            m = self.history[i]
-            name, args = call_meta.get(str(m.get("tool_call_id") or ""), ("tool", {}))
-            content = str(m.get("content") or "")
-            if project_tool is not None:
-                try:
-                    d = project_tool(name, args, content, getattr(self, "tool_registry", None))
-                    parts = [f"{k}={v}" for k, v in (d or {}).items() if k != "name" and v not in (None, "")]
-                    line = f"{name}(" + ", ".join(str(x)[:200] for x in parts) + ")"
-                except Exception:  # noqa: BLE001 — 蒸馏钩子出错就退回截断
-                    line = f"{name}: {content[:200]}…"
-            else:
-                line = f"{name}: {content[:200]}…"
             seq = seqs[i] if i < len(seqs) else None
             coord = (f"recall_send(send_index={self.send_index}, seq={seq})"
-                     if (self.send_index is not None and seq is not None) else "recall_send")
-            new_content = (f"{self._DISTILL_MARK}{self.send_index} seq={seq} — 原文已从上下文移出，"
-                           f"需要时 {coord} 回取] {line}")
-            freed += max(0, (len(content) - len(new_content)) // 4)
-            m["content"] = new_content
-        for i in picked_args:
-            freed += self._distill_tool_call_args(i, seqs)
-        return freed
+                     if self.send_index is not None and seq is not None else "recall_send")
+            new_content = f"{self._DISTILL_MARK}{self.send_index} seq={seq}; {coord}] {line}"
+            new_raw = json.dumps({"_distilled": coord}, ensure_ascii=False)
+            saved = len(raw) + len(content) - len(new_raw) - len(new_content)
+            if saved <= 0:
+                continue
+            new_calls = list(self.history[i]["tool_calls"])
+            new_calls[j] = {**tc, "function": {**fn, "arguments": new_raw}}
+            self.history[i] = {**self.history[i], "tool_calls": new_calls}
+            self.history[ri] = {**self.history[ri], "content": new_content}
+            freed_chars += saved
+            if target_tokens is not None and freed_chars // 4 >= target_tokens:
+                break
+        return freed_chars // 4
 
     def _estimate_history_tokens(self) -> int:
         """Current history token estimate, maintained incrementally (SCALE-4).
@@ -1131,42 +1020,22 @@ class AgentPipeline:
         if irr is not None and int(irr) > 0 and self._retire_stale_images(round_index, int(irr)):
             self._tok_len = -1
 
-        # ── 6.10.0 send 内保险丝：最早的 n 条工具结果 → 投影行（内存替换，pl_messages 不动）──
-        # 触发依据 = 上一轮供应商返回的真实 prompt_tokens（就是当前上下文的真实大小；第一轮
-        # 还没有就用估算）。每轮最多蒸馏一批（最早的 n 条、跳过已蒸馏的、不动最近 hot_tail 条）；
-        # 下一轮真实 prompt 仍超阈值就再蒸馏下一批——逐轮递进，只蒸馏到够用为止。
+        # Fuse uses total prompt size, including the fixed prompt and history prefix.
         dt = self.config.insend_distill_tokens
         if dt is not None and int(dt) > 0 and round_index > 0:
-            # 6.27.0：量的是**本 send 内的增长**，不是整个上下文。系统提示词 + 技能 + 工具目录 + 历史
-            # 一开局就可能有几万 token，按整体判的话第一轮就超阈值、之后每轮都烧（真实事故：一个
-            # 会话 44 次触发，模型自己的发言参数被瘦成占位符，再被照样发进聊天）。保险丝的本意是
-            # 「这一个 send 跑得太长」才出手：第一轮的真实 prompt_tokens 是基线，之后每轮减它。
             real = int((self.ctx.token_usage or {}).get("prompt_tokens", 0) or 0)
-            if real > 0:
-                if self._send_baseline_prompt is None:
-                    self._send_baseline_prompt = real
-                growth = real - int(self._send_baseline_prompt)
-            else:
-                start = min(int(getattr(self, "_send_start_len", 0) or 0), len(self.history))
-                growth = estimate_tokens(self.history[start:])
-            if growth >= int(dt):
+            if real and self._send_baseline_prompt is None:
+                self._send_baseline_prompt = real  # diagnostics only; never subtracted from trigger
+            total = real or self._estimate_history_tokens()
+            if total >= int(dt):
                 freed = self._distill_oldest_tool_rows(
-                    int(self.config.insend_distill_batch or 10),
-                    int(self.config.insend_distill_hot_tail or 0),
+                    0, int(self.config.insend_distill_hot_tail or 0),
+                    target_tokens=max(1, total - int(dt) + 1),
                 )
                 if freed:
-                    self._tok_len = -1  # content shrank in place; force a fresh estimate
-                start_i = min(int(getattr(self, "_send_start_len", 0) or 0), len(self.history))
-                # freed==0 也要记：那是「保险丝烧完了、再触发也没用」的静默状态，
-                # 而它的表现和「一切正常」一模一样——上下文继续涨，日志里一个字都没有。
-                logger.info(
-                    "insend distill: send grew %d >= %d tokens; freed ~%d this round "
-                    "(send %s, round %d, prompt %d, rows %d) | 大头: %s%s",
-                    growth, int(dt), freed, self.send_index, round_index, real,
-                    len(self.history) - start_i, self._context_profile(start_i),
-                    "" if freed else "  ← 没有可回收的了：剩下的要么在热尾、要么已蒸馏、要么是"
-                                     "模型自己的正文（保险丝只动工具结果与调用参数）",
-                )
+                    self._tok_len = -1
+                logger.info("insend distill: total prompt %d >= %d; freed ~%d tokens",
+                            total, int(dt), freed)
         if self.config.microcompact_enabled:
             self.ctx.microcompact(
                 self.history,
@@ -1665,6 +1534,7 @@ class AgentPipeline:
             ckpt = self.config.context_checkpoint_tokens
             if (
                 ckpt is not None
+                and (self.config.insend_distill_tokens or 0) <= 0
                 and int(ckpt) > 0
                 and round_idx > 0
                 and not self._terminal_grace_active

{power_loop-6.46.4 → power_loop-6.47.0}/power_loop/runtime/representation.py

@@ -420,6 +420,13 @@ class ProjectedRepresentation:
             source_seq_hi=max(seqs) if seqs else None,
         )
 
+    def distill_tool_call(
+        self, name: str, args: Any, result: Any, tool_registry: ToolRegistry | None
+    ) -> str:
+        """Public single-call projection seam shared with the in-send context fuse."""
+        entry = self._project_tool(name, args, result, tool_registry)
+        return json.dumps(entry, ensure_ascii=False, default=str)
+
     def _project_tool(
         self, name: str | None, args: Any, result: Any, tool_registry: ToolRegistry | None
     ) -> dict[str, Any]:

{power_loop-6.46.4 → power_loop-6.47.0}/power_loop/workflow/engine.py

@@ -386,8 +386,14 @@ class WorkflowEngine:
         # journaling (those leaves share one id and aren't individually
         # replayable). The foreach's aggregate is journaled instead.
         self._emit_suppressed = 0
+        self._frames: dict[int, dict[str, Any]] = {}
+        self._repairs: dict[int, asyncio.Task[Any]] = {}
+        self._resume_instructions: dict[str, tuple[str, int]] = {}
+        self._replay_no_charge: set[str] = set()
+        self._steering: dict[str, list[asyncio.Task[Any]]] = {}
 
     async def run(self, spec: WorkflowSpec) -> WorkflowResult:
+        self._spec = spec
         if self._budget is None and spec.budget is not None:
             self._budget = SharedBudget(
                 spec.budget.max_tokens, stop_at_remaining_pct=spec.budget.stop_at_remaining_pct
@@ -477,7 +483,113 @@ class WorkflowEngine:
 
     # ── node dispatch ──────────────────────────────────────────────────────
 
+    @staticmethod
+    def _children(node: WorkflowNode) -> list[WorkflowNode]:
+        if isinstance(node, SequenceNode):
+            return list(node.steps)
+        if isinstance(node, ParallelNode):
+            return list(node.branches)
+        if isinstance(node, (LoopNode, ForeachNode)):
+            return [node.body]
+        if isinstance(node, BranchNode):
+            return list(node.cases.values()) + ([node.default] if node.default else [])
+        return []
+
+    async def steer_node(self, node_id: str, sid: str, message: str):
+        """Accept steering only while this engine owns execution, never launch an idle send."""
+        import uuid
+        pending = self._steering.get(node_id)
+        if pending is None:
+            raise WorkflowRunError("node is settling; retry nudge after its journal step settles")
+        task = asyncio.create_task(self._loop.follow_up(
+            message, session_id=sid, mode="steer", enqueue_only=True,
+            item_id=f"workflow-steer-{uuid.uuid4().hex}"))
+        pending.append(task)  # registered before any await; the leaf joins delivery before settling
+        return await asyncio.shield(task)
+
+    async def continue_node(self, node_id: str, message: str, rounds: int) -> AgentResult | None:
+        """Recover a settled branch while siblings run, using the original leaf session.
+
+        Active dependent scopes are rejected before executing anything. Foreach IDs are
+        ambiguous and require iteration-aware orchestration instead of guessing a session.
+        """
+        def path_to(node):
+            if isinstance(node, AgentNode) and node.id == node_id:
+                return [node]
+            for child in self._children(node):
+                path = path_to(child)
+                if path:
+                    return [node, *path]
+            return None
+
+        path = path_to(self._spec.root)
+        if not path or any(isinstance(n, ForeachNode) for n in path):
+            raise WorkflowRunError("node is missing or requires an explicit foreach iteration")
+        leaf = path[-1]
+        frame = self._frames.get(id(leaf))
+        if not frame or frame["active"]:
+            raise WorkflowRunError("node is active or has not settled; deliver a steering message to its sid")
+        scope = leaf
+        for parent in reversed(path[:-1]):
+            pf = self._frames.get(id(parent))
+            if not pf or pf["active"]:
+                if not isinstance(parent, ParallelNode):
+                    raise WorkflowRunError("dependent scope is still active; wait for its current step to settle")
+                break
+            scope = parent
+        key = id(scope)
+        if key in self._repairs:
+            raise WorkflowRunError("this branch already has a continuation in progress")
+        prior = self._results.get(node_id)
+        if prior is None or not prior.session_id:
+            raise WorkflowRunError("node has no resumable session")
+        sf = self._frames[key]
+
+        async def repair():
+            from .resume import continuation_replay
+            repaired_spec = replace(self._spec, root=scope)
+            for key in _agent_ids(scope):
+                self._replay.pop(key, None)
+            invalidated: set[str] = set()
+            replay = continuation_replay(repaired_spec, node_id, dict(self._results), invalidated=invalidated)
+            self._replay.update(replay)
+            self._replay_no_charge.update(replay)
+            for invalid_id in invalidated:
+                self._replay.pop(invalid_id, None)
+                old = self._results.pop(invalid_id, None)
+                await self._emit_step(AgentResult(
+                    node_id=invalid_id, status="pending", text="",
+                    session_id=old.session_id if old else None,
+                    error="invalidated by node continuation"))
+            self._resume_sessions[node_id] = prior.session_id
+            self._resume_instructions[node_id] = (message, rounds)
+            guard = _IN_WORKFLOW.set(True)
+            try:
+                return await self._exec(scope, sf["env"], sf["driver"])
+            finally:
+                _IN_WORKFLOW.reset(guard)
+
+        task = asyncio.create_task(repair(), name=f"workflow-continue-{node_id}")
+        self._repairs[key] = task
+        try:
+            return await asyncio.shield(task)
+        finally:
+            # Keep the task registered until completed, even if the caller disconnects.
+            if task.done():
+                self._repairs.pop(key, None)
+
     async def _exec(self, node: WorkflowNode, env: dict[str, Any], driver_sid: str) -> AgentResult | None:
+        if ITERATION_ENV_KEY in env:
+            return await self._exec_dispatch(node, env, driver_sid)
+        frame = {"active": True, "env": dict(env), "driver": driver_sid, "result": None}
+        self._frames[id(node)] = frame
+        try:
+            frame["result"] = await self._exec_dispatch(node, env, driver_sid)
+            return frame["result"]
+        finally:
+            frame["active"] = False
+
+    async def _exec_dispatch(self, node: WorkflowNode, env: dict[str, Any], driver_sid: str) -> AgentResult | None:
         if isinstance(node, AgentNode):
             return await self._exec_agent(node, env, driver_sid)
         if isinstance(node, SequenceNode):
@@ -502,7 +614,9 @@ class WorkflowEngine:
                                                  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)
+            if node.id not in self._replay_no_charge:
+                self._add_usage(replayed.usage)
+            self._replay_no_charge.discard(node.id)
             return replayed
         body_ids = _agent_ids(node.body)
         feedback_node = str(node.until.get("ref") or "").split(".", 1)[0]
@@ -557,7 +671,9 @@ class WorkflowEngine:
         if replayed is not None:
             self._results[node.id] = replayed
             self._last = replayed
-            self._add_usage(replayed.usage)
+            if node.id not in self._replay_no_charge:
+                self._add_usage(replayed.usage)
+            self._replay_no_charge.discard(node.id)
             return replayed
 
         if self._cancel.is_cancelled():
@@ -663,6 +779,7 @@ class WorkflowEngine:
             except Exception:  # noqa: BLE001 — observability must not fail the run
                 pass
 
+        self._steering[node.id] = []
         node_tok = self._cancel.child()
         self._node_tokens.setdefault(node.id, []).append(node_tok)
         # 重启后接着跑（6.46）：这个节点上次有叶子会话、没做完 → 先在原会话补轮；补不了再照常开新会话。
@@ -670,8 +787,10 @@ class WorkflowEngine:
         rs = self._resume_sessions.pop(node.id, None) if not self._emit_suppressed else None
         if rs:
             try:
+                prompt, rounds = self._resume_instructions.pop(
+                    node.id, (_RESUME_PROMPT, max(int(node.spec.max_rounds or 30), 10)))
                 resumed_raw = await self._continue_leaf(
-                    rs, _RESUME_PROMPT, extra_rounds=max(int(node.spec.max_rounds or 30), 10), stop=node_tok)
+                    rs, prompt, extra_rounds=rounds, 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 — 会话丢了就照常重跑
@@ -781,6 +900,22 @@ class WorkflowEngine:
                 raw = {**raw, "error": raw.get("error") or f"节点被单独取消：{node_tok.reason}"}
             else:
                 self._cancelled = True
+        # Close intake, then join every accepted delivery. Any input arriving after the
+        # final round drain is flushed before schema validation, journaling or review.
+        accepted_steering = self._steering.pop(node.id, [])
+        if accepted_steering:
+            await asyncio.gather(*accepted_steering)
+            sid = raw.get("session_id")
+            pending = await self._loop.inbox_pending(sid) if sid else {}
+            if pending.get("pending", 0):
+                more = await self._continue_leaf(
+                    str(sid), "继续处理收件箱中的补充要求，完成后按原任务格式交付。",
+                    extra_rounds=max(int(node.spec.max_rounds or 30), 10), stop=node_tok)
+                combined_usage = dict(raw.get("usage") or {})
+                for key, value in (more.get("usage") or {}).items():
+                    combined_usage[key] = combined_usage.get(key, 0) + value
+                raw = {**more, "session_id": sid, "usage": combined_usage}
+
         payload: dict[str, Any] | None = None
         err: str | None = None
         if node.output_schema is not None and raw.get("status") == "completed":
@@ -1018,6 +1153,15 @@ class WorkflowEngine:
         gathered = await self._gather_branches(
             [one(b) for b in node.branches], on_error=node.on_error
         )
+        # A closed branch may have been repaired while siblings were executing.
+        # Join accepted repairs before releasing dependent sequence/assembly steps.
+        for branch in node.branches:
+            task = self._repairs.get(id(branch))
+            if task is not None:
+                await asyncio.shield(task)
+        gathered = [self._frames.get(id(b), {}).get("result", r)
+                    if not isinstance(r, BaseException) and ITERATION_ENV_KEY not in env else r
+                    for b, r in zip(node.branches, gathered, strict=True)]
         for r in gathered:
             if isinstance(r, BaseException):
                 self._errors.append(f"parallel branch error: {r}")

{power_loop-6.46.4 → power_loop-6.47.0}/power_loop/workflow/resume.py

@@ -260,6 +260,60 @@ async def resume_run(
     return result
 
 
+def continuation_replay(spec: WorkflowSpec, node_id: str, results: dict[str, AgentResult],
+                        *, invalidated: set[str] | None = None) -> dict[str, AgentResult]:
+    """Invalidate the target, its downstream sequence, and enclosing aggregates.
+
+    Parallel siblings retain their completed results. Foreach body IDs cannot identify
+    an iteration and are rejected. Old reviews downstream of changed work never replay.
+    """
+    invalid: set[str] = set()
+    found = False
+
+    def all_ids(node):
+        own = {node.id} if getattr(node, "id", None) else set()
+        for c in WorkflowEngine._children(node):
+            own.update(all_ids(c))
+        return own
+
+    def visit(node, in_foreach=False):
+        nonlocal found
+        if isinstance(node, AgentNode):
+            if node.id == node_id:
+                if in_foreach:
+                    raise WorkflowRunError("foreach continuation needs an iteration-specific target")
+                found = True
+                invalid.add(node.id)
+                return True
+            return False
+        affected = False
+        for child in WorkflowEngine._children(node):
+            if affected and isinstance(node, SequenceNode):
+                invalid.update(all_ids(child))
+            affected = visit(child, in_foreach or isinstance(node, ForeachNode)) or affected
+        if affected and getattr(node, "id", None):
+            invalid.add(node.id)
+        return affected
+
+    visit(spec.root)
+    if not found:
+        raise WorkflowRunError(f"unknown continuation node {node_id}")
+    if invalidated is not None:
+        invalidated.update(invalid)
+    scope_ids = all_ids(spec.root)
+    replay = {k: v for k, v in results.items()
+              if k in scope_ids and k not in invalid and v.status not in ("pending", "running")}
+    def prune(node):
+        if isinstance(node, (LoopNode, ForeachNode)) and node.id in replay:
+            for key in all_ids(node.body):
+                replay.pop(key, None)
+        else:
+            for c in WorkflowEngine._children(node):
+                prune(c)
+    prune(spec.root)
+    return replay
+
+
 async def resume_detached(
     loop: Any,
     parent_sid: str,
@@ -271,6 +325,7 @@ async def resume_detached(
     force: bool = False,
     on_complete: OnComplete | None = None,
     file_io: Any | None = None,
+    continuation: tuple[str, str, int] | None = None,
 ) -> WorkflowRunHandle:
     """Resume a run on a background task; wake the parent on completion.
 
@@ -285,25 +340,48 @@ async def resume_detached(
     if await store.get_session(parent_sid) is None:
         raise WorkflowRunError("parent session not found; cannot resume detached run")
     spec, replay, j = await rehydrate(store, parent_sid, run_id)
+    invalidated: set[str] = set()
+    if continuation is not None:
+        nid, message, rounds = continuation
+        all_results = {str(st["node_id"]): AgentResult(
+            node_id=str(st["node_id"]), status=str(st.get("status") or "failed"),
+            text=st.get("text") or "", payload=st.get("payload"), usage=st.get("usage") or {},
+            session_id=st.get("session_id"),
+        ) for st in j.get("steps", [])}
+        replay = continuation_replay(spec, nid, all_results, invalidated=invalidated)
+        if not (j.get("live_sessions") or {}).get(nid):
+            raise WorkflowRunError("continuation node has no recorded session")
     _guard_resumable(run_id, force)
-    await _mark_resuming(store, parent_sid, run_id, j)
-    cancel_token = CancellationToken()
-
-    def _build_engine() -> WorkflowEngine:
-        return WorkflowEngine(
-            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,
+    _LIVE_RUN_IDS.add(run_id)  # reserve before the first journal-write await
+    try:
+        await _mark_resuming(store, parent_sid, run_id, j)
+        for invalid_id in invalidated:
+            await journal.record_step(store, parent_sid, run_id, node_id=invalid_id,
+                                      status="pending", error="invalidated by node continuation",
+                                      session_id=(j.get("live_sessions") or {}).get(invalid_id))
+        cancel_token = CancellationToken()
+
+        def _build_engine() -> WorkflowEngine:
+            engine = WorkflowEngine(
+                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,
+            )
+            if continuation is not None:
+                engine._resume_instructions[continuation[0]] = (continuation[1], continuation[2])
+            return engine
+
+        return spawn_background(
+            loop, parent_sid, run_id, store=store,
+            build_engine=_build_engine, run_spec=spec,
+            cancel_token=cancel_token, eager_wake=eager_wake, task_set=_RESUME_TASKS,
+            on_complete=on_complete,
         )
-
-    return spawn_background(
-        loop, parent_sid, run_id, store=store,
-        build_engine=_build_engine, run_spec=spec,
-        cancel_token=cancel_token, eager_wake=eager_wake, task_set=_RESUME_TASKS,
-        on_complete=on_complete,
-    )
+    except BaseException:
+        _LIVE_RUN_IDS.discard(run_id)
+        raise

{power_loop-6.46.4 → power_loop-6.47.0}/power_loop/workflow/runner.py

@@ -145,6 +145,21 @@ def make_on_node_session(store: Any, parent_sid: str, run_id: str):
 _ENGINES: dict[str, Any] = {}
 
 
+async def steer_node(run_id: str, node_id: str, sid: str, message: str):
+    engine = _ENGINES.get(run_id)
+    if engine is None:
+        raise RuntimeError("run is settling; retry nudge to resume the persisted workflow")
+    return await engine.steer_node(node_id, sid, message)
+
+
+async def continue_node(run_id: str, node_id: str, message: str, rounds: int = 8):
+    """Continue one settled branch in its live engine; active leaves use follow_up."""
+    engine = _ENGINES.get(run_id)
+    if engine is None:
+        raise RuntimeError("run has no live engine; resume its persisted journal first")
+    return await engine.continue_node(node_id, message, rounds)
+
+
 def cancel_node(run_id: str, node_id: str, reason: str = "cancelled by host") -> int | None:
     """只取消某个 run 里的一个节点（6.46）。返回停了几个在跑的叶子；None = 这个 run 不在本进程跑。"""
     eng = _ENGINES.get(run_id)

{power_loop-6.46.4 → power_loop-6.47.0}/power_loop.egg-info/PKG-INFO

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