power-loop 3.0.0__tar.gz → 3.0.1__tar.gz

{power_loop-3.0.0 → power_loop-3.0.1}/PKG-INFO

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

{power_loop-3.0.0 → power_loop-3.0.1}/power_loop/__init__.py

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

@@ -774,6 +774,11 @@ class StatefulAgentLoop:
         sink = SQLiteSink(store, session_id)
         sink._unresolved = {str(tc.get("id") or "") for tc in tool_calls}
         sink._assistant_seq = pending.get("assistant_seq")
+        # Prime _tool_calls so a crash mid-abort (after some but not all <aborted> rows land)
+        # persists a CONSISTENT intermediate pending — on_message_appended rebuilds the still-pending
+        # tool_calls from self._tool_calls (sink.py:171-174); left empty it would write
+        # {tool_call_ids:[…], tool_calls:[]}, a self-inconsistent pending.
+        sink._tool_calls = list(tool_calls)
         for tc in tool_calls:
             cid = str(tc.get("id") or "")
             name = _tool_call_name(tc) if "function" in tc or "name" in tc else None
@@ -1056,7 +1061,13 @@ class StatefulAgentLoop:
         if pending.get("pending_interactions"):
             return
         round_index = int(pending.get("round_index") or 0)
-        tool_calls = pending.get("tool_calls") or []
+        # Fall back to tool_call_ids (as abort_pending / _prime_sink_from_pending do): a pending that
+        # carries only ids (e.g. a crash mid-abort left {tool_call_ids:[…], tool_calls:[]}) must
+        # still be resolved here, else resume() returns "completed" while the pending stays set and
+        # the session is permanently stranded.
+        tool_calls = pending.get("tool_calls") or [
+            {"id": cid} for cid in (pending.get("tool_call_ids") or [])
+        ]
         if not tool_calls:
             return
         # Initialize sink's in-memory unresolved set so auto-resolve works.
@@ -1064,6 +1075,19 @@ class StatefulAgentLoop:
         for tc in tool_calls:
             cid = str(tc.get("id") or "")
             name = _tool_call_name(tc)
+            if name is None:
+                # Reconstructed from ids only — no name/args to replay. Resolve the protocol with an
+                # aborted marker (clears unresolved → pending cleared) instead of stranding.
+                await sink.on_message_appended(
+                    {
+                        "role": "tool",
+                        "tool_call_id": cid,
+                        "name": None,
+                        "content": "<aborted: unrecoverable tool_call on resume>",
+                    },
+                    round_index=round_index,
+                )
+                continue
             args = _tool_call_args(tc)
             if self.tool_registry is None:
                 output, failed = (
@@ -1511,19 +1535,26 @@ class StatefulAgentLoop:
                     llm=self.llm, max_tokens=self.config.max_tokens,
                 ),
             )
+        fold_as_project: list[int] = []
         if folded is not None:
             from_send = 0 if note is not None else (min(fold) if fold else 0)
             compact_tuple = (folded.content, folded.rendered_text, from_send, folded.folded_to_send)
             migration_note_ops = list(folded.note_ops)
-        elif note is not None:
-            # Only the note, nothing foldable beyond keep → preserve the note as a standalone
-            # compact sitting just before the kept tail (or the current send).
-            to_send = (min(recent) - 1) if recent else (current_send_index - 1)
-            compact_tuple = ({"summary": note.content or ""}, None, 0, max(0, to_send))
+        else:
+            # The fold soft-failed (LLM error/timeout/empty) OR nothing was foldable. Do NOT write a
+            # compact that claims to COVER sends it never merged — the reader uses compact_to_send as
+            # the exclusion cutoff, so an over-claiming range silently drops real history (B4), and a
+            # marker-set no-op drops compression forever (B13). Instead preserve everything: keep the
+            # note as a standalone compact that covers NO real send (to_send=0), and write the
+            # would-be-folded sends as individual project rows. A later end-of-send fold compresses
+            # them (rolling this note compact forward) once over budget.
+            if note is not None:
+                compact_tuple = ({"summary": note.content or ""}, None, 0, 0)
+            fold_as_project = fold
 
         project_rows = [
             (si, pr.kind, pr.content, pr.rendered_text)
-            for si in recent
+            for si in (fold_as_project + recent)
             for pr in projected[si].rows
         ]
         # Mark migrated in the SAME transaction as the rows (atomic): a crash can't leave the

{power_loop-3.0.0 → power_loop-3.0.1}/power_loop/agent/types.py

@@ -35,7 +35,11 @@ def _fold_from_legacy_projector(proj: Any) -> FoldStrategy:
     admin-configured projection settings). Without this the mapped fold would silently use
     ``LLMSummaryFold`` defaults (4 / 0.75) and ignore the operator's config."""
     from power_loop.runtime.fold import LLMSummaryFold
-    keep = max(1, int(getattr(proj, "keep_last_sends", 4) or 4))
+    # Only a MISSING/None keep falls back to 4; an explicit 0 means "keep ~none" (fold aggressively)
+    # → clamp to the validator's floor of 1, NOT silently to 4 (B10). (A verbatim keep==0 projector is
+    # routed to never-fold in _map_legacy_axes and never reaches here.)
+    keep_raw = getattr(proj, "keep_last_sends", None)
+    keep = 4 if keep_raw is None else max(1, int(keep_raw))
     trigger = float(getattr(proj, "trigger_ratio", 0.75) or 0.75)
     return LLMSummaryFold(keep_last_sends=keep, trigger_ratio=trigger)
 
@@ -172,6 +176,17 @@ class AgentLoopConfig:
         # stray legacy compactor= must NOT silently disable it.
         if legacy_comp is not _UNSET and legacy_proj in (_UNSET, None) and fold_was_unset:
             object.__setattr__(self, "_legacy_verbatim_compactor", legacy_comp)
+        elif (
+            legacy_proj not in (_UNSET, None)
+            and fold_was_unset
+            and getattr(legacy_proj, "kind", None) == "verbatim"
+            and getattr(legacy_proj, "keep_last_sends", 1) == 0  # exact 0 (NOT `or 1`, which 0 defeats)
+        ):
+            # A legacy NEVER-FOLD projector (IdentityProjector: kind='verbatim', keep_last_sends==0)
+            # maps to never-fold (compactor=None) — NOT a folding fold_strategy. Else it would fold
+            # (the seeder coerces keep 0→positive) and, on the old projection path, drop the compact
+            # (B7 data loss). Routes via resolve_compactor's verbatim branch (kind=='verbatim').
+            object.__setattr__(self, "_legacy_verbatim_compactor", None)
         else:
             object.__setattr__(self, "_legacy_verbatim_compactor", _UNSET)
         if self.migrate_history_on_projection_switch is not _UNSET:

{power_loop-3.0.0 → power_loop-3.0.1}/power_loop/runtime/history_projector.py

@@ -173,6 +173,7 @@ class IdentityProjector:
     with this projector sees byte-identical history to the no-projector default. Useful to
     prove the projection seam itself introduces no behavior change."""
 
+    kind: str = "verbatim"  # routes to the safe in-place (verbatim) path, never the projection fold
     version: int = 1
     keep_last_sends: int = 0  # verbatim mode never folds
     trigger_ratio: float = 0.75  # unused (keep_last_sends==0 short-circuits folding); for Protocol parity
@@ -197,6 +198,14 @@ class IdentityProjector:
     def render(self, rows: list[ProjectMessageRow]) -> list[LoopMessage]:
         out: list[LoopMessage] = []
         for r in rows:
+            # Defensive: even though this projector never folds, a compact row could reach render
+            # via a mode switch / legacy mapping — render its summary instead of silently dropping it
+            # (the 3.0 invariant: every representation's render MUST handle kind=='compact').
+            if getattr(r, "kind", None) == "compact":
+                summary = (r.content or {}).get("summary")
+                if summary:
+                    out.append({"role": "user", "content": str(summary)})
+                continue
             out.extend((r.content or {}).get("messages") or [])
         return out
 

{power_loop-3.0.0 → power_loop-3.0.1}/power_loop/runtime/representation.py

@@ -260,15 +260,32 @@ class ProjectedRepresentation:
 
     # rendering ----------------------------------------------------------------
     def render(self, rows: list[ProjectMessageRow]) -> list[LoopMessage]:
+        # Each rendered send is tagged with its ``#N`` send_index so the model can call
+        # recall_send(send_index=N) on a folded/compacted earlier turn — the tool docstring and the
+        # host's RECALL_SEND_NOTE both tell it to use "the #N the summary shows", so render MUST
+        # actually emit them (else recall_send is undiscoverable). The folded compact carries its
+        # covered range.
         out: list[LoopMessage] = []
         for r in rows:
+            si = r.send_index
             if r.kind == "user":
                 humans = (r.content or {}).get("human") or []
-                out.append({"role": "user", "content": "\n".join(str(h) for h in humans)})
+                tag = f"[#{si}] " if si is not None else ""
+                out.append({"role": "user", "content": tag + "\n".join(str(h) for h in humans)})
             elif r.kind == "project":
-                out.append({"role": "assistant", "content": self._render_project(r.content)})
+                tag = f"#{si} " if si is not None else ""
+                out.append({"role": "assistant", "content": tag + self._render_project(r.content)})
             elif r.kind == "compact":
-                out.append(_render_compact_row(r))
+                msg = _render_compact_row(r)
+                lo, hi = r.compact_from_send, r.compact_to_send
+                if lo is not None and hi is not None and hi >= lo > 0:
+                    rng = f"#{lo}" if lo == hi else f"#{lo}–#{hi}"
+                    msg = {
+                        "role": "user",
+                        "content": f"[older sends {rng} folded — recall_send(send_index=N) to "
+                        f"expand]\n{msg['content']}",
+                    }
+                out.append(msg)
         return out
 
     def _render_tool(self, t: dict[str, Any]) -> str:

{power_loop-3.0.0 → power_loop-3.0.1}/power_loop/runtime/store/dialect.py

@@ -356,7 +356,7 @@ class MySQLDialect:
                 status VARCHAR(32) NOT NULL, return_code BIGINT, output_tail TEXT, output_path TEXT,
                 last_seen_at BIGINT NOT NULL DEFAULT 0, created_at BIGINT NOT NULL,
                 updated_at BIGINT NOT NULL, PRIMARY KEY (session_id, task_id),
-                KEY {p}idx_bgtasks_session_status (session_id, status, updated_at)) {opts}""",
+                KEY {p}idx_background_tasks_session_status (session_id, status, updated_at)) {opts}""",
             f"""CREATE TABLE IF NOT EXISTS {p}session_stats (
                 session_id VARCHAR(255) NOT NULL, sends BIGINT NOT NULL DEFAULT 0,
                 rounds BIGINT NOT NULL DEFAULT 0, llm_calls BIGINT NOT NULL DEFAULT 0,

{power_loop-3.0.0 → power_loop-3.0.1}/power_loop/runtime/store/schema.py

@@ -243,7 +243,16 @@ async def _column_exists(tx: Transaction, dialect_name: str, table: str, column:
         rows = await tx.fetchall(f"PRAGMA table_info({table})")
         return any(r["name"] == column for r in rows)
     if dialect_name in ("postgres", "mysql"):
-        scope = "AND table_schema=DATABASE() " if dialect_name == "mysql" else ""
+        # Scope to the CURRENT schema — otherwise a same-named table in ANOTHER schema (PG
+        # search_path / multi-schema deployments) makes the probe return True for a column the
+        # current-schema table lacks, so the ALTER … ADD COLUMN is skipped but the version is still
+        # stamped → every subsequent append referencing that column crashes. Mirrors _table_exists
+        # (PG to_regclass honors search_path; MySQL DATABASE()).
+        scope = (
+            "AND table_schema=current_schema() "
+            if dialect_name == "postgres"
+            else "AND table_schema=DATABASE() "
+        )
         row = await tx.fetchone(
             "SELECT 1 AS present FROM information_schema.columns "
             f"WHERE table_name=? {scope}AND column_name=?",

{power_loop-3.0.0 → power_loop-3.0.1}/power_loop/tools/default_tools.py

@@ -310,7 +310,14 @@ def _validate_bash_command_scope(command: str) -> str | None:
             "Error: Reading agent-home internals is blocked outside allowlisted paths (.cache/logs/skills). "
             "Use load_skill(name) for skill content instead of direct file reads."
         )
-    return None
+    # DEFAULT-DENY: the command references POWER_LOOP_HOME, is NOT under an allowlisted path, and
+    # matched none of the verb hints above — but the hint lists are not exhaustive (awk / base64 / od
+    # / python -c / dd of= / truncate / ln -s all reach agent-home undetected). Refuse rather than
+    # fall through to "allow", since the resolved target is provably an un-allowlisted home path.
+    return (
+        "Error: Accessing POWER_LOOP_HOME is blocked outside allowlisted paths (.cache/logs/skills). "
+        "Use workspace files or allowlisted agent paths only."
+    )
 
 
 def _dangerous_command_reason(command: str) -> str | None:

{power_loop-3.0.0 → power_loop-3.0.1}/power_loop/workflow/runner.py

@@ -249,18 +249,33 @@ def make_wake_guard(store: Any):
     once (timers are at-least-once). Ignores non-workflow timers. Async because the
     store is async; ``run_typed_async`` awaits it."""
 
+    from power_loop.runtime.store.store import MUTATE_SKIP
+
     async def guard(ctx: TimerFireCtx) -> None:
         run_id = _parse_run_id(ctx.note)
         if run_id is None:
             return  # not a workflow timer → CONTINUE
-        j = await store.get_runtime_state(ctx.session_id, journal.run_key(run_id), default=None)
-        if j is None:
-            return
-        if j.get("woke"):
-            ctx.directive = HookDirective.SKIP  # already delivered once
-            return
-        j["woke"] = True
-        await store.set_runtime_state(ctx.session_id, journal.run_key(run_id), j)
+        # Claim the wake ATOMICALLY: a bare get→set RMW races a concurrent journal write
+        # (journal.update / record_step funnel through mutate_runtime_state on the SAME run key) —
+        # the guard's set would clobber that write, and two concurrent fires could both observe
+        # woke=False → double-wake. mutate_runtime_state is row-locked, so the claim is exclusive.
+        seen = {"woke": False}
+
+        def _claim(cur: Any) -> Any:
+            if cur is None:
+                return MUTATE_SKIP  # no journal → CONTINUE (nothing to dedupe)
+            if cur.get("woke"):
+                seen["woke"] = True
+                return MUTATE_SKIP  # already delivered once
+            return {**cur, "woke": True}  # first delivery — set woke, preserve every other key
+
+        try:
+            await store.mutate_runtime_state(ctx.session_id, journal.run_key(run_id), _claim, default=None)
+        except ValueError:
+            return  # session/state row gone (a stale timer firing on a deleted session) → CONTINUE,
+            # matching the old get_runtime_state(default=None) tolerance; nothing to dedupe.
+        if seen["woke"]:
+            ctx.directive = HookDirective.SKIP
 
     return guard
 

{power_loop-3.0.0 → power_loop-3.0.1}/power_loop.egg-info/PKG-INFO

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