@agentsdock/server 1.0.7-beta.5

package/server/claude_goals.py

@@ -0,0 +1,245 @@
+"""Read native Claude goal attachments without interpreting conversation text.
+
+Call refresh from the existing provider-history/activity path. This module owns
+no watcher, timer, provider command, or transcript mutation.
+"""
+from __future__ import annotations
+
+from collections import deque, OrderedDict
+from datetime import datetime
+import json
+import os
+import re
+from pathlib import Path
+from typing import Any
+from uuid import UUID
+
+
+MAX_GOAL_RECORD_BYTES = 128 * 1024
+MAX_GOAL_SCAN_BYTES = 4 * 1024 * 1024
+
+
+def is_claude_synthetic_no_response(event: Any) -> bool:
+    if not isinstance(event, dict) or event.get("type") != "assistant" or event.get("isSidechain") is True:
+        return False
+    message = event.get("message")
+    return bool(isinstance(message, dict) and message.get("model") == "<synthetic>"
+                and message.get("role") == "assistant"
+                and message.get("content") == [{"type": "text", "text": "No response requested."}]
+                and isinstance(message.get("usage"), dict)
+                and message["usage"].get("output_tokens") == 0)
+
+
+class ClaudeGoalHistoryNormalizer:
+    """Normalize only commands linked to native goal attachments, never quotes."""
+    _command = re.compile(r"\A<command-name>/goal</command-name>\s*<command-message>goal</command-message>\s*<command-args>(.*)</command-args>\Z", re.DOTALL)
+
+    def __init__(self):
+        self._parents: OrderedDict[str, dict] = OrderedDict()
+
+    def seed(self, path: Path, offset: int) -> None:
+        if offset <= 0:
+            return
+        try:
+            with path.open("rb") as stream:
+                start = max(0, offset - 65536)
+                stream.seek(start)
+                region = stream.read(offset - start)
+        except OSError:
+            return
+        if start:
+            region = region.partition(b"\n")[2]
+        for line in region.splitlines():
+            try:
+                self.consume(json.loads(line))
+            except (ValueError, RecursionError):
+                continue
+
+    def consume(self, event: Any) -> Any:
+        if not isinstance(event, dict) or event.get("isSidechain") is True:
+            return event
+        parent = self._parents.get(event.get("parentUuid"))
+        same_session = bool(parent and parent.get("sessionId") == event.get("sessionId"))
+        message = event.get("message")
+        content = message.get("content") if isinstance(message, dict) else None
+        attachment = event.get("attachment")
+        if (isinstance(attachment, dict) and attachment.get("type") == "goal_status"
+                and attachment.get("sentinel") is True and type(attachment.get("met")) is bool):
+            self._remember(event)
+        elif (same_session and event.get("type") == "user" and event.get("isMeta") is True
+              and isinstance(content, str) and content.startswith("<local-command-caveat>")
+              and parent.get("attachment", {}).get("met") is True):
+            self._remember({**event, "attachment": parent["attachment"]})
+        elif (same_session and event.get("type") == "user" and isinstance(message, dict)
+              and message.get("role") == "user" and isinstance(content, str)):
+            match = self._command.fullmatch(content)
+            native = parent.get("attachment", {})
+            if match and ((native.get("met") is False and match[1] == native.get("condition"))
+                          or (native.get("met") is True and match[1] == "clear"
+                              and parent.get("isMeta") is True
+                              and parent.get("promptId") == event.get("promptId"))):
+                return {**event, "message": {**message, "content": "/goal " + match[1]}}
+        return event
+
+    def _remember(self, event: dict) -> None:
+        identity = event.get("uuid")
+        if not isinstance(identity, str) or not isinstance(event.get("sessionId"), str):
+            return
+        native = event.get("attachment", {})
+        condition = native.get("condition")
+        if not isinstance(condition, str) or len(condition) > 16_384:
+            return
+        self._parents[identity] = {key: event.get(key) for key in ("sessionId", "promptId", "isMeta")}
+        self._parents[identity]["attachment"] = {
+            "met": native.get("met"), "condition": condition,
+        }
+        while len(self._parents) > 32:
+            self._parents.popitem(last=False)
+
+
+def _timestamp_ms(value: Any) -> int | None:
+    if not isinstance(value, str) or len(value) > 64:
+        return None
+    try:
+        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+        return int(parsed.timestamp() * 1000) if parsed.tzinfo else None
+    except (ValueError, OverflowError, OSError):
+        return None
+
+
+def _counter(value: Any) -> int | None:
+    return value if type(value) is int and 0 <= value <= 2**53 - 1 else None
+
+
+class ClaudeGoalProjection:
+    """One provider session's latest goal and bounded incremental file cursor.
+
+    A native set sentinel establishes the goal. Evaluator and clear records
+    update that exact condition; unrelated sessions/sidechains cannot establish
+    or finish it. A fork starts empty until its own native set evidence arrives.
+    No failure, pause, or success is inferred from a result/assistant message.
+    """
+
+    def __init__(self, provider_session_id: str):
+        self.reset(provider_session_id)
+
+    def reset(self, provider_session_id: str) -> None:
+        self.provider_session_id = str(provider_session_id)
+        self.goal: dict[str, Any] | None = None
+        self.offset = 0
+        self.caught_up = False
+        self._identity: tuple[str, int, int] | None = None
+        self._tail = b""
+        self._anchor = b""
+        self._discard_line = False
+        self._seen: deque[str] = deque(maxlen=256)
+        self._last_timestamp = -1
+
+    def consume(self, event: Any) -> bool:
+        """Fold one native JSONL record; return whether visible goal changed."""
+        if not isinstance(event, dict) or (
+            event.get("type") != "attachment"
+            or event.get("sessionId") != self.provider_session_id
+            or event.get("isSidechain") is not False
+        ):
+            return False
+        attachment = event.get("attachment")
+        if not isinstance(attachment, dict) or attachment.get("type") != "goal_status":
+            return False
+        event_id = event.get("uuid")
+        if not isinstance(event_id, str) or len(event_id) != 36:
+            return False
+        try:
+            UUID(event_id)
+        except ValueError:
+            return False
+        timestamp = _timestamp_ms(event.get("timestamp"))
+        condition = attachment.get("condition")
+        met = attachment.get("met")
+        sentinel = attachment.get("sentinel", False)
+        if (
+            timestamp is None or timestamp < self._last_timestamp
+            or event_id in self._seen
+            or not isinstance(condition, str) or not condition.strip()
+            or len(condition) > 16_384
+            or type(met) is not bool or type(sentinel) is not bool
+        ):
+            return False
+        previous = self.goal
+        if sentinel and not met:
+            goal = {"condition": condition, "status": "active", "set_at": timestamp}
+        else:
+            if previous is None or previous["condition"] != condition:
+                return False
+            if not sentinel and previous["status"] != "active":
+                return False
+            goal = dict(previous)
+            goal["status"] = "cleared" if sentinel else "achieved" if met else "active"
+            if sentinel:
+                for field in ("iterations", "duration_ms", "tokens"):
+                    goal.pop(field, None)
+            if not sentinel:
+                reason = attachment.get("reason")
+                if isinstance(reason, str) and reason:
+                    goal["last_reason"] = reason[:8192]
+                # Resuming the native session can reset its counters. The
+                # number of historical evaluator rows is not a native total.
+                for native, public in (("iterations", "iterations"), ("durationMs", "duration_ms"), ("tokens", "tokens")):
+                    value = _counter(attachment.get(native))
+                    if value is not None:
+                        goal[public] = value
+                    else:
+                        goal.pop(public, None)
+        self._seen.append(event_id)
+        self._last_timestamp = timestamp
+        self.goal = goal
+        return goal != previous
+
+    def refresh(
+        self, path: str | Path, *, provider_session_id: str | None = None,
+        max_bytes: int = MAX_GOAL_SCAN_BYTES,
+    ) -> bool:
+        """Read at most max_bytes; later activity can continue an unfinished scan.
+
+        Partial lines are retained, oversized lines skipped, and replacement,
+        truncation or provider changes reset both projection and cursor. A
+        temporarily missing/unreadable file keeps the last observed native state.
+        The caller should run file I/O off the server's event loop.
+        """
+        previous = self.goal
+        if provider_session_id is not None and provider_session_id != self.provider_session_id:
+            self.reset(provider_session_id)
+        budget = max(1, min(int(max_bytes), MAX_GOAL_SCAN_BYTES))
+        try:
+            with Path(path).open("rb") as stream:
+                stat = os.fstat(stream.fileno())
+                identity = (str(Path(path).absolute()), stat.st_dev, stat.st_ino)
+                stream.seek(max(0, self.offset - len(self._anchor)))
+                anchor_matches = stream.read(len(self._anchor)) == self._anchor
+                if self._identity != identity or stat.st_size < self.offset or not anchor_matches:
+                    self.reset(self.provider_session_id)
+                    self._identity = identity
+                stream.seek(self.offset)
+                chunk = stream.read(budget)
+                self.offset += len(chunk)
+                self._anchor = (self._anchor + chunk)[-64:]
+                self.caught_up = self.offset >= stat.st_size
+        except OSError:
+            self.caught_up = False
+            return previous != self.goal
+        lines = (self._tail + chunk).split(b"\n")
+        self._tail = lines.pop()
+        for line in lines:
+            if self._discard_line:
+                self._discard_line = False
+                continue
+            if len(line) > MAX_GOAL_RECORD_BYTES or b'"goal_status"' not in line:
+                continue
+            try:
+                self.consume(json.loads(line))
+            except (ValueError, RecursionError):
+                continue
+        if len(self._tail) > MAX_GOAL_RECORD_BYTES:
+            self._tail = b""
+            self._discard_line = True
+        return previous != self.goal

package/server/claude_history_provenance.py

@@ -0,0 +1,137 @@
+"""Pure, bounded Claude source-lineage classification. Never edits transcripts.
+
+The marker's wording is not evidence of a human Stop action. A synthetic user
+record must belong to an already established prompt, not begin a new prompt.
+Only source identifiers are carried between byte-cursor reads; never chat text.
+"""
+from __future__ import annotations
+
+from datetime import datetime
+import re
+
+
+INTERRUPTION_MARKERS = frozenset({
+    "[Request interrupted by user]",
+    "[Request interrupted by user for tool use]",
+})
+_UUID = re.compile(r"[0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}\Z")
+_TIME = re.compile(r"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)\Z")
+_MAX_BRANCH_EVENTS = 128
+
+
+def _uuid(value) -> str | None:
+    return value if isinstance(value, str) and _UUID.fullmatch(value) else None
+
+
+def _timestamp(value) -> str | None:
+    if not isinstance(value, str) or not _TIME.fullmatch(value):
+        return None
+    try:
+        return value if datetime.fromisoformat(value.replace("Z", "+00:00")).tzinfo else None
+    except ValueError:
+        return None
+
+
+def normalize_claude_interruption_context(value, provider_session_id=None) -> dict:
+    """Allowlist a tiny initialized cursor state, including conservative empties."""
+    empty = {"version": 1}
+    if not isinstance(value, dict) or value.get("version") != 1:
+        return empty
+    keys = ("session_id", "prompt_id", "anchor_event_id", "last_event_id")
+    if any(not _uuid(value.get(key)) for key in keys):
+        return empty
+    if provider_session_id and value["session_id"] != provider_session_id:
+        return empty
+    context = {"version": 1, **{key: value[key] for key in keys}}
+    branch_ids = value.get("branch_event_ids")
+    if branch_ids is not None:
+        if (not isinstance(branch_ids, list) or not 1 <= len(branch_ids) <= _MAX_BRANCH_EVENTS
+                or any(not _uuid(item) for item in branch_ids)
+                or context["last_event_id"] not in branch_ids):
+            return empty
+        context["branch_event_ids"] = list(dict.fromkeys(branch_ids))
+    return context
+
+
+class ClaudeInterruptionTracker:
+    def __init__(self, initial_context=None):
+        self._context = normalize_claude_interruption_context(initial_context)
+
+    def export_context(self) -> dict:
+        return normalize_claude_interruption_context(self._context)
+
+    def consume(self, event) -> dict | None:
+        if not isinstance(event, dict):
+            self._context = {"version": 1}
+            return None
+        if event.get("isSidechain") is True:
+            return None
+        event_id = _uuid(event.get("uuid"))
+        # Non-message queue bookkeeping has no UUID and is outside the lineage.
+        if event_id is None:
+            if not isinstance(event.get("type"), str) or event.get("type") in ("user", "assistant", "attachment"):
+                self._context = {"version": 1}
+            return None
+        session_id = _uuid(event.get("sessionId"))
+        parent_id = _uuid(event.get("parentUuid"))
+        prompt_id = _uuid(event.get("promptId"))
+        timestamp = _timestamp(event.get("timestamp"))
+        message = event.get("message")
+        content = message.get("content") if isinstance(message, dict) else None
+        blocks = content if isinstance(content, list) else []
+        marker = (
+            event.get("type") == "user"
+            and isinstance(message, dict) and message.get("role") == "user"
+            and len(blocks) == 1 and isinstance(blocks[0], dict)
+            and blocks[0].get("type") == "text"
+            and isinstance(blocks[0].get("text"), str)
+            and blocks[0]["text"] in INTERRUPTION_MARKERS
+        )
+        context = self._context
+        # Parallel tool results can be siblings of the same assistant record.
+        # Keep their proven parents across incremental cursor reads; immediate
+        # adjacency alone is not Claude's transcript ancestry contract.
+        branch_ids = context.get("branch_event_ids", [context.get("last_event_id")])
+        continued = (
+            session_id is not None and session_id == context.get("session_id")
+            and parent_id is not None and parent_id in branch_ids
+            and (prompt_id is None or prompt_id == context.get("prompt_id"))
+        )
+        origin = None
+        if marker and session_id and timestamp and (
+            event.get("isMeta") is True
+            or (continued and prompt_id is not None and prompt_id == context.get("prompt_id")
+                and event_id != context.get("anchor_event_id")
+                and parent_id != context.get("anchor_event_id"))
+        ):
+            origin = {
+                "provider": "claude", "kind": "interruption", "cause": "unknown",
+                "event_id": event_id, "session_id": session_id, "timestamp": timestamp,
+            }
+            if parent_id:
+                origin["parent_event_id"] = parent_id
+            if prompt_id:
+                origin["prompt_id"] = prompt_id
+
+        has_text = isinstance(content, str) and bool(content.strip()) or any(
+            isinstance(block, dict) and block.get("type") == "text"
+            and isinstance(block.get("text"), str) and bool(block["text"].strip())
+            for block in blocks
+        )
+        tool_result = any(isinstance(block, dict) and block.get("type") == "tool_result" for block in blocks)
+        real_prompt = (
+            event.get("type") == "user" and isinstance(message, dict)
+            and message.get("role") == "user" and has_text and not tool_result
+            and not marker and event.get("isMeta") is not True
+            and session_id and prompt_id and timestamp
+        )
+        if real_prompt:
+            self._context = {"version": 1, "session_id": session_id, "prompt_id": prompt_id,
+                             "anchor_event_id": event_id, "last_event_id": event_id,
+                             "branch_event_ids": [event_id]}
+        elif continued:
+            self._context = {**context, "last_event_id": event_id,
+                             "branch_event_ids": [*branch_ids, event_id][-_MAX_BRANCH_EVENTS:]}
+        else:
+            self._context = {"version": 1}
+        return origin