power-loop 3.4.0__tar.gz → 3.6.0__tar.gz

{power_loop-3.4.0 → power_loop-3.6.0}/PKG-INFO

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

{power_loop-3.4.0 → power_loop-3.6.0}/power_loop/__init__.py

@@ -15,7 +15,7 @@ Stability tiers
 无版本承诺，可随时变更或删除。
 """
 
-__version__ = "3.4.0"
+__version__ = "3.6.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-3.4.0 → power_loop-3.6.0}/power_loop/_vendor/llm_client/llm_factory.py

@@ -624,7 +624,7 @@ class OpenAICompatibleChatLLMService(LLMService):
             if not isinstance(items, list):
                 items = [items]
 
-            for pos, it in enumerate(items):
+            for it in items:
                 d = _as_dict(it)
                 if not isinstance(d, dict):
                     continue
@@ -641,8 +641,18 @@ class OpenAICompatibleChatLLMService(LLMService):
                 elif delta_index is not None:
                     call_key = f"index_{delta_index}"
                 else:
-                    # fall back to position inside this delta event
-                    call_key = f"event_pos_{pos}"
+                    # Ambiguous: neither id nor index (non-standard provider). Keying purely by this
+                    # event's position collided sequential DISTINCT calls (both arriving at pos 0 in
+                    # separate events) into one entry, merging their arguments (llm-transport-5).
+                    # OpenAI-style streaming starts a call with a function NAME and continues it with
+                    # arguments-only deltas: a name-bearing (or first-ever) ambiguous delta opens a
+                    # NEW slot; an arguments-only one continues the most-recent call.
+                    fn_obj = d.get("function")
+                    fn_obj = fn_obj if isinstance(fn_obj, dict) else (_as_dict(fn_obj) or {})
+                    if fn_obj.get("name") or not tool_call_order:
+                        call_key = f"ambiguous_{len(tool_call_order)}"
+                    else:
+                        call_key = tool_call_order[-1]
 
                 if call_key not in tool_call_store:
                     tool_call_store[call_key] = {

{power_loop-3.4.0 → power_loop-3.6.0}/power_loop/agent/sink.py

@@ -26,8 +26,13 @@ logger = logging.getLogger(__name__)
 class MessageSink(Protocol):
     """Persistence callbacks invoked by :class:`AgentPipeline`.
 
-    Every method MUST be safe to call multiple times and MUST NOT raise on
-    normal paths — sinks degrade gracefully and log internally if needed.
+    Every method MUST be safe to call multiple times.
+
+    Raising contract (prompt-sink-provider-2): an OBSERVABILITY sink (logging / metrics) MUST NOT
+    raise on normal paths — it degrades gracefully and logs internally. A PERSISTENCE sink (e.g.
+    :class:`SQLiteSink`, the durable source of truth) MAY raise on a genuine store I/O failure, and
+    the pipeline treats that as a FATAL send error (it does not swallow it): the send aborts and the
+    durable store stays authoritative. Callers that want best-effort persistence must wrap the sink.
     """
 
     async def on_round_started(self, round_index: int) -> None: ...
@@ -145,14 +150,15 @@ class SQLiteSink:
         role = message.get("role")
         if role == "tool":
             tool_call_id = str(message.get("tool_call_id") or "")
+            text, structured = _encode_content(message.get("content"))
             seq = await self.store.append_message(
                 self.session_id,
                 role="tool",
-                content=_as_text(message.get("content")),
+                content=text,
                 tool_call_id=tool_call_id,
                 name=message.get("name"),
                 round_index=round_index,
-                meta=message.get("meta"),
+                meta=_meta_with_content_encoding(message.get("meta"), structured=structured),
                 send_index=message.get("send_index"),
             )
             self._history_seqs.append(seq)
@@ -189,13 +195,14 @@ class SQLiteSink:
             return
         if role == "assistant":
             tool_calls = message.get("tool_calls")
+            text, structured = _encode_content(message.get("content"))
             seq = await self.store.append_message(
                 self.session_id,
                 role="assistant",
-                content=_as_text(message.get("content")),
+                content=text,
                 tool_calls=list(tool_calls) if tool_calls else None,
                 round_index=round_index,
-                meta=message.get("meta"),
+                meta=_meta_with_content_encoding(message.get("meta"), structured=structured),
                 send_index=message.get("send_index"),
                 hook_injected=message.get("hook_injected"),
             )
@@ -205,13 +212,14 @@ class SQLiteSink:
                 self._assistant_seq = seq
             return
         # user / system / anything else
+        text, structured = _encode_content(message.get("content"))
         seq = await self.store.append_message(
             self.session_id,
             role=str(role or "user"),
-            content=_as_text(message.get("content")),
+            content=text,
             name=message.get("name"),
             round_index=round_index,
-            meta=message.get("meta"),
+            meta=_meta_with_content_encoding(message.get("meta"), structured=structured),
             send_index=message.get("send_index"),
         )
         self._history_seqs.append(seq)
@@ -224,12 +232,18 @@ class SQLiteSink:
     ) -> None:
         ids = [str(tc.get("id") or "") for tc in tool_calls if tc.get("id")]
         self._unresolved = set(ids)
-        self._assistant_seq = assistant_seq
+        # Prefer the DB seq captured when the assistant row was appended (on_message_appended set
+        # self._assistant_seq to the store seq) over the caller's in-memory history INDEX, which
+        # diverges from the store seq once history is compacted/projected/rebuilt — persisting the
+        # index as assistant_seq would point resume at the wrong row (pipeline-runner-4). Fall back
+        # to the passed value only if no row seq was captured.
+        seq = self._assistant_seq if self._assistant_seq is not None else assistant_seq
+        self._assistant_seq = seq
         self._tool_calls = list(tool_calls)
         await self.store.set_pending(
             self.session_id,
             {
-                "assistant_seq": assistant_seq,
+                "assistant_seq": seq,
                 "round_index": round_index,
                 "tool_call_ids": ids,
                 "tool_calls": list(tool_calls),
@@ -262,6 +276,13 @@ class SQLiteSink:
         rows ``compacted_out``. The in-memory fold still stands; the un-persisted
         compaction simply re-triggers next round (active rows are untouched, so a
         resume is correct), trading a missed optimization for zero corruption.
+
+        RESIDUAL (compaction-2): this guard is LENGTH-only. A hook that replaces history with a
+        list of the SAME length but DIFFERENT identities (a length-preserving swap) passes the
+        check, so the fold indices would map through ``_history_seqs`` onto the wrong rows. INVARIANT
+        for hosts: a SESSION_START/ROUND_START hook that rewrites history must NOT preserve length
+        while changing message identities — change the length (so this guard skips persistence), or
+        keep identities stable. (A future fix can pass per-message identity, not just the length.)
         """
         if expected_history_len is not None and len(self._history_seqs) != expected_history_len:
             logger.warning(
@@ -359,6 +380,36 @@ class SQLiteSink:
             )
 
 
+# Meta marker recording that a row's text column holds JSON-encoded *structured* content
+# (a multimodal list / dict), so the reload path can losslessly reconstruct it instead of
+# handing the model a literal JSON string. (H6 — BUG_REVIEW_3.4.) The marker lives in meta
+# (jsonb, already round-trips) because the content column alone can't distinguish a
+# stringified list from a user string that merely looks like JSON.
+CONTENT_ENCODING_META_KEY = "content_encoding"
+CONTENT_ENCODING_JSON = "json"
+
+
+def _encode_content(content: Any) -> tuple[str | None, bool]:
+    """Return ``(text, structured)``. ``str``/``None`` pass through unflagged; a non-string
+    (multimodal list/dict) is JSON-encoded and flagged so reload reconstructs the original."""
+    if content is None or isinstance(content, str):
+        return content, False
+    import json
+
+    return json.dumps(content, ensure_ascii=False), True
+
+
+def _meta_with_content_encoding(
+    meta: dict[str, Any] | None, *, structured: bool
+) -> dict[str, Any] | None:
+    """Stamp the structured-content marker into ``meta`` (copy-on-write) when needed."""
+    if not structured:
+        return meta
+    out = dict(meta or {})
+    out[CONTENT_ENCODING_META_KEY] = CONTENT_ENCODING_JSON
+    return out
+
+
 def _as_text(content: Any) -> str | None:
     if content is None:
         return None

{power_loop-3.4.0 → power_loop-3.6.0}/power_loop/agent/stateful_loop.py

@@ -29,7 +29,13 @@ from typing import TYPE_CHECKING, Any
 
 from power_loop._vendor.llm_client.interface import LLMService
 from power_loop.agent.follow_up import FollowUpQueued, merge_follow_up_inputs
-from power_loop.agent.sink import SQLiteSink
+from power_loop.agent.sink import (
+    CONTENT_ENCODING_JSON,
+    CONTENT_ENCODING_META_KEY,
+    SQLiteSink,
+    _encode_content,
+    _meta_with_content_encoding,
+)
 from power_loop.agent.system_prompt import (
     resolve_runtime_system_prompt,
 )
@@ -759,12 +765,17 @@ class StatefulAgentLoop:
             sink = SQLiteSink(store, session_id)
             await self._prime_sink_from_pending(session_id, sink)
             round_index = int((pending or {}).get("round_index") or 0)
+            # Stamp the in-flight send's index so projection mode keeps this answer in the
+            # active send's current_rows (else it lands in the NULL-send_index legacy prefix,
+            # renders before its own tool_call, and is dropped as an orphan). See H1.
+            send_index = await self._current_send_index(store, session_id)
             await sink.on_message_appended(
                 {
                     "role": "tool",
                     "tool_call_id": str(interaction["tool_call_id"]),
                     "name": str(interaction.get("tool_name") or "request_user_input"),
                     "content": _as_tool_result_text(value),
+                    "send_index": send_index,
                 },
                 round_index=round_index,
             )
@@ -808,6 +819,10 @@ class StatefulAgentLoop:
         # 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)
+        # Stamp the pending send's index (runtime_state still holds it — abort runs before the
+        # next _persist_user_input bumps it) so projection keeps these <aborted> rows paired with
+        # their assistant tool_call instead of orphaning them in the legacy prefix. See H1.
+        send_index = await self._current_send_index(store, session_id)
         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
@@ -817,6 +832,7 @@ class StatefulAgentLoop:
                     "tool_call_id": cid,
                     "name": name,
                     "content": f"<aborted: {reason}>",
+                    "send_index": send_index,
                 },
                 round_index=round_index,
             )
@@ -1031,17 +1047,46 @@ class StatefulAgentLoop:
                 pending_tool_calls=pending.get("tool_calls", []),
             )
 
+    @staticmethod
+    def _coerce_send_index(raw: Any) -> int | None:
+        """The current send's authoritative index, or None when unallocated/legacy.
+
+        send_index is allocated >= 1 by _persist_user_input and persists across
+        resume()/submit_input()/follow-up (they inherit, never re-bump). 0 is the
+        unallocated/legacy default. A corrupted runtime_state value (non-numeric /
+        inf / nan) must degrade to "unallocated", never crash int()."""
+        try:
+            v = int(raw)
+        except (TypeError, ValueError, OverflowError):
+            return None
+        return v if v >= 1 else None
+
+    async def _current_send_index(self, store: Any, sid: str) -> int | None:
+        """Read the in-flight send index from runtime state (None if unallocated).
+
+        Out-of-band tool appends (submit_input/resume/abort_pending) MUST stamp this
+        onto every row so projection mode partitions them into the active send's
+        ``current_rows`` rather than the legacy (NULL send_index) prefix — otherwise
+        the tool result renders BEFORE its own assistant tool_call and align_tool_calls
+        drops it as an orphan, silently losing the answer."""
+        raw = await store.get_runtime_state(sid, "send_index", default=0)
+        return self._coerce_send_index(raw)
+
     async def _persist_user_input(self, sid: str, user_input: str | LoopMessage) -> None:
         store = await self._ensure_store()
         role: str
         content: str | None
         name: str | None
+        # Encode multimodal (list/dict) content losslessly: JSON in the text column + a meta
+        # marker so the reload path reconstructs the original structure rather than handing the
+        # model a literal JSON string (vision would otherwise silently break). See H6.
         if isinstance(user_input, str):
-            role, content, name = "user", user_input, None
+            role, content, name, structured = "user", user_input, None, False
         else:
             role = str(user_input.get("role", "user"))
-            content = _as_text(user_input.get("content"))
+            content, structured = _encode_content(user_input.get("content"))
             name = user_input.get("name")
+        meta = _meta_with_content_encoding(None, structured=structured)
         # Allocate the next monotonic SEND index for this session (atomic RMW under the
         # session_state row lock — never resets, unlike round_index). This is the single
         # send-begin point (exactly one user row per send; resume()/follow-up drains do
@@ -1051,18 +1096,18 @@ class StatefulAgentLoop:
             sid, "send_index", lambda v: int(v or 0) + 1, default=0
         )
         seq = await store.append_message(
-            sid, role=role, content=content, name=name, send_index=send_index
+            sid, role=role, content=content, name=name, send_index=send_index, meta=meta
         )
         # Keep a live cache entry current with the loop's OWN append (no reload): the next
         # send's next_seq token will then match and reuse the cached window. No-op if this
         # session isn't cached. The row mirrors what append_message persisted (only
-        # seq/role/content/name/send_index are consumed when rebuilding the working history).
+        # seq/role/content/name/send_index/meta are consumed when rebuilding the working history).
         self._cache_append(
             sid,
             MessageRow(
                 session_id=sid, seq=seq, role=role, name=name, content=content,
                 tool_calls=None, tool_call_id=None, round_index=None,
-                state=MessageState.ACTIVE, meta={}, created_at=0, send_index=send_index,
+                state=MessageState.ACTIVE, meta=meta or {}, created_at=0, send_index=send_index,
             ),
             new_next_seq=seq + 1,
         )
@@ -1088,6 +1133,10 @@ class StatefulAgentLoop:
             return
         # Initialize sink's in-memory unresolved set so auto-resolve works.
         await self._prime_sink_from_pending(sid, sink)
+        # The in-flight send's index (inherited, not re-bumped on resume): stamp it on every
+        # replayed tool row so projection mode pairs the result with its assistant tool_call
+        # instead of orphaning it in the NULL-send_index legacy prefix. See H1.
+        send_index = await self._current_send_index(store, sid)
         for tc in tool_calls:
             cid = str(tc.get("id") or "")
             name = _tool_call_name(tc)
@@ -1100,6 +1149,7 @@ class StatefulAgentLoop:
                         "tool_call_id": cid,
                         "name": None,
                         "content": "<aborted: unrecoverable tool_call on resume>",
+                        "send_index": send_index,
                     },
                     round_index=round_index,
                 )
@@ -1124,6 +1174,7 @@ class StatefulAgentLoop:
                     "tool_call_id": cid,
                     "name": name,
                     "content": _truncate_result(output),
+                    "send_index": send_index,
                 },
                 round_index=round_index,
             )
@@ -1159,18 +1210,10 @@ class StatefulAgentLoop:
         fold_strategy = self.config.fold_strategy
         # The current send's authoritative index (set by _persist_user_input; inherited by
         # resume()/follow-up). Read up-front so projection mode can partition history by it.
-        si = await store.get_runtime_state(sid, "send_index", default=0)
-        # send_index is allocated >= 1 by _persist_user_input and persists across resume();
-        # 0 is the unallocated/legacy default. Treat ONLY a real allocation (>= 1) as the current
-        # send — explicit (matches the `is not None` convention used below), never conflating the
-        # unallocated 0 with a (hypothetical) explicit send 0. Coerce defensively: a corrupted
-        # runtime_state value (non-numeric / inf / nan) must degrade to "unallocated", never crash
-        # the reader with int()'s ValueError/OverflowError.
-        try:
-            si_int = int(si)
-        except (TypeError, ValueError, OverflowError):
-            si_int = 0
-        current_send_index = si_int if si_int >= 1 else None
+        # The current send (>= 1) or None when unallocated/legacy — same coercion the out-of-band
+        # tool appends (submit_input/resume/abort_pending) use to stamp send_index, so the reader's
+        # partition and the writer's stamp can never disagree.
+        current_send_index = await self._current_send_index(store, sid)
         # Cache only the plain-send path: resume()/submit_input() pass a pre-primed sink built
         # from pending state (NOT a full init_history_seqs), so they must neither read from nor
         # write to the window cache — they self-invalidate via the next_seq bump from their own
@@ -1776,7 +1819,16 @@ class StatefulAgentLoop:
 def _row_to_loop_message(row: MessageRow) -> LoopMessage:
     msg: LoopMessage = {"role": row.role}
     if row.content is not None:
-        msg["content"] = row.content
+        content: Any = row.content
+        # Reconstruct structured (multimodal) content that was JSON-encoded on persist, so the
+        # model receives the original list/dict — not a literal JSON string. See H6. A corrupt
+        # marker / unparseable payload degrades to the raw text rather than raising.
+        if (row.meta or {}).get(CONTENT_ENCODING_META_KEY) == CONTENT_ENCODING_JSON:
+            try:
+                content = json.loads(row.content)
+            except (ValueError, TypeError):
+                content = row.content
+        msg["content"] = content
     if row.tool_calls:
         msg["tool_calls"] = list(row.tool_calls)
     if row.tool_call_id:
@@ -1786,12 +1838,6 @@ def _row_to_loop_message(row: MessageRow) -> LoopMessage:
     return msg
 
 
-def _as_text(content: Any) -> str | None:
-    if content is None or isinstance(content, str):
-        return content
-    return json.dumps(content, ensure_ascii=False)
-
-
 def _as_tool_result_text(value: Any) -> str:
     if isinstance(value, str):
         return value

{power_loop-3.4.0 → power_loop-3.6.0}/power_loop/contracts/messages.py

@@ -45,8 +45,11 @@ class AgentMessage:
         }
         if self.role == "assistant" and self.tool_calls:
             payload["tool_calls"] = [call.to_openai_tool_call() for call in self.tool_calls]
-        if self.role == "tool" and self.tool_call_id:
-            payload["tool_call_id"] = self.tool_call_id
+        if self.role == "tool":
+            # A tool-role message MUST carry tool_call_id — emit it unconditionally (empty string if
+            # unset) so we never produce a structurally-invalid tool message a provider rejects with
+            # an opaque error (exec-skills-structured-7).
+            payload["tool_call_id"] = self.tool_call_id or ""
         if self.name:
             payload["name"] = self.name
         return payload

{power_loop-3.4.0 → power_loop-3.6.0}/power_loop/contracts/protocols.py

@@ -44,5 +44,13 @@ class HookManagerProtocol(Protocol):
 
 
 class ToolArgsValidator(Protocol):
+    """Pre-execution tool-argument validator: return an error string to reject the call, or ``None``
+    to allow it (may be async).
+
+    RESERVED / PROVISIONAL (exec-skills-structured-6): this is a typed seam published for forward
+    compatibility, but the runtime does NOT yet consume it — there is currently no
+    ``ToolRegistry`` / ``AgentLoopConfig`` hook that calls a ToolArgsValidator. Validate tool args
+    inside the tool handler itself for now. (Tracked for a future wiring; not STABLE_API.)"""
+
     def __call__(self, tool_name: str, args: dict[str, Any]) -> str | None | Awaitable[str | None]:
         ...

power_loop-3.6.0/power_loop/contrib/_redact.py

@@ -0,0 +1,84 @@
+"""Shared payload sanitization for contrib event sinks (logging, JSONL).
+
+Truncates long strings and redacts secret-looking keys so event payloads can be logged
+or persisted without leaking credentials or blowing up volume. Used by both
+``logging_sink`` and ``jsonl_sink`` so the redaction policy is defined once.
+
+REDACTION SCOPE (important): by default redaction is **key-name based** — a value is
+replaced only when its *key* matches the denylist. Secrets embedded in string VALUES under
+benign keys (a ``Bearer …`` header inside a bash command string, an ``sk-…`` key pasted into
+a tool argument) are NOT scrubbed by the default policy. Opt into value-content scrubbing with
+``redact_value_secrets=True`` on the sink, which additionally regex-redacts common secret shapes
+(see :data:`DEFAULT_VALUE_PATTERNS`) inside string values.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable
+from typing import Any
+
+# Keys whose VALUE is replaced with "***" anywhere in a payload (case-insensitive
+# substring match on the key name). Tool inputs and request messages can carry secrets.
+# NB: bare "token" is intentionally NOT here — it would redact the non-secret usage
+# counts (prompt_tokens / completion_tokens / total_tokens). Specific token names are.
+DEFAULT_REDACT_KEYS: tuple[str, ...] = (
+    "api_key", "api-key", "apikey",
+    "authorization", "bearer",
+    "password", "passwd",
+    "secret", "secret_key",
+    "access_key", "private_key",
+    "access_token", "refresh_token", "auth_token", "id_token",
+)
+REDACTED = "***"
+
+#: Regexes for secret-shaped substrings scrubbed from string VALUES when value-content redaction
+#: is enabled (opt-in). Conservative shapes only, to avoid mangling ordinary text:
+DEFAULT_VALUE_PATTERNS: tuple[re.Pattern[str], ...] = (
+    re.compile(r"\bBearer\s+[A-Za-z0-9._~+/\-]{12,}=*", re.IGNORECASE),  # Authorization: Bearer …
+    re.compile(r"\b(?:sk|rk|pk|xoxb|xoxp|ghp|gho|github_pat)[-_][A-Za-z0-9_\-]{16,}"),  # provider keys
+    re.compile(r"\bAKIA[0-9A-Z]{16}\b"),                                 # AWS access key id
+    re.compile(r"\beyJ[A-Za-z0-9_\-]+\.[A-Za-z0-9_\-]+\.[A-Za-z0-9_\-]+"),  # JWT
+    re.compile(r"\bAIza[0-9A-Za-z_\-]{35}\b"),                           # Google API key
+)
+
+
+def resolve_redact(redact_keys: Iterable[str] | None) -> tuple[str, ...]:
+    """Lower-cased redaction key substrings. ``None`` → the default denylist; ``()``
+    disables redaction; any iterable overrides."""
+    keys = tuple(redact_keys if redact_keys is not None else DEFAULT_REDACT_KEYS)
+    return tuple(k.lower() for k in keys)
+
+
+def scrub_value_secrets(text: str, patterns: tuple[re.Pattern[str], ...]) -> str:
+    """Replace every secret-shaped substring matched by ``patterns`` with :data:`REDACTED`."""
+    for pat in patterns:
+        text = pat.sub(REDACTED, text)
+    return text
+
+
+def sanitize(
+    value: Any, limit: int, redact_lower: tuple[str, ...], *, max_list: int = 50,
+    value_patterns: tuple[re.Pattern[str], ...] | None = None,
+) -> Any:
+    """Recursively truncate long strings to ``limit`` and redact values under keys whose
+    (lower-cased) name contains any ``redact_lower`` substring. Lists are capped at ``max_list``
+    items. When ``value_patterns`` is given, secret-shaped substrings inside string VALUES are
+    scrubbed too (key-name redaction alone misses secrets embedded in values — M-observability-6)."""
+    if isinstance(value, str):
+        text = value if len(value) <= limit else value[:limit] + f"…(+{len(value) - limit})"
+        return scrub_value_secrets(text, value_patterns) if value_patterns else text
+    if isinstance(value, dict):
+        out: dict[Any, Any] = {}
+        for k, v in value.items():
+            kl = str(k).lower()
+            out[k] = REDACTED if any(r in kl for r in redact_lower) else sanitize(
+                v, limit, redact_lower, max_list=max_list, value_patterns=value_patterns
+            )
+        return out
+    if isinstance(value, list):
+        return [
+            sanitize(v, limit, redact_lower, max_list=max_list, value_patterns=value_patterns)
+            for v in value[:max_list]
+        ]
+    return value

{power_loop-3.4.0 → power_loop-3.6.0}/power_loop/contrib/jsonl_sink.py

@@ -28,7 +28,7 @@ from collections.abc import Iterable, Iterator
 from pathlib import Path
 
 from power_loop.contracts.events import AgentEvent, AgentEventType
-from power_loop.contrib._redact import resolve_redact, sanitize
+from power_loop.contrib._redact import DEFAULT_VALUE_PATTERNS, resolve_redact, sanitize
 from power_loop.core.events import AgentEventBus
 
 __all__ = ["attach_jsonl_sink", "replay", "JsonlSink"]
@@ -36,7 +36,15 @@ __all__ = ["attach_jsonl_sink", "replay", "JsonlSink"]
 
 class JsonlSink:
     """A size-rotated JSON-lines writer. One ``AgentEvent.to_dict()`` per line; rotates
-    to ``path.1``, ``path.2``, … (oldest dropped past ``backup_count``). Thread-safe."""
+    to ``path.1``, ``path.2``, … (oldest dropped past ``backup_count``). Thread-safe.
+
+    ``backup_count<=0`` disables size rotation entirely (the file grows unbounded) — previously it
+    truncated the file on every rotation, silently discarding ALL history (contrib-observability-5).
+
+    PERF (contrib-observability-4): ``write_line`` writes + ``flush()`` INLINE. If attached to a bus
+    that dispatches subscribers synchronously on the agent's own thread, that disk I/O stalls the
+    loop. For durability without stalling, attach this sink to a bus configured with threaded/async
+    dispatch (so writes happen off the loop thread)."""
 
     def __init__(self, path: str | Path, *, max_bytes: int = 10 * 1024 * 1024, backup_count: int = 5) -> None:
         self.path = Path(path)
@@ -50,7 +58,10 @@ class JsonlSink:
         with self._lock:
             if self._fh.closed:
                 return
-            if self.max_bytes and self._fh.tell() > 0 and self._fh.tell() + len(line) + 1 > self.max_bytes:
+            # Only rotate when we actually keep backups — backup_count<=0 means "no rotation" (let
+            # the file grow), NOT "rotate by truncating to nothing" (contrib-observability-5).
+            if (self.max_bytes and self.backup_count > 0 and self._fh.tell() > 0
+                    and self._fh.tell() + len(line) + 1 > self.max_bytes):
                 self._rotate()
             self._fh.write(line)
             self._fh.write("\n")
@@ -84,6 +95,7 @@ def attach_jsonl_sink(
     backup_count: int = 5,
     max_field_len: int = 2000,
     redact_keys: Iterable[str] | None = None,
+    redact_value_secrets: bool = False,
 ) -> JsonlSink:
     """Persist events from ``bus`` to a rotating JSONL file at ``path``.
 
@@ -91,17 +103,20 @@ def attach_jsonl_sink(
     :param max_bytes/backup_count: rotation (``0`` disables size rotation).
     :param max_field_len: truncate long string payload values.
     :param redact_keys: secret-key denylist (``None`` = default; ``()`` = no redaction).
+    :param redact_value_secrets: also scrub secret-shaped substrings inside string VALUES
+        (off by default; key-name redaction alone misses value-embedded secrets — M-observability-6).
     Returns the :class:`JsonlSink`; call ``.close()`` to flush + release the file.
     """
     sink = JsonlSink(path, max_bytes=max_bytes, backup_count=backup_count)
     wanted = set(events) if events is not None else None
     redact_lower = resolve_redact(redact_keys)
+    value_patterns = DEFAULT_VALUE_PATTERNS if redact_value_secrets else None
 
     def _handler(event: AgentEvent) -> None:
         if wanted is not None and event.type not in wanted:
             return
         d = event.to_dict()
-        d["payload"] = sanitize(d.get("payload") or {}, max_field_len, redact_lower)
+        d["payload"] = sanitize(d.get("payload") or {}, max_field_len, redact_lower, value_patterns=value_patterns)
         sink.write_line(json.dumps(d, ensure_ascii=False, default=str))
 
     if wanted is None:

{power_loop-3.4.0 → power_loop-3.6.0}/power_loop/contrib/logging_sink.py

@@ -35,6 +35,7 @@ from typing import Any
 from power_loop.contracts.events import AgentEvent, AgentEventType
 from power_loop.contrib._redact import (
     DEFAULT_REDACT_KEYS,
+    DEFAULT_VALUE_PATTERNS,
     REDACTED,
     resolve_redact,
     sanitize,
@@ -58,6 +59,7 @@ def attach_logging_sink(
     events: Iterable[AgentEventType] | None = None,
     max_field_len: int = 500,
     redact_keys: Iterable[str] | None = None,
+    redact_value_secrets: bool = False,
 ) -> None:
     """Subscribe a JSON-lines logger to ``bus``.
 
@@ -66,10 +68,14 @@ def attach_logging_sink(
     :param redact_keys: key-name substrings whose values are replaced with ``***``.
         Defaults to a common secret denylist (api_key/token/password/…); pass
         ``()`` to disable redaction, or your own iterable to override.
+    :param redact_value_secrets: also scrub secret-shaped substrings (Bearer/sk-/AKIA/JWT/…)
+        inside string VALUES, not just denylisted keys. Off by default (M-observability-6) —
+        key-name redaction alone misses secrets embedded in tool args / command strings.
     """
     log = logger if logger is not None else logging.getLogger(DEFAULT_LOGGER_NAME)
     wanted = set(events) if events is not None else None
     redact_lower = resolve_redact(redact_keys)
+    value_patterns = DEFAULT_VALUE_PATTERNS if redact_value_secrets else None
 
     def _handler(event: AgentEvent) -> None:
         if wanted is not None and event.type not in wanted:
@@ -89,7 +95,7 @@ def attach_logging_sink(
         if event.source:
             record["source"] = event.source
         payload = event.payload or {}
-        record["payload"] = sanitize(payload, max_field_len, redact_lower)
+        record["payload"] = sanitize(payload, max_field_len, redact_lower, value_patterns=value_patterns)
         log.log(level, json.dumps(record, ensure_ascii=False, default=str))
 
     if wanted is None:

{power_loop-3.4.0 → power_loop-3.6.0}/power_loop/contrib/metrics_sink.py

@@ -24,6 +24,7 @@ Metrics emitted (prefix ``power_loop`` by default):
 
 from __future__ import annotations
 
+import logging
 from collections.abc import Iterable
 from typing import Any, Protocol, runtime_checkable
 
@@ -32,6 +33,8 @@ from power_loop.core.events import AgentEventBus
 
 __all__ = ["MetricsBackend", "attach_metrics_sink", "PrometheusBackend", "StatsDBackend"]
 
+logger = logging.getLogger(__name__)
+
 
 @runtime_checkable
 class MetricsBackend(Protocol):
@@ -57,6 +60,17 @@ def attach_metrics_sink(
         return wanted is None or t in wanted
 
     def _handler(event: AgentEvent) -> None:
+        # Observability must NEVER break the loop: a real backend can raise (StatsD socket
+        # OSError, prometheus_client ValueError on a bad/duplicate metric or label), and on a
+        # bus with suppress_subscriber_errors=False (the default, incl. DEFAULT_EVENT_BUS) an
+        # unhandled subscriber exception unwinds through publish() and aborts the agent run.
+        # Log-and-swallow here, mirroring otel_sink's guards. See H7 (BUG_REVIEW_3.4).
+        try:
+            _dispatch(event)
+        except Exception:  # noqa: BLE001 — a metrics hiccup is a dropped data point, not a failed run
+            logger.exception("metrics sink backend failed; dropping this metric and continuing")
+
+    def _dispatch(event: AgentEvent) -> None:
         p = event.payload or {}
         t = event.type
         if not _on(t):