xdog-coding 2.3.0__tar.gz → 2.4.1__tar.gz

{xdog_coding-2.3.0 → xdog_coding-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: xdog-coding
-Version: 2.3.0
+Version: 2.4.1
 Summary: Interactive coding agent CLI
 Project-URL: Homepage, https://xdog.942295.xyz
 Project-URL: Repository, https://github.com/litterzhang/xdog
@@ -21,9 +21,9 @@ Requires-Python: >=3.12
 Requires-Dist: click>=8.1.0
 Requires-Dist: pydantic>=2.0
 Requires-Dist: pyyaml>=6.0
-Requires-Dist: xdog-agent>=2.3.0
-Requires-Dist: xdog-ai[openai]>=2.3.0
-Requires-Dist: xdog-tui>=2.3.0
+Requires-Dist: xdog-agent>=2.4.1
+Requires-Dist: xdog-ai[openai]>=2.4.1
+Requires-Dist: xdog-tui>=2.4.1
 Description-Content-Type: text/markdown
 
 # xdog-coding

{xdog_coding-2.3.0 → xdog_coding-2.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "xdog-coding"
-version = "2.3.0"
+version = "2.4.1"
 description = "Interactive coding agent CLI"
 requires-python = ">=3.12"
 classifiers = [
@@ -21,9 +21,9 @@ readme = "README.md"
 license = "AGPL-3.0-or-later"
 license-files = ["LICENSE", "LICENSE-EXCEPTION.md"]
 dependencies = [
-    "xdog-ai[openai]>=2.3.0",
-    "xdog-agent>=2.3.0",
-    "xdog-tui>=2.3.0",
+    "xdog-ai[openai]>=2.4.1",
+    "xdog-agent>=2.4.1",
+    "xdog-tui>=2.4.1",
     "pyyaml>=6.0",
     "click>=8.1.0",
     "pydantic>=2.0",

{xdog_coding-2.3.0 → xdog_coding-2.4.1}/src/xdog/coding/__init__.py

@@ -1,3 +1,3 @@
 """coding - Interactive coding agent CLI."""
 
-__version__ = "2.3.0"
+__version__ = "2.4.1"

{xdog_coding-2.3.0 → xdog_coding-2.4.1}/src/xdog/coding/config.py

@@ -26,7 +26,7 @@ from pydantic import BaseModel, Field
 
 MONOREPO_NAME = "xdog"
 APP_NAME = "coding"
-VERSION = "2.3.0"
+VERSION = "2.4.1"
 PROJECT_DIR_NAME = ".coding"
 ENV_OVERRIDE = "CODING_DIR"
 

{xdog_coding-2.3.0 → xdog_coding-2.4.1}/src/xdog/coding/core/agent_session.py

@@ -274,15 +274,8 @@ class AgentSession:
         try:
             if self._base_context_transform is not None:
                 messages = await self._base_context_transform(messages)
-            from xdog.agent.skills import render_skill_body
-            from xdog.coding.core.slash_commands import skill_manager
-            def transient_messages() -> list[UserMessage]:
-                manager = skill_manager()
-                return [UserMessage(content='## Active skill: ' + skill.name + '\n\n' + render_skill_body(skill))
-                    for slug in sorted(self._active_skills)
-                    if (skill := manager.load_skill(slug)) is not None and skill.expires_after_turn]
-            transient = await asyncio.to_thread(transient_messages) if self._active_skills else []
-            result = await self.extensions.transform([*transient, *messages])
+            # The SDK supplies run-owned turn skills before this transform.
+            result = await self.extensions.transform(messages)
             return result
         finally:
             await self._sync_extension_tools()
@@ -626,33 +619,11 @@ class AgentSession:
             self._expire_turn_scoped_skills()
 
     def _expire_turn_scoped_skills(self) -> None:
-        """Retire skills their author declared as lasting one turn.
-
-        Declared, not inferred. A timer cannot tell a one-shot procedure from a
-        guardrail, and "unused for N turns" is unmeasurable anyway — there is no
-        way to observe whether the model followed an instruction. Only the
-        author knows which kind they wrote, so only the author gets to say.
-        """
-        if not self._active_skills:
-            return
-        try:
-            from xdog.coding.core.slash_commands import skill_manager
-
-            manager = skill_manager()
-            expired = {
-                slug
-                for slug in self._active_skills
-                if (skill := manager.load_skill(slug)) is not None and skill.expires_after_turn
-            }
-        except Exception:
-            logger.debug("could not expire turn-scoped skills", exc_info=True)
-            return
-
-        if expired:
-            self._active_skills = self._active_skills - expired
-            self._push_skills()
+        """Mirror SDK retirement; preparation failures do not consume pending skills."""
+        retained = self._active_skills & frozenset(self.agent.active_skills)
+        if retained != self._active_skills:
+            self._active_skills = retained
             self._rebuild_system_prompt()
-            logger.debug("expired turn-scoped skills: %s", sorted(expired))
 
     def steer(self, message: str) -> None:
         """Queue a steering interrupt for the current turn."""

{xdog_coding-2.3.0 → xdog_coding-2.4.1}/src/xdog/coding/core/compaction/compaction.py

@@ -6,23 +6,19 @@ from typing import Any
 
 from xdog.agent import AgentMessage
 from xdog.agent.agent import Agent
-from xdog.ai.types import AssistantMessage, Context, TextContent, ToolCall, ToolResultMessage, UserMessage
+from xdog.agent.compaction import (
+    SUMMARIZE_SYSTEM_PROMPT as SUMMARIZE_SYSTEM_PROMPT,
+)
+from xdog.agent.compaction import (
+    conversation_text,
+    extract_text,
+    summary_context,
+)
+from xdog.ai.types import UserMessage
 from xdog.coding.core.compaction.utils import split_messages
 from xdog.coding.core.defaults import COMPACTION_TARGET_RATIO
 from xdog.coding.core.prompt_templates import COMPACTION_SUMMARY_TEMPLATE
 
-SUMMARIZE_SYSTEM_PROMPT = """\
-You are a conversation summarizer. You will receive a portion of a conversation \
-between a user and a coding assistant. Produce a concise summary that captures:
-
-1. What tasks were discussed and their current status.
-2. Key decisions made.
-3. Important code changes or file paths mentioned.
-4. Any outstanding issues or next steps.
-
-Be concise but ensure no critical context is lost. Output only the summary text.
-"""
-
 
 def prepare_index(messages: list[AgentMessage], agent: Agent, *, force: bool = False,
                   context_limit: int | None = None) -> int:
@@ -64,31 +60,11 @@ async def compact_messages(
     if not old_messages:
         return list(messages)
 
-    # Build text representation of old messages for summarization
-    text_parts: list[str] = []
-    for msg in old_messages:
-        if isinstance(msg, UserMessage):
-            text = msg.content if isinstance(msg.content, str) else _extract_text(msg)
-            if text:
-                text_parts.append(f"[USER]: {text}")
-        elif isinstance(msg, AssistantMessage):
-            text = _extract_text(msg)
-            calls = [f"[TOOL CALL {part.name}]: {part.arguments}" for part in msg.content
-                     if isinstance(part, ToolCall)]
-            if text or calls:
-                text_parts.append(f"[ASSISTANT]: {text}" + "\n" + "\n".join(calls))
-        elif isinstance(msg, ToolResultMessage):
-            text_parts.append(f"[TOOL RESULT {msg.tool_name}, error={msg.is_error}]: {_extract_text(msg)}")
-        else:
-            from xdog.agent.extensions.context_message import summary_text as context_summary_text
-            if custom_text := context_summary_text(msg):
-                text_parts.append('[EXTENSION CONTEXT]: ' + custom_text)
-
-    conversation_text = "\n\n".join(text_parts)
+    text = conversation_text(old_messages)
 
     # Use the agent's stream_fn to summarize
     summary = (summary_override if summary_override is not None
-               else await _summarize(conversation_text, agent, instructions))
+               else await _summarize(text, agent, instructions))
 
     # Build the compacted history
     summary_text = COMPACTION_SUMMARY_TEMPLATE.format(summary=summary)
@@ -98,25 +74,12 @@ async def compact_messages(
 
 
 def _extract_text(msg: Any) -> str:
-    """Extract concatenated text from a message's content parts."""
-    parts: list[str] = []
-    content = getattr(msg, "content", None)
-    if isinstance(content, str):
-        return content
-    if content is None:
-        return ""
-    for part in content:
-        if isinstance(part, TextContent):
-            parts.append(part.text)
-    return "\n".join(parts)
+    """Compatibility wrapper for the shared text projection."""
+    return extract_text(msg)
 
 
 async def _summarize(conversation_text: str, agent: Agent, instructions: str = "") -> str:
     """Use the selected session adapter, including extension/custom providers."""
     from xdog.agent.summarization import stream_summary
-    request = conversation_text
-    if instructions:
-        request += "\n\nUser's compaction focus (not a request to execute tools):\n" + instructions
     return await stream_summary(agent.stream_fn, agent.state.model,
-        Context(system_prompt=SUMMARIZE_SYSTEM_PROMPT, messages=(UserMessage(content=request),), tools=()),
-        agent.options)
+                                summary_context(conversation_text, instructions), agent.options)

xdog_coding-2.4.1/src/xdog/coding/core/compaction/utils.py

@@ -0,0 +1,13 @@
+"""Compatibility exports of Coding's original history estimates and splitter."""
+from xdog.agent.compaction import (
+    estimate_history_tokens as estimate_history_tokens,
+)
+from xdog.agent.compaction import (
+    estimate_message_tokens as estimate_message_tokens,
+)
+from xdog.agent.compaction import (
+    estimate_tokens as estimate_tokens,
+)
+from xdog.agent.compaction import (
+    split_messages as split_messages,
+)

{xdog_coding-2.3.0 → xdog_coding-2.4.1}/src/xdog/coding/modes/rpc/events.py

@@ -12,6 +12,9 @@ from xdog.agent import AgentEvent, AgentMessage
 from xdog.agent.events import (
     AgentEndEvent,
     AgentStartEvent,
+    CompactionEndEvent,
+    CompactionFailedEvent,
+    CompactionStartEvent,
     InputConsumedEvent,
     InputHandledEvent,
     InputRejectedEvent,
@@ -19,11 +22,13 @@ from xdog.agent.events import (
     MessageEndEvent,
     MessageStartEvent,
     MessageUpdateEvent,
+    SnapshotEvent,
     ToolExecutionEndEvent,
     ToolExecutionStartEvent,
     ToolExecutionUpdateEvent,
     TurnEndEvent,
     TurnStartEvent,
+    UsageEvent,
 )
 from xdog.ai.types import ImageContent, TextContent
 from xdog.coding.core.agent_session import AgentSession
@@ -80,7 +85,7 @@ class RpcEvents:
                 payload = {'event': event.type, 'data': {}, 'limited': True}
             if payload is not None:
                 if len(json.dumps(payload, ensure_ascii=True, allow_nan=False).encode()) > MAX_EVENT_BYTES // 2:
-                    payload = {'event': event.type, 'data': {}, 'limited': True}
+                    payload = {**payload, 'data': {}, 'limited': True}
                 with self._lock:
                     if self._pending >= 32:
                         self._limited = True
@@ -134,9 +139,52 @@ def _message(message: AgentMessage | None) -> dict[str, Any] | None:
     return value
 
 
+def _sdk_metadata(event: AgentEvent) -> dict[str, Any]:
+    """SDK identity is separate from the RPC session lease/delivery sequence.
+
+    Bound identity strings independently so payload-size fallback can retain
+    correlation without retaining oversized data or unbounded identifiers.
+    """
+    if (any(not isinstance(value, str) or len(value) > 256 for value in (event.session_id, event.run_id))
+            or type(event.sequence) is not int or event.sequence < 0):
+        raise ValueError('Invalid SDK event identity')
+    return {'session_id': safe_json(event.session_id), 'run_id': safe_json(event.run_id), 'sequence': event.sequence}
+
+
 def _payload(event: AgentEvent) -> dict[str, Any] | None:
     data: dict[str, Any]
-    if isinstance(event, ToolExecutionStartEvent):
+    if isinstance(event, (CompactionStartEvent, CompactionEndEvent, CompactionFailedEvent)):
+        if type(event.automatic) is not bool:
+            raise ValueError('Invalid SDK compaction metadata')
+    if isinstance(event, CompactionEndEvent) and (type(event.generation) is not int or event.generation < 0):
+        raise ValueError('Invalid SDK compaction generation')
+    if isinstance(event, UsageEvent):
+        # Do not recursively serialize SDK dataclasses or apply key-based token
+        # redaction to numeric token counters. Explicit numeric fields only.
+        counters = {key: getattr(event.usage, key) for key in
+                    ('input', 'output', 'cache_read', 'cache_write', 'total_tokens')}
+        cost = {key: getattr(event.usage.cost, key)
+                for key in ('input', 'output', 'cache_read', 'cache_write', 'total')}
+        if (any(type(value) is not int or value < 0 for value in counters.values())
+                or any(type(value) not in (int, float) or value < 0 for value in cost.values())
+                or event.source not in ('model', 'compaction') or not isinstance(event.model, str)):
+            raise ValueError('Invalid SDK usage event')
+        json.dumps(cost, allow_nan=False)
+        data = {'source': event.source, 'model': safe_json(event.model), 'usage': {**counters, 'cost': cost}}
+    elif isinstance(event, CompactionStartEvent):
+        data = {'automatic': event.automatic}
+    elif isinstance(event, CompactionEndEvent):
+        data = {'automatic': event.automatic, 'generation': event.generation,
+                'removed_message_count': len(event.removed_messages), 'summary_omitted': True}
+    elif isinstance(event, CompactionFailedEvent):
+        # Summary/error prose can contain arbitrary sensitive history, not merely
+        # recognizable credential patterns. Keep observations metadata-only.
+        data = {'automatic': event.automatic, 'error_omitted': True}
+    elif isinstance(event, SnapshotEvent):
+        # Do not even parse snapshot_json/access snapshot: opt-in transient
+        # events grant neither canonical history nor persistence/credential data.
+        data = {'snapshot_omitted': True}
+    elif isinstance(event, ToolExecutionStartEvent):
         data = {'call_id': event.tool_call_id, 'tool': event.tool_name, 'arguments': safe_json(event.args)}
     elif isinstance(event, ToolExecutionUpdateEvent):
         result = event.partial_result
@@ -178,4 +226,4 @@ def _payload(event: AgentEvent) -> dict[str, Any] | None:
         data = {}  # Never copy the whole canonical history into an agent-end event.
     else:
         return None
-    return {'event': event.type, 'data': data}
+    return {'event': event.type, 'data': data, 'sdk': _sdk_metadata(event)}

xdog_coding-2.4.1/tests/test_mcp_task_ci_ordering.py

@@ -0,0 +1,69 @@
+"""Controlled CI schedules: host acknowledgement is not UI settlement."""
+from __future__ import annotations
+
+import asyncio
+import json
+
+from xdog.claw.channels.tui.tui_app import ChatApp
+from xdog.claw.core.runtime.sampling_protocol import SamplingConnection
+
+from packages.coding.tests.test_mcp_task_hosts import (
+    test_native_required_tools_not_selected_refuses_before_model_or_output_review as run_required_tools,
+)
+
+
+async def test_required_tool_refusal_waits_for_delayed_socket_close_event(tmp_path, monkeypatch):
+    """Drive the old GitHub failure without sleeps or changing runtime policy.
+
+    Deliver the terminal error to the peer but withhold only the UI close event.
+    The input form is already gone; busy must stay true until the actual close
+    observation is delivered. The host integration test must wait for that fact.
+    """
+    held = []
+    panels = []
+    published = SamplingConnection._publish
+    opened = ChatApp._open_mcp
+
+    def defer_closed(connection, binding, view, event, models):
+        if event['type'] == 'sampling_closed':
+            held.append((connection, binding, view, event, models))
+        else:
+            published(connection, binding, view, event, models)
+
+    def capture_panel(ui):
+        opened(ui)
+        panels.append(ui._mcp_panel)
+
+    monkeypatch.setattr(SamplingConnection, '_publish', defer_closed)
+    monkeypatch.setattr(ChatApp, '_open_mcp', capture_panel)
+    operation = asyncio.create_task(run_required_tools(tmp_path, 'claw'))
+
+    def release():
+        while held:
+            published(*held.pop(0))
+
+    try:
+        async with asyncio.timeout(6):
+            while not held:
+                if operation.done():
+                    operation.result()
+                    raise AssertionError('No terminal close event was produced')
+                await asyncio.sleep(0)
+            # This is the original test's failure window: the MCP result is
+            # available while the socket UI still has not received its close.
+            log = tmp_path / 'task-frames'
+            while not log.exists() or not any(
+                row.get('id') == 'retrieve' for row in (json.loads(line) for line in log.read_text().splitlines())
+            ):
+                await asyncio.sleep(0)
+        assert panels[-1].sampling_review is None
+        assert panels[-1]._busy
+        assert not operation.done(), 'The host test mistook form removal for a settled request'
+        release()
+        await asyncio.wait_for(operation, 6)
+        assert not panels[-1]._busy
+    finally:
+        release()
+        if not operation.done():
+            operation.cancel()
+        await asyncio.gather(operation, return_exceptions=True)

{xdog_coding-2.3.0 → xdog_coding-2.4.1}/tests/test_mcp_task_hosts.py

@@ -310,7 +310,10 @@ async def test_native_required_tools_not_selected_refuses_before_model_or_output
         first.handle_input(KeyEvent('enter'))
         await wait(lambda: any(row.get('id') == 'retrieve' for row in frames()))
         assert next(row for row in frames() if row.get('id') == 'retrieve')['error']['code'] == -32000
-        await wait(lambda: panel.sampling_review is None)
+        # Answer admission removes the input form immediately, before the task
+        # worker and socket delivery have settled. Only the terminal close event
+        # clears busy; a transport error reply is not a UI settlement receipt.
+        await wait(lambda: panel.sampling_review is None and not panel._busy)
         assert not adapter.calls and not session.agent.messages and not panel._busy
         assert ui._editor.get_text() == 'PARENT REQUIRED TOOL DRAFT'
         if kind == 'coding':

{xdog_coding-2.3.0 → xdog_coding-2.4.1}/tests/test_mcp_task_terminal.py

@@ -26,12 +26,13 @@ def test_physical_native_task_full_review_result_transport_resize_and_termios(tm
     owned, errors = {}, []
     thread = None
     terminal = Terminal(tmp_path)
+    cancel_gate = tmp_path / "allow-peer-cancel"
     if kind == 'coding':
         configs, log = task_config(tmp_path, family)
         if end == 'expire':
             configs['owned']['args'].append('2000')
         elif end == 'peer_cancel':
-            configs['owned']['args'].extend(['60000', 'cancel'])
+            configs['owned']['args'].extend(['60000', 'cancel', str(cancel_gate)])
         home = tmp_path / 'home'
         home.mkdir(mode=0o700)
         (home / 'settings.json').write_text(json.dumps({'mcp_servers': configs}))
@@ -50,7 +51,7 @@ def test_physical_native_task_full_review_result_transport_resize_and_termios(tm
                         from dataclasses import replace
                         original = runtime.mcp.configs['owned']
                         runtime.mcp.configs['owned'] = replace(original,
-                            command=(*original.command, '60000', 'cancel'))
+                            command=(*original.command, '60000', 'cancel', str(cancel_gate)))
                     owned.update(config=config, runtime=runtime, session=session, adapter=adapter, log=log)
                     ready.set()
                     while not stop.is_set():
@@ -92,7 +93,13 @@ def test_physical_native_task_full_review_result_transport_resize_and_termios(tm
         while not any(row.get('id') == 'create' for row in frames()) and time.monotonic() < deadline:
             time.sleep(.03)
         created = next(row for row in frames() if row.get('id') == 'create')['result']['task']
-        assert 'PRIVATE' not in str(created) and not any(row.get('id') == 'retrieve' for row in frames())
+        assert 'PRIVATE' not in str(created)
+        assert not any(row.get('id') == 'retrieve' for row in frames())
+        if end == 'peer_cancel':
+            # Keep the pre-cancel withholding assertion above, then explicitly
+            # admit cancellation. A terminal error response is now legitimate;
+            # successful/private result delivery is never legitimate.
+            cancel_gate.touch()
         initial = next(row for row in frames() if row.get('method') == 'initialize')
         assert initial['params']['capabilities']['tasks']['requests'] == {
             family: {'createMessage' if family == 'sampling' else 'create': {}}}
@@ -112,6 +119,12 @@ def test_physical_native_task_full_review_result_transport_resize_and_termios(tm
                 cancelled = next(row for row in frames() if row.get('id') == 'peer-cancel')
                 assert cancelled['result']['status'] == 'cancelled'
                 assert cancelled['result']['taskId'] == created['taskId']
+                deadline = time.monotonic() + 5
+                while not any(row.get('id') == 'retrieve' for row in frames()) and time.monotonic() < deadline:
+                    time.sleep(.03)
+                denied = next(row for row in frames() if row.get('id') == 'retrieve')
+                assert denied['error']['code'] == -32000 and 'result' not in denied
+                assert 'PRIVATE' not in json.dumps(frames())
             terminal.keys('Escape')
             terminal.wait_hidden('MCP servers')
             terminal.wait_cursor(True)
@@ -173,6 +186,7 @@ def test_physical_native_task_full_review_result_transport_resize_and_termios(tm
         else:
             no_model()
     finally:
+        cancel_gate.touch()  # Release our own peer if an earlier assertion failed.
         terminal.call('kill-server')
         stop.set()
         if thread is not None:

{xdog_coding-2.3.0 → xdog_coding-2.4.1}/tests/test_rpc_child_terminal.py

@@ -159,6 +159,15 @@ def test_actual_cli_child_terminal_transform_receipts_never_submit_or_authorize_
         else:
             raise AssertionError('Child terminal registry never became active')
         peer.caps = caps
+        # Registry activity admits terminal hooks, not the model generator. Quit
+        # can still cancel input/context/checkpoint work before its first step;
+        # only an entered model owns the fixture's producer cleanup marker.
+        deadline = time.monotonic() + 6
+        while not peer.marker.exists() and time.monotonic() < deadline:
+            assert peer.process.poll() is None, 'CLI exited before child model admission'
+            time.sleep(0.01)
+        assert peer.marker.exists(), 'Child model generator never entered'
+        assert not peer.marker.with_suffix('.settled').exists()
         for key, kind, data, expected in (('keys', 'key', 'ab', '[a][b]'),
                                          ('paste', 'paste', '开发🙂\nline', '[开发🙂\nline]'),
                                          ('consume', 'paste', 'drop', None)):

{xdog_coding-2.3.0 → xdog_coding-2.4.1}/tests/test_rpc_events.py

@@ -8,10 +8,15 @@ import pytest
 from xdog.agent.core import AgentToolResult
 from xdog.agent.events import (
     AgentEndEvent,
+    CompactionEndEvent,
+    CompactionFailedEvent,
+    CompactionStartEvent,
     MessageUpdateEvent,
+    SnapshotEvent,
     ToolExecutionEndEvent,
     ToolExecutionStartEvent,
     ToolExecutionUpdateEvent,
+    UsageEvent,
 )
 from xdog.ai.types import AssistantMessage, ImageContent, TextContent, ThinkingContent
 from xdog.coding.modes.rpc.events import MAX_EVENT_BYTES, RpcEvents
@@ -212,7 +217,7 @@ def test_every_declared_agent_event_has_a_named_transient_projection_with_safe_m
         payload = _payload(event)
         assert payload is not None and payload['event'] == event.type
         projected.append(payload)
-    assert len(projected) == 14
+    assert len(projected) == len(get_args(AgentEvent))
     encoded = json.dumps(projected)
     assert 'PRIVATE' not in encoded and 'PUBLIC' in encoded and '123' in encoded
     update = next(row for row in projected if row['event'] == 'message_update')
@@ -224,3 +229,99 @@ def test_every_declared_agent_event_has_a_named_transient_projection_with_safe_m
     assert 'PRIVATE' not in json.dumps(final)
     tool_message = ToolResultMessage(tool_call_id='call', tool_name='tool', content=(picture,))
     assert 'PRIVATE-BINARY' not in json.dumps(_payload(MessageEndEvent(message=tool_message)))
+
+
+def test_sdk_observation_projections_have_exact_safe_fields_and_separate_identity():
+    from xdog.ai.types import CostBreakdown, Usage, UserMessage
+    from xdog.coding.modes.rpc.events import _payload
+
+    metadata = {'session_id': 'sdk-session', 'run_id': 'sdk-run', 'sequence': 41}
+    usage = Usage(input=10, output=3, cache_read=2, cache_write=1, total_tokens=16,
+                  cost=CostBreakdown(input=.1, output=.2, cache_read=.03, cache_write=.04, total=.37))
+    for source in ('model', 'compaction'):
+        assert _payload(UsageEvent(usage=usage, model='offline/model', source=source, **metadata)) == {
+            'event': 'usage', 'sdk': metadata,
+            'data': {'source': source, 'model': 'offline/model', 'usage': {
+                'input': 10, 'output': 3, 'cache_read': 2, 'cache_write': 1, 'total_tokens': 16,
+                'cost': {'input': .1, 'output': .2, 'cache_read': .03, 'cache_write': .04, 'total': .37},
+            }},
+        }
+    secret = 'ARBITRARY-PRIVATE-CONTENT without a recognizable credential prefix'
+    cases = (
+        (CompactionStartEvent(automatic=True, **metadata), {'automatic': True}),
+        (CompactionEndEvent(automatic=True, generation=2, summary=secret,
+                            removed_messages=(UserMessage(content=secret),), **metadata),
+         {'automatic': True, 'generation': 2, 'removed_message_count': 1, 'summary_omitted': True}),
+        (CompactionFailedEvent(error=secret, **metadata), {'automatic': False, 'error_omitted': True}),
+        (SnapshotEvent(snapshot_json=json.dumps({'messages': secret, 'api_key': secret}), **metadata),
+         {'snapshot_omitted': True}),
+        (SnapshotEvent(snapshot_json='NOT JSON ' + secret, **metadata), {'snapshot_omitted': True}),
+    )
+    for event, expected in cases:
+        payload = _payload(event)
+        assert payload == {'event': event.type, 'sdk': metadata, 'data': expected}
+        assert 'PRIVATE' not in json.dumps(payload)
+        assert all(key not in payload['data'] for key in ('removed_messages', 'snapshot_json', 'summary', 'error'))
+    redacted = _payload(UsageEvent(model='token=PRIVATE-MODEL', session_id='api_key=PRIVATE-SESSION',
+                                  run_id='password=PRIVATE-RUN', sequence=1))
+    assert 'PRIVATE' not in json.dumps(redacted)
+
+
+async def test_sdk_metadata_preserves_rpc_lease_sequence_and_snapshot_privacy(tmp_path):
+    from xdog.ai.types import Usage, UserMessage
+
+    session, _, calls, nav, sources, events = setup(tmp_path)
+    stream = RpcEvents(session, nav, events.append)
+    try:
+        # An observation before negotiation advances only the SDK counter.
+        session.agent._emit(AgentEndEvent())
+        stream.negotiate({'transient_events': 1})
+        session.agent._emit(AgentEndEvent())
+        await asyncio.sleep(0)
+        sdk_events = [
+            session.agent._emit(UsageEvent(usage=Usage(input=17), model='offline/model')),
+            session.agent._emit(CompactionEndEvent(summary='PRIVATE-SUMMARY',
+                removed_messages=(UserMessage(content='PRIVATE-HISTORY'),), generation=3)),
+            session.agent._emit(SnapshotEvent(snapshot_json='PRIVATE-INVALID-JSON')),
+        ]
+        await asyncio.sleep(0)
+        rows = [row for row in events if row['type'] == 'transient_event'][1:]
+        assert len(rows) == len(sdk_events) == 3
+        for row, sdk_event in zip(rows, sdk_events, strict=True):
+            assert row['session_id'] == session.session_id
+            assert row['event_owner'] == stream.lease and row['retained'] is False
+            assert row['sdk'] == {'session_id': sdk_event.session_id, 'run_id': sdk_event.run_id,
+                                  'sequence': sdk_event.sequence}
+        assert [row['sequence'] for row in rows] == [2, 3, 4]
+        assert [row['sdk']['sequence'] for row in rows] == [3, 4, 5]
+        assert 'PRIVATE' not in json.dumps(rows)
+        assert not calls and session.permissions.mode == 'deny'
+    finally:
+        stream.close()
+        await close(session, nav, sources)
+
+
+async def test_oversized_usage_keeps_sdk_correlation_when_data_is_limited(tmp_path):
+    session, _, _, nav, sources, events = setup(tmp_path)
+    stream = RpcEvents(session, nav, events.append)
+    try:
+        stream.negotiate({'transient_events': 1})
+        sdk_event = session.agent._emit(UsageEvent(model='x' * MAX_EVENT_BYTES))
+        await asyncio.sleep(0)
+        row = events[-1]
+        assert row['event'] == 'usage' and row['limited'] is True and row['data'] == {}
+        assert row['sdk'] == {'session_id': sdk_event.session_id, 'run_id': sdk_event.run_id,
+                              'sequence': sdk_event.sequence}
+        assert len(json.dumps(row).encode()) <= MAX_EVENT_BYTES
+    finally:
+        stream.close()
+        await close(session, nav, sources)
+
+
+@pytest.mark.parametrize('value', ['PRIVATE-INVALID-COUNTER', True, -1])
+def test_usage_projection_rejects_non_numeric_or_negative_counters(value):
+    from xdog.ai.types import Usage
+    from xdog.coding.modes.rpc.events import _payload
+
+    with pytest.raises(ValueError, match='Invalid SDK usage event'):
+        _payload(UsageEvent(usage=Usage(input=value)))