npm - @ngocsangairvds/vsaf - Versions diffs - 3.2.15 → 4.0.0 - Mend

@ngocsangairvds/vsaf 3.2.15 → 4.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2337) hide show

package/tools/vds-scripts/telegram_bridge/tests/acceptance/test_ac_09_long_block_spill.py DELETED Viewed

@@ -1,121 +0,0 @@
-"""AC-1.9: Long fenced block spills to sendDocument (FR-2.7 / TSK-5.4).
-Scenario: agent emits a 5 KB ```python``` fenced block; StreamingThrottler
-detects it exceeds DOCUMENT_SPILL_CHARS (~3800) and calls send_document instead
-of editMessageText. The original fenced span is replaced with a placeholder so
-it does not re-trigger on subsequent chunks.
-"""
-from __future__ import annotations
-from uuid import uuid4
-import pytest
-from telegram_bridge.daemon.throttler import (
-    DOCUMENT_SPILL_CHARS,
-    ChatTokenBucket,
-    StreamingThrottler,
-)
-@pytest.mark.asyncio
-async def test_5kb_python_fence_spills_to_send_document(
-    fake_streaming_gateway,
-) -> None:
-    """AC-1.9 primary: a single ```python``` block larger than DOCUMENT_SPILL_CHARS
-    (~3800 chars) is sent as a Telegram document (not an edit).
-    The fence body is chosen to exceed DOCUMENT_SPILL_CHARS but the total
-    message buffer (fence open + body + fence close) must stay below
-    MAX_MESSAGE_CHARS (4096) to avoid the rollover splitting the fence across
-    two messages. Rollover would place the opening ``` in one finalized message
-    and the closing ``` in the next, preventing fence detection.
-    Build order:
-    1. Real StreamingThrottler with FakeStreamingGateway injected.
-    2. attach_session — establishes the per-session stream state.
-    3. on_chunk × N building the fence across multiple deltas.
-    4. on_complete — final flush.
-    5. Assert gateway.docs contains exactly one entry whose filename ends with
-       '.python' and whose content contains the fence body.
-    """
-    bucket = ChatTokenBucket(capacity=20, refill_per_second=100.0)
-    throttler = StreamingThrottler(gateway=fake_streaming_gateway, bucket=bucket)
-    sid = uuid4()
-    throttler.attach_session(sid, supergroup_id=-1001, message_thread_id=10)
-    # Fence body is just over DOCUMENT_SPILL_CHARS (3800) but the full buffer
-    # (open_line(10) + body + close_line(5)) stays below MAX_MESSAGE_CHARS (4096):
-    #   10 + 3810 + 5 = 3825 < 4096 → no rollover; fence stays intact.
-    fence_body = "x" * (DOCUMENT_SPILL_CHARS + 10)
-    assert len(fence_body) > DOCUMENT_SPILL_CHARS
-    total_len = len("```python\n") + len(fence_body) + len("\n```\n")
-    assert total_len < 4096, "test invariant: fence must fit in one message"
-    # Deliver the fence in two chunks to simulate streaming.
-    half = len(fence_body) // 2
-    await throttler.on_chunk(sid, "```python\n")
-    await throttler.on_chunk(sid, fence_body[:half])
-    await throttler.on_chunk(sid, fence_body[half:])
-    await throttler.on_chunk(sid, "\n```\n")
-    await throttler.on_complete(sid)
-    assert len(fake_streaming_gateway.docs) == 1, (
-        f"expected exactly one sendDocument call for the oversized python fence; "
-        f"got {len(fake_streaming_gateway.docs)} docs, "
-        f"{len(fake_streaming_gateway.edits)} edits"
-    )
-    doc = fake_streaming_gateway.docs[0]
-    assert doc["filename"] == "agent-output.python", f"expected 'agent-output.python', got {doc['filename']!r}"
-    # The fence body must appear in the document content.
-    assert b"x" * 100 in doc["content"]
-@pytest.mark.asyncio
-async def test_spilled_fence_placeholder_appears_in_edit(
-    fake_streaming_gateway,
-) -> None:
-    """AC-1.9 rewrite: after spilling, the buffer retains a one-line placeholder
-    so subsequent edits don't re-send the same fence content.
-    """
-    bucket = ChatTokenBucket(capacity=20, refill_per_second=100.0)
-    throttler = StreamingThrottler(gateway=fake_streaming_gateway, bucket=bucket)
-    sid = uuid4()
-    throttler.attach_session(sid, supergroup_id=-1001, message_thread_id=11)
-    fence_body = "z" * (DOCUMENT_SPILL_CHARS + 50)
-    await throttler.on_chunk(sid, f"```diff\n{fence_body}\n```\n")
-    await throttler.on_chunk(sid, "some trailing text")
-    await throttler.on_complete(sid)
-    # Exactly one doc (the fence); the trailing text stays in the main message.
-    assert len(fake_streaming_gateway.docs) == 1
-    # The edit (final flush) should contain the placeholder text, not the raw
-    # fence body.
-    all_edit_texts = [e["text"] for e in fake_streaming_gateway.edits]
-    all_sent_texts = [m["text"] for m in fake_streaming_gateway.sent]
-    combined = " ".join(all_edit_texts + all_sent_texts)
-    assert "z" * 100 not in combined, "original fence body must not appear in message text after spill rewrite"
-    assert "diff content sent as file" in combined or "trailing text" in combined
-@pytest.mark.asyncio
-async def test_diff_with_more_than_50_lines_spills(fake_streaming_gateway) -> None:
-    """AC-1.9 variant: a ```diff``` block with >50 lines triggers spill even if
-    total char count is below DOCUMENT_SPILL_CHARS.
-    """
-    bucket = ChatTokenBucket(capacity=20, refill_per_second=100.0)
-    throttler = StreamingThrottler(gateway=fake_streaming_gateway, bucket=bucket)
-    sid = uuid4()
-    throttler.attach_session(sid, supergroup_id=-1001, message_thread_id=12)
-    diff_body = "\n".join(f"+ line {i}" for i in range(60))  # 60 lines > 50 limit
-    await throttler.on_chunk(sid, f"```diff\n{diff_body}\n```\n")
-    await throttler.on_complete(sid)
-    assert len(fake_streaming_gateway.docs) == 1
-    assert fake_streaming_gateway.docs[0]["filename"] == "agent-output.diff"

package/tools/vds-scripts/telegram_bridge/tests/acceptance/test_ac_10_streaming_throttle.py DELETED Viewed

@@ -1,90 +0,0 @@
-"""AC-1.10: Streaming throttle — 100 chunks over ~3s coalesce into ≤10 edits.
-Scenario: the agent emits 100 single-character chunks with 30 ms between each
-(total ~3 s). The StreamingThrottler's 1 Hz coalesce window must suppress all
-but a handful of editMessageText calls, keeping the total well below the 100
-raw-chunk count and comfortably under the ≤10 threshold.
-Timing rationale:
-    - 100 chunks × 0.03 s = 3.0 s total streaming time.
-    - Coalesce timer = 1.0 s (COALESCE_INTERVAL_NORMAL_S).
-    - Expected edits ≈ 3 timer-fires + 1 final flush from on_complete = ~4.
-    - ≤10 is a generous upper bound that accounts for timer jitter.
-"""
-from __future__ import annotations
-import asyncio
-from uuid import uuid4
-import pytest
-from telegram_bridge.daemon.throttler import (
-    ChatTokenBucket,
-    StreamingThrottler,
-)
-_CHUNKS = 100
-_CHUNK_INTERVAL_S = 0.03  # 30 ms between chunks → ~3 s total
-_MAX_EXPECTED_EDITS = 10  # spec ceiling; real count is ~3-5
-@pytest.mark.asyncio
-async def test_100_chunks_coalesce_into_at_most_10_edits(
-    fake_streaming_gateway,
-) -> None:
-    """AC-1.10 primary: 100 short chunks emitted over 3 s produce at most 10
-    editMessageText calls total (including the final flush from on_complete).
-    Build order:
-    1. Real StreamingThrottler with generous bucket (no rate-limit interference).
-    2. attach_session.
-    3. on_chunk("x") × 100 with asyncio.sleep(0.03) between each.
-    4. on_complete.
-    5. Assert len(gateway.edits) ≤ 10.
-    """
-    bucket = ChatTokenBucket(capacity=50, refill_per_second=100.0)
-    throttler = StreamingThrottler(gateway=fake_streaming_gateway, bucket=bucket)
-    sid = uuid4()
-    throttler.attach_session(sid, supergroup_id=-1001, message_thread_id=20)
-    for _ in range(_CHUNKS):
-        await throttler.on_chunk(sid, "x")
-        await asyncio.sleep(_CHUNK_INTERVAL_S)
-    await throttler.on_complete(sid)
-    total_edits = len(fake_streaming_gateway.edits)
-    assert total_edits <= _MAX_EXPECTED_EDITS, (
-        f"expected ≤{_MAX_EXPECTED_EDITS} edits for {_CHUNKS} chunks; "
-        f"got {total_edits} — throttler coalescing may be broken"
-    )
-    assert total_edits >= 1, "at least the on_complete flush should emit one edit"
-@pytest.mark.asyncio
-async def test_final_message_contains_all_chunks(fake_streaming_gateway) -> None:
-    """AC-1.10 content: despite coalescing, the final edit must contain the
-    accumulated text from all chunks — no data is dropped.
-    """
-    bucket = ChatTokenBucket(capacity=50, refill_per_second=100.0)
-    throttler = StreamingThrottler(gateway=fake_streaming_gateway, bucket=bucket)
-    sid = uuid4()
-    throttler.attach_session(sid, supergroup_id=-1001, message_thread_id=21)
-    for _ in range(_CHUNKS):
-        await throttler.on_chunk(sid, "x")
-        await asyncio.sleep(_CHUNK_INTERVAL_S)
-    await throttler.on_complete(sid)
-    # The last edit (or the only one) must have all 100 'x' chars.
-    if fake_streaming_gateway.edits:
-        last_edit_text = fake_streaming_gateway.edits[-1]["text"]
-    else:
-        # If on_complete flushed without prior edits, check sent messages.
-        last_edit_text = fake_streaming_gateway.sent[-1]["text"] if fake_streaming_gateway.sent else ""
-    assert "x" * _CHUNKS in last_edit_text, "accumulated text from all 100 chunks must appear in the final message"

package/tools/vds-scripts/telegram_bridge/tests/acceptance/test_ac_11_audit_invariant.py DELETED Viewed

@@ -1,156 +0,0 @@
-"""AC-1.11: Audit-write-before-side-effect invariant (FR-7.5 / ADR-5).
-Scenario: every assistant_chunk emitted by the runner is audit-recorded in
-Postgres BEFORE the event is published to the SessionBus (and therefore before
-the throttler can issue an editMessageText).
-The invariant is load-bearing: without it, Telegram edits can precede the audit
-row, making the audit log a lagging shadow of an already-observable agent.
-Test approach:
-- Build a RunnerOrchestrator with a recording AuditWriter and SessionBus.
-- Call _handle_outbound directly with an AssistantChunkFrame.
-- Assert that the first recorded action is "audit" and the second is "bus.publish".
-Note: calling orch._handle_outbound is direct but not monkeypatched — we are
-driving the production code, not bypassing it.
-"""
-from __future__ import annotations
-from pathlib import Path
-from uuid import uuid4
-import pytest
-from telegram_bridge.daemon.runner_orchestrator import RunnerOrchestrator
-from telegram_bridge.models.events import Event, EventType
-from telegram_bridge.runners._base.protocol import AssistantChunkFrame
-# ---------------------------------------------------------------------------
-# Recording fakes (local to this test — not in conftest to keep them explicit)
-# ---------------------------------------------------------------------------
-class _RecordingAudit:
-    """Appends ("audit", event_type_str) to the shared order list."""
-    def __init__(self, order: list[str]) -> None:
-        self._order = order
-    async def record_event(self, event: Event, *, blob: bytes | None = None) -> int:
-        self._order.append(f"audit:{event.event_type}")
-        return 1
-    async def write_session_end(self, *args, **kwargs) -> int:
-        return 1
-class _RecordingBus:
-    """Appends ("bus", event_type_str) to the shared order list."""
-    def __init__(self, order: list[str]) -> None:
-        self._order = order
-    async def publish(self, event: Event) -> None:
-        self._order.append(f"bus:{event.event_type}")
-class _NullRegistry:
-    """Minimal registry stub — no sessions needed for _handle_outbound."""
-    def list_active(self) -> list:
-        return []
-# ---------------------------------------------------------------------------
-# Tests
-# ---------------------------------------------------------------------------
-@pytest.mark.asyncio
-async def test_audit_recorded_before_bus_publish_for_assistant_chunk() -> None:
-    """AC-1.11 primary: audit.record_event is awaited and complete BEFORE
-    bus.publish is called for an AssistantChunkFrame.
-    The production code in RunnerOrchestrator._handle_outbound is:
-        await self._audit.record_event(ev)
-        await self._bus.publish(ev)
-    Both awaits are sequential; the recording order proves the invariant holds.
-    """
-    call_order: list[str] = []
-    orch = RunnerOrchestrator(
-        registry=_NullRegistry(),
-        audit=_RecordingAudit(call_order),
-        bus=_RecordingBus(call_order),
-        runner_dir=Path("/tmp/invariant-test"),
-        db_dsn="postgresql://fake",
-    )
-    sid = uuid4()
-    frame = AssistantChunkFrame(session_id=sid, delta="hello world", message_id="m1")
-    await orch._handle_outbound(sid, frame)
-    assert len(call_order) == 2, f"expected exactly 2 recorded actions (audit + bus); got {call_order}"
-    assert call_order[0] == f"audit:{EventType.ASSISTANT_CHUNK}", (
-        f"first action must be audit write; got {call_order[0]!r}"
-    )
-    assert call_order[1] == f"bus:{EventType.ASSISTANT_CHUNK}", (
-        f"second action must be bus publish; got {call_order[1]!r}"
-    )
-@pytest.mark.asyncio
-async def test_hello_frame_produces_no_audit_or_bus_call() -> None:
-    """AC-1.11 negative: HelloFrame is intentionally not audited or published.
-    _translate_frame returns (None, {}) for HelloFrame so the invariant path
-    is skipped. This verifies the skip is correct, not a bug.
-    """
-    from telegram_bridge.runners._base.protocol import HelloFrame
-    call_order: list[str] = []
-    orch = RunnerOrchestrator(
-        registry=_NullRegistry(),
-        audit=_RecordingAudit(call_order),
-        bus=_RecordingBus(call_order),
-        runner_dir=Path("/tmp/invariant-test"),
-        db_dsn="postgresql://fake",
-    )
-    sid = uuid4()
-    frame = HelloFrame(session_id=sid, runner_kind="claude-sdk-runner", pid=999)
-    await orch._handle_outbound(sid, frame)
-    assert call_order == [], "HelloFrame must not trigger audit or bus publish"
-@pytest.mark.asyncio
-async def test_tool_call_audit_before_bus() -> None:
-    """AC-1.11 variant: ToolCallFrame also satisfies the invariant — audit
-    before bus publish.
-    """
-    from telegram_bridge.runners._base.protocol import ToolCallFrame
-    call_order: list[str] = []
-    orch = RunnerOrchestrator(
-        registry=_NullRegistry(),
-        audit=_RecordingAudit(call_order),
-        bus=_RecordingBus(call_order),
-        runner_dir=Path("/tmp/invariant-test"),
-        db_dsn="postgresql://fake",
-    )
-    sid = uuid4()
-    frame = ToolCallFrame(
-        session_id=sid,
-        tool_call_id="tc1",
-        tool_name="Read",
-        tool_input={"file_path": "/README.md"},
-    )
-    await orch._handle_outbound(sid, frame)
-    assert len(call_order) == 2
-    assert call_order[0].startswith("audit:")
-    assert call_order[1].startswith("bus:")

package/tools/vds-scripts/telegram_bridge/tests/acceptance/test_ac_12_pg_outage_strict.py DELETED Viewed

@@ -1,171 +0,0 @@
-"""AC-1.12: Postgres outage — strict audit Option A (TSK-7.7 / FR-7.5).
-Scenario: AuditWriter raises PostgresUnavailable during record_event.
-RunnerOrchestrator.send_input must propagate that exception to the caller
-WITHOUT forwarding input to the runner (side-effect refused).
-This is the load-bearing claim of 'audit-only' safety policy (ADR-5): when
-the audit write fails, the daemon refuses to act on user input.
-"""
-from __future__ import annotations
-import asyncio
-from contextlib import asynccontextmanager
-from pathlib import Path
-from uuid import uuid4
-import pytest
-from telegram_bridge.daemon.audit import PostgresUnavailable
-from telegram_bridge.daemon.runner_orchestrator import RunnerOrchestrator
-# ---------------------------------------------------------------------------
-# Local fakes for this test module
-# ---------------------------------------------------------------------------
-class _FailingAudit:
-    """Always raises PostgresUnavailable on record_event."""
-    async def record_event(self, event, *, blob=None):
-        raise PostgresUnavailable("simulated Postgres outage for AC-1.12")
-    async def write_session_end(self, *args, **kwargs):
-        raise PostgresUnavailable("simulated Postgres outage for AC-1.12")
-class _RecordingAudit:
-    """Records calls; does NOT raise."""
-    def __init__(self) -> None:
-        self.calls: list[str] = []
-    async def record_event(self, event, *, blob=None) -> int:
-        self.calls.append(str(event.event_type))
-        return 1
-    async def write_session_end(self, *args, **kwargs) -> int:
-        return 1
-class _FakeRegistry:
-    """Per-session asyncio.Lock for acquire_input_lock."""
-    def __init__(self) -> None:
-        self._locks: dict = {}
-    def register(self, session_id) -> None:
-        self._locks[session_id] = asyncio.Lock()
-    @asynccontextmanager
-    async def acquire_input_lock(self, session_id):
-        lock = self._locks.get(session_id)
-        if lock is None:
-            raise KeyError(session_id)
-        async with lock:
-            yield
-    def list_active(self) -> list:
-        return []
-class _FakeBus:
-    async def publish(self, event) -> None:
-        pass
-class _FakeHandle:
-    """Records whether send_input was called (it must NOT be, in the outage case)."""
-    def __init__(self) -> None:
-        self.send_calls: int = 0
-    async def send_input(self, frame) -> None:
-        self.send_calls += 1
-# ---------------------------------------------------------------------------
-# Tests
-# ---------------------------------------------------------------------------
-@pytest.mark.asyncio
-async def test_postgres_unavailable_propagates_from_send_input() -> None:
-    """AC-1.12 primary: when AuditWriter.record_event raises PostgresUnavailable,
-    RunnerOrchestrator.send_input propagates it to the caller.
-    The runner handle's send_input must NOT be called — the daemon refuses the
-    side effect when the audit write fails.
-    """
-    registry = _FakeRegistry()
-    fake_handle = _FakeHandle()
-    sid = uuid4()
-    registry.register(sid)
-    orch = RunnerOrchestrator(
-        registry=registry,  # type: ignore[arg-type]
-        audit=_FailingAudit(),  # type: ignore[arg-type]
-        bus=_FakeBus(),  # type: ignore[arg-type]
-        runner_dir=Path("/tmp/pg-outage-test"),
-        db_dsn="postgresql://fake",
-    )
-    # Inject fake handle so the session-lookup succeeds before the audit call.
-    orch._handles[sid] = fake_handle  # type: ignore[assignment]
-    with pytest.raises(PostgresUnavailable):
-        await orch.send_input(sid, text="hello agent")
-    assert fake_handle.send_calls == 0, (
-        "runner handle.send_input must NOT be called when audit raises PostgresUnavailable"
-    )
-@pytest.mark.asyncio
-async def test_send_input_succeeds_when_audit_is_healthy() -> None:
-    """AC-1.12 contrast: when AuditWriter works, send_input completes normally
-    and the runner handle IS called.
-    """
-    registry = _FakeRegistry()
-    recording_audit = _RecordingAudit()
-    fake_handle = _FakeHandle()
-    sid = uuid4()
-    registry.register(sid)
-    orch = RunnerOrchestrator(
-        registry=registry,  # type: ignore[arg-type]
-        audit=recording_audit,  # type: ignore[arg-type]
-        bus=_FakeBus(),  # type: ignore[arg-type]
-        runner_dir=Path("/tmp/pg-outage-test"),
-        db_dsn="postgresql://fake",
-    )
-    orch._handles[sid] = fake_handle  # type: ignore[assignment]
-    await orch.send_input(sid, text="hello agent")
-    assert "user_input" in recording_audit.calls, "audit should have recorded a user_input event"
-    assert fake_handle.send_calls == 1, "runner handle.send_input must be called exactly once on success"
-@pytest.mark.asyncio
-async def test_send_input_raises_key_error_for_unknown_session() -> None:
-    """AC-1.12 boundary: send_input for a session with no registered runner
-    raises KeyError, not PostgresUnavailable.
-    """
-    registry = _FakeRegistry()
-    sid = uuid4()
-    registry.register(sid)
-    orch = RunnerOrchestrator(
-        registry=registry,  # type: ignore[arg-type]
-        audit=_RecordingAudit(),  # type: ignore[arg-type]
-        bus=_FakeBus(),  # type: ignore[arg-type]
-        runner_dir=Path("/tmp/pg-outage-test"),
-        db_dsn="postgresql://fake",
-    )
-    # Do NOT inject a handle — _handles is empty.
-    with pytest.raises(KeyError):
-        await orch.send_input(sid, text="this should fail fast")

package/tools/vds-scripts/telegram_bridge/tests/acceptance/test_ac_13_redaction_in_blob.py DELETED Viewed

@@ -1,146 +0,0 @@
-"""AC-1.13: Secret-shaped substrings are redacted before blob storage (NFR-5.4).
-Scenario: AuditWriter receives an event whose payload contains an Anthropic API
-key (sk-ant-<60chars>). The PatternRedactionInterceptor must replace the secret
-with <REDACTED:ANTHROPIC_API_KEY:sha8> BEFORE the blob is written to
-vds_telegram_audit_blobs. The raw key must not appear in storage.
-The real AuditWriter + real PatternRedactionInterceptor are used here —
-no mocks on the redaction path. Only the Postgres pool is faked.
-"""
-from __future__ import annotations
-import hashlib
-from uuid import uuid4
-import pytest
-from telegram_bridge.daemon.audit import (
-    BLOB_OFFLOAD_THRESHOLD_BYTES,
-    AuditWriter,
-    PatternRedactionInterceptor,
-)
-from telegram_bridge.models.events import Event, EventType
-@pytest.mark.asyncio
-async def test_anthropic_api_key_redacted_in_stored_blob(fake_pg_pool) -> None:
-    """AC-1.13 primary: sk-ant-<60chars> is redacted to
-    <REDACTED:ANTHROPIC_API_KEY:sha8> before the blob lands in Postgres.
-    The raw key must NOT appear in the stored blob bytes.
-    """
-    interceptor = PatternRedactionInterceptor()
-    audit = AuditWriter(pg=fake_pg_pool, interceptor=interceptor)  # type: ignore[arg-type]
-    # Build a payload large enough to force blob offload (> 1 KiB threshold).
-    secret_key = "sk-ant-" + "A" * 60  # 67-char Anthropic-shaped key
-    filler = "x" * (BLOB_OFFLOAD_THRESHOLD_BYTES + 100)
-    payload = {"text": secret_key, "filler": filler}
-    ev = Event(
-        session_id=uuid4(),
-        source_surface="telegram",
-        event_type=EventType.USER_INPUT,
-        payload=payload,
-    )
-    seq = await audit.record_event(ev)
-    assert seq == 1, "record_event should return the allocated seq"
-    # Inspect what was stored in the fake pool.
-    stored_blobs = fake_pg_pool.pool.store.get("blobs", {})
-    assert stored_blobs, (
-        "at least one blob should have been stored "
-        f"(payload size {len(str(payload))} > {BLOB_OFFLOAD_THRESHOLD_BYTES} threshold)"
-    )
-    blob_bytes: bytes = next(iter(stored_blobs.values()))
-    # The raw secret must be absent from storage.
-    assert b"sk-ant-" not in blob_bytes, "raw Anthropic API key prefix must be redacted before storage"
-    # The redaction marker must be present.
-    assert b"<REDACTED:ANTHROPIC_API_KEY:" in blob_bytes, (
-        f"expected <REDACTED:ANTHROPIC_API_KEY:...> in blob, got: {blob_bytes[:200]!r}"
-    )
-@pytest.mark.asyncio
-async def test_redaction_marker_includes_sha8(fake_pg_pool) -> None:
-    """AC-1.13 marker format: the redaction tag contains the first 8 hex chars
-    of SHA-256 of the matched secret (deterministic, correlatable).
-    """
-    secret_key = "sk-ant-" + "B" * 60
-    expected_sha8 = hashlib.sha256(secret_key.encode()).hexdigest()[:8]
-    interceptor = PatternRedactionInterceptor()
-    audit = AuditWriter(pg=fake_pg_pool, interceptor=interceptor)  # type: ignore[arg-type]
-    filler = "y" * (BLOB_OFFLOAD_THRESHOLD_BYTES + 100)
-    payload = {"secret": secret_key, "pad": filler}
-    ev = Event(
-        session_id=uuid4(),
-        source_surface="agent",
-        event_type=EventType.ASSISTANT_CHUNK,
-        payload=payload,
-    )
-    await audit.record_event(ev)
-    stored_blobs = fake_pg_pool.pool.store.get("blobs", {})
-    assert stored_blobs, "blob must be stored"
-    blob_bytes = next(iter(stored_blobs.values()))
-    expected_marker = f"<REDACTED:ANTHROPIC_API_KEY:{expected_sha8}>".encode()
-    assert expected_marker in blob_bytes, f"expected marker {expected_marker!r} in blob content"
-@pytest.mark.asyncio
-async def test_passthrough_blob_not_redacted(fake_pg_pool) -> None:
-    """AC-1.13 passthrough: a payload with NO secrets is stored verbatim
-    (no marker injection, no data corruption).
-    """
-    from telegram_bridge.daemon.audit import PassthroughInterceptor
-    interceptor = PassthroughInterceptor()
-    audit = AuditWriter(pg=fake_pg_pool, interceptor=interceptor)  # type: ignore[arg-type]
-    filler = "clean text with no secrets " * 50  # > 1 KiB
-    payload = {"text": filler}
-    ev = Event(
-        session_id=uuid4(),
-        source_surface="telegram",
-        event_type=EventType.USER_INPUT,
-        payload=payload,
-    )
-    await audit.record_event(ev)
-    stored_blobs = fake_pg_pool.pool.store.get("blobs", {})
-    assert stored_blobs
-    blob_bytes = next(iter(stored_blobs.values()))
-    assert b"REDACTED" not in blob_bytes, "passthrough interceptor must not inject redaction markers"
-    assert b"clean text" in blob_bytes
-@pytest.mark.asyncio
-async def test_small_payload_not_offloaded_to_blob(fake_pg_pool) -> None:
-    """AC-1.13 boundary: payloads below BLOB_OFFLOAD_THRESHOLD_BYTES are stored
-    inline in the event row (no blob INSERT). The fake pool's blob store stays empty.
-    """
-    interceptor = PatternRedactionInterceptor()
-    audit = AuditWriter(pg=fake_pg_pool, interceptor=interceptor)  # type: ignore[arg-type]
-    small_payload = {"text": "short"}  # well under 1 KiB
-    ev = Event(
-        session_id=uuid4(),
-        source_surface="telegram",
-        event_type=EventType.USER_INPUT,
-        payload=small_payload,
-    )
-    await audit.record_event(ev)
-    stored_blobs = fake_pg_pool.pool.store.get("blobs", {})
-    assert len(stored_blobs) == 0, "small payload must not trigger a blob offload INSERT"