iCode-TUI 0.29.1__py3-none-any.whl

chrys/service/analytics/_context_evidence.py

@@ -0,0 +1,357 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Verified context evidence: replayed revision memberships and compaction consumption.
+
+Revision membership is rebuilt from checkpoint/delta records and accepted only
+when the replay is consistent (valid occurrences, matching item count) and any
+declared membership hash verifies. Phase-4 compaction consumption names the
+items a compaction run folded and the already-reserved successor exchange whose
+request that run compacted. This module proves membership only;
+``_turn_graph`` decides which causal edges that evidence supports.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from threading import Event
+from typing import cast
+
+from chrys.foundation.trajectory.ids import is_valid_analytics_id
+from chrys.foundation.trajectory.revisions import MembershipRef, membership_hash
+from chrys.service.analytics._facts import (
+    _active,
+    _Endpoint,
+    _Intermediate,
+    _payload_bool,
+    _payload_int,
+    _payload_str,
+    _RevisionEntry,
+    _Segment,
+)
+from chrys.service.analytics._timeline import _endpoint_in_coverage_runtime, _ResolvedNode
+from chrys.service.analytics.reader import raise_if_cancelled as _check_cancelled
+
+
+@dataclass(frozen=True, slots=True)
+class _RevisionResolution:
+    memberships: dict[str, tuple[str, ...]]
+    endpoints: dict[str, _Endpoint]
+    errors: dict[str, tuple[str, ...]]
+    side_call_empty_shell_revisions: tuple[str, ...]
+    # Replayed and hash-verified, but the producer reported items it could not
+    # name: membership is a lower bound, good for positive claims only.
+    unidentified_membership_revision_count: int = 0
+
+
+@dataclass(frozen=True, slots=True)
+class _Phase4Consumption:
+    item_ids: frozenset[str]
+    next_exchange_operation_id: str
+
+
+@dataclass(frozen=True, slots=True)
+class _CompactionConsumptionResolution:
+    by_run: dict[str, _Phase4Consumption]
+    exact: bool
+
+
+def _revision_memberships(
+    intermediate: _Intermediate,
+    inactive_ranges: tuple[tuple[int, int], ...],
+    *,
+    fingerprint_key: bytes | None,
+    cancel_event: Event | None,
+) -> _RevisionResolution:
+    ordered_memberships: dict[str, tuple[MembershipRef, ...]] = {}
+    endpoints: dict[str, _Endpoint] = {}
+    errors: dict[str, tuple[str, ...]] = {}
+    side_call_empty_shell_revisions: list[str] = []
+    unidentified_membership_revisions = 0
+    definitions = {
+        revision_id: [endpoint for endpoint in candidates if _active(endpoint.sequence, inactive_ranges)]
+        for revision_id, candidates in intermediate.context_revisions.items()
+    }
+    for revision_id, candidates in definitions.items():
+        _check_cancelled(cancel_event)
+        if len(candidates) > 1:
+            errors[revision_id] = (f"context revision {revision_id} is defined more than once",)
+        elif candidates:
+            endpoints[revision_id] = candidates[0]
+    for revision_id, endpoint in sorted(endpoints.items(), key=lambda item: item[1].sequence):
+        _check_cancelled(cancel_event)
+        if revision_id in errors:
+            continue
+        revision_errors: list[str] = []
+        membership: tuple[MembershipRef, ...] | None = None
+        entries = None
+        if not _endpoint_in_coverage_runtime(intermediate, endpoint, inactive_ranges):
+            revision_errors.append(f"context revision {revision_id} falls outside coverage or after runtime closure")
+        else:
+            entries = _segmented_revision_entries(intermediate, endpoint, inactive_ranges, cancel_event=cancel_event)
+        if entries is None:
+            revision_errors.append(f"context revision {revision_id} has invalid segmented membership")
+        elif _payload_bool(endpoint.payload, "is_checkpoint"):
+            membership = _replay_checkpoint(entries)
+            if membership is None:
+                revision_errors.append(f"context revision {revision_id} has invalid checkpoint membership")
+        else:
+            parent_id = _payload_str(endpoint.payload, "parent_revision_id")
+            parent = endpoints.get(parent_id or "")
+            parent_membership = ordered_memberships.get(parent_id or "")
+            if (
+                parent_id is None
+                or parent is None
+                or parent_membership is None
+                or parent.sequence >= endpoint.sequence
+                or parent.actor_id is None
+                or parent.actor_id != endpoint.actor_id
+                or parent.runtime_id != endpoint.runtime_id
+                or parent.branch_id != endpoint.branch_id
+            ):
+                revision_errors.append(f"context revision {revision_id} has no valid same-actor/runtime parent")
+                membership = None
+            else:
+                membership = _replay_delta(parent_membership, entries)
+                if membership is None:
+                    revision_errors.append(f"context revision {revision_id} has an invalid delta replay")
+        if entries is not None and membership is not None:
+            item_count = _payload_int(endpoint.payload, "item_count")
+            unidentified = _payload_int(endpoint.payload, "unidentified_item_count")
+            if item_count is None or item_count != len(membership):
+                revision_errors.append(f"context revision {revision_id} item_count does not match replayed membership")
+            if unidentified is None or unidentified < 0:
+                revision_errors.append(f"context revision {revision_id} has an invalid unidentified item count")
+            elif unidentified and endpoint.side_call and item_count == 0:
+                # The known empty-shell shape of a side call: nothing named,
+                # nothing to replay; its volume travels through exchange usage.
+                side_call_empty_shell_revisions.append(revision_id)
+            elif unidentified:
+                # The named items replay and verify; the request also carried
+                # items nothing can name, so the membership only supports
+                # positive claims and the count is surfaced as information.
+                unidentified_membership_revisions += 1
+            expected_hash = _payload_str(endpoint.payload, "membership_hash")
+            if expected_hash is not None:
+                actual_hash = membership_hash(fingerprint_key, membership)
+                if actual_hash is None:
+                    revision_errors.append(f"context revision {revision_id} membership_hash cannot be verified")
+                elif actual_hash != expected_hash:
+                    revision_errors.append(f"context revision {revision_id} membership_hash does not match replay")
+        if revision_errors:
+            errors[revision_id] = tuple(revision_errors)
+            continue
+        if membership is None:
+            raise RuntimeError("A validated context revision has no resolved membership.")
+        ordered_memberships[revision_id] = membership
+    return _RevisionResolution(
+        memberships={
+            revision_id: tuple(item_id for item_id, _ in membership)
+            for revision_id, membership in ordered_memberships.items()
+        },
+        endpoints=endpoints,
+        errors=errors,
+        side_call_empty_shell_revisions=tuple(side_call_empty_shell_revisions),
+        unidentified_membership_revision_count=unidentified_membership_revisions,
+    )
+
+
+def _segmented_revision_entries(
+    intermediate: _Intermediate,
+    endpoint: _Endpoint,
+    inactive_ranges: tuple[tuple[int, int], ...],
+    *,
+    cancel_event: Event | None,
+) -> tuple[_RevisionEntry, ...] | None:
+    field_pointer = "/payload/refs"
+    declarations = [item for item in endpoint.segmented_fields if item.field_pointer == field_pointer]
+    if len(declarations) != 1 or endpoint.event_id is None:
+        return None
+    declaration = declarations[0]
+    segments = [
+        segment
+        for segment in intermediate.segments.get(endpoint.event_id, ())
+        if _active(segment.sequence, inactive_ranges) and segment.field_pointer == field_pointer
+    ]
+    if len(segments) != declaration.segment_count:
+        return None
+    indexed_segments: list[tuple[int, _Segment]] = []
+    for segment in segments:
+        _check_cancelled(cancel_event)
+        segment_index = segment.segment_index
+        if segment_index is None:
+            return None
+        indexed_segments.append((segment_index, segment))
+    if sorted(segment_index for segment_index, _ in indexed_segments) != list(range(declaration.segment_count)):
+        return None
+    entries: list[_RevisionEntry] = []
+    for _, segment in sorted(indexed_segments):
+        _check_cancelled(cancel_event)
+        if (
+            segment.segment_count != declaration.segment_count
+            or segment.segment_group_id != declaration.segment_group_id
+            or segment.encoding != "array_slice"
+            or segment.entry_oversized
+            or segment.runtime_id != endpoint.runtime_id
+            or segment.branch_id != endpoint.branch_id
+            or segment.coverage_id != endpoint.coverage_id
+            or segment.turn_id != endpoint.turn_id
+            or segment.sequence <= endpoint.sequence
+            or not _endpoint_in_coverage_runtime(intermediate, segment, inactive_ranges)
+        ):
+            return None
+        values = segment.entries
+        if values is None or not all(isinstance(value, _RevisionEntry) for value in values):
+            return None
+        entries.extend(value for value in values if isinstance(value, _RevisionEntry))
+    return tuple(entries)
+
+
+def _replay_checkpoint(entries: tuple[_RevisionEntry, ...]) -> tuple[MembershipRef, ...] | None:
+    if any(entry.action != "add" for entry in entries):
+        return None
+    ordered = sorted(entries, key=lambda entry: entry.position)
+    if [entry.position for entry in ordered] != list(range(len(ordered))):
+        return None
+    membership = tuple((entry.item_id, entry.occurrence) for entry in ordered)
+    return membership if _valid_membership_occurrences(membership) else None
+
+
+def _replay_delta(
+    parent: tuple[MembershipRef, ...],
+    entries: tuple[_RevisionEntry, ...],
+) -> tuple[MembershipRef, ...] | None:
+    removals = [entry for entry in entries if entry.action == "remove"]
+    additions = [entry for entry in entries if entry.action == "add"]
+    if len(removals) + len(additions) != len(entries):
+        return None
+    removal_positions = [entry.position for entry in removals]
+    if len(removal_positions) != len(set(removal_positions)):
+        return None
+    for entry in removals:
+        if entry.position >= len(parent) or parent[entry.position] != (entry.item_id, entry.occurrence):
+            return None
+    replayed = list(parent)
+    for entry in sorted(removals, key=lambda item: item.position, reverse=True):
+        del replayed[entry.position]
+    addition_positions = [entry.position for entry in additions]
+    if len(addition_positions) != len(set(addition_positions)):
+        return None
+    for entry in sorted(additions, key=lambda item: item.position):
+        ref = (entry.item_id, entry.occurrence)
+        if entry.position > len(replayed) or ref in replayed:
+            return None
+        replayed.insert(entry.position, ref)
+    membership = tuple(replayed)
+    return membership if _valid_membership_occurrences(membership) else None
+
+
+def _valid_membership_occurrences(membership: tuple[MembershipRef, ...]) -> bool:
+    seen: dict[str, int] = {}
+    for item_id, occurrence in membership:
+        if occurrence != seen.get(item_id, 0):
+            return False
+        seen[item_id] = occurrence + 1
+    return True
+
+
+def _compaction_consumption_resolution(
+    intermediate: _Intermediate,
+    nodes: list[_ResolvedNode],
+    inactive_ranges: tuple[tuple[int, int], ...],
+    *,
+    cancel_event: Event | None,
+    diagnostics: list[str],
+) -> _CompactionConsumptionResolution:
+    by_run: dict[str, _Phase4Consumption] = {}
+    seen_runs: set[str] = set()
+    exact = True
+    for phase in (node for node in nodes if node.family == "compaction.phase"):
+        _check_cancelled(cancel_event)
+        if _payload_str(phase.finish.payload, "phase") != "phase4":
+            continue
+        endpoint = phase.finish
+        run_id = endpoint.parent_operation_id
+        if run_id is None:
+            diagnostics.append("Phase-4 consumed item declaration lacks a compaction run")
+            exact = False
+            continue
+        if run_id in seen_runs:
+            diagnostics.append("compaction run declares more than one Phase-4 consumption event")
+            by_run.pop(run_id, None)
+            exact = False
+            continue
+        seen_runs.add(run_id)
+        entries = _segmented_string_entries(
+            intermediate,
+            endpoint,
+            inactive_ranges,
+            field_pointer="/payload/consumed_item_ids",
+            cancel_event=cancel_event,
+        )
+        if entries is None:
+            diagnostics.append("Phase-4 compaction has invalid segmented consumed item ids")
+            exact = False
+            continue
+        next_exchange = _payload_str(endpoint.payload, "next_exchange_operation_id")
+        if next_exchange is None:
+            diagnostics.append("Phase-4 compaction lacks next_exchange_operation_id")
+            exact = False
+            continue
+        by_run[run_id] = _Phase4Consumption(
+            item_ids=frozenset(entries),
+            next_exchange_operation_id=next_exchange,
+        )
+    return _CompactionConsumptionResolution(
+        by_run=by_run,
+        exact=exact,
+    )
+
+
+def _segmented_string_entries(
+    intermediate: _Intermediate,
+    endpoint: _Endpoint,
+    inactive_ranges: tuple[tuple[int, int], ...],
+    *,
+    field_pointer: str,
+    cancel_event: Event | None,
+) -> tuple[str, ...] | None:
+    declarations = [item for item in endpoint.segmented_fields if item.field_pointer == field_pointer]
+    if len(declarations) != 1 or endpoint.event_id is None:
+        return None
+    declaration = declarations[0]
+    segments = [
+        segment
+        for segment in intermediate.segments.get(endpoint.event_id, ())
+        if _active(segment.sequence, inactive_ranges) and segment.field_pointer == field_pointer
+    ]
+    if len(segments) != declaration.segment_count:
+        return None
+    indexed_segments: list[tuple[int, _Segment]] = []
+    for segment in segments:
+        _check_cancelled(cancel_event)
+        if segment.segment_index is None:
+            return None
+        indexed_segments.append((segment.segment_index, segment))
+    if sorted(index for index, _ in indexed_segments) != list(range(declaration.segment_count)):
+        return None
+    entries: list[str] = []
+    for _, segment in sorted(indexed_segments):
+        _check_cancelled(cancel_event)
+        if (
+            segment.segment_count != declaration.segment_count
+            or segment.segment_group_id != declaration.segment_group_id
+            or segment.encoding != "array_slice"
+            or segment.entry_oversized
+            or segment.runtime_id != endpoint.runtime_id
+            or segment.branch_id != endpoint.branch_id
+            or segment.coverage_id != endpoint.coverage_id
+            or segment.turn_id != endpoint.turn_id
+            or segment.sequence <= endpoint.sequence
+            or not _endpoint_in_coverage_runtime(intermediate, segment, inactive_ranges)
+        ):
+            return None
+        values = segment.entries
+        if values is None or not all(isinstance(value, str) and is_valid_analytics_id(value) for value in values):
+            return None
+        entries.extend(cast("str", value) for value in values)
+    return tuple(entries)

chrys/service/analytics/_critical_path.py

@@ -0,0 +1,179 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
+
+"""Bounded interval-union critical-path resolution."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from dataclasses import dataclass
+from threading import Event
+from typing import Final
+
+from chrys.service.analytics.math import interval_length, interval_union
+from chrys.service.analytics.reader import raise_if_cancelled as _check_cancelled
+
+_MAX_CRITICAL_PATH_CANDIDATES: Final = 4096
+"""Hard bound on retained interval histories in one critical-path resolution."""
+
+
+@dataclass(frozen=True, slots=True)
+class _PathResolution:
+    value: int | None
+    acyclic: bool
+    bounded: bool
+
+
+def _longest_interval_path(
+    intervals: dict[str, list[tuple[int, int]]],
+    edges: dict[str, set[str]],
+    *,
+    parents: dict[str, str] | None = None,
+    fork_edges: frozenset[tuple[str, str]] = frozenset(),
+    root_id: str | None = None,
+    terminal_id: str | None = None,
+    cancel_event: Event | None = None,
+) -> _PathResolution:
+    """Resolve the path whose interval union is longest.
+
+    A causal edge that leaves a container (neither a displacing parent→child
+    edge nor a concurrent-hook fork) depends on the container *completing*, so
+    the walk carries the container's displaced descendants across that edge:
+    a consumer that waits on a tool also waited for the approval and the
+    sub-agent the tool displaced.
+
+    Interval unions make the exact problem combinatorial, so a max-sum walk
+    runs first: when the best-sum path's intervals are pairwise disjoint its
+    sum equals its union and bounds every other path's union, which certifies
+    it. Only overlapping paths fall back to the bounded non-dominated search.
+    """
+    vertices = set(intervals)
+    for source, targets in edges.items():
+        _check_cancelled(cancel_event)
+        vertices.add(source)
+        vertices.update(targets)
+    indegree = dict.fromkeys(vertices, 0)
+    for targets in edges.values():
+        for target in targets:
+            indegree[target] += 1
+    roots = [vertex for vertex, degree in indegree.items() if degree == 0]
+    ready = list(roots)
+    order: list[str] = []
+    while ready:
+        _check_cancelled(cancel_event)
+        vertex = ready.pop()
+        order.append(vertex)
+        for target in edges.get(vertex, ()):
+            indegree[target] -= 1
+            if indegree[target] == 0:
+                ready.append(target)
+    if len(order) != len(vertices):
+        return _PathResolution(None, False, True)
+
+    displacing_parents = parents or {}
+    children: dict[str, list[str]] = defaultdict(list)
+    for child, parent in displacing_parents.items():
+        children[parent].append(child)
+    completions: dict[str, tuple[tuple[int, int], ...]] = {}
+
+    def carried(source: str, target: str) -> tuple[tuple[int, int], ...]:
+        if displacing_parents.get(target) == source or (source, target) in fork_edges:
+            return ()
+        completion = completions.get(source)
+        if completion is None:
+            members: list[tuple[int, int]] = []
+            seen: set[str] = set()
+            pending = list(children.get(source, ()))
+            while pending:
+                member = pending.pop()
+                if member in seen:
+                    continue
+                seen.add(member)
+                members.extend(intervals.get(member, ()))
+                pending.extend(children.get(member, ()))
+            completion = completions[source] = interval_union(members)
+        return completion
+
+    starts = roots if root_id is None else [root_id] if root_id in vertices else []
+    lengths = {vertex: interval_length(interval_union(intervals.get(vertex, ()))) for vertex in vertices}
+    sums: dict[str, int] = {vertex: lengths[vertex] for vertex in starts}
+    predecessors: dict[str, str] = {}
+    for vertex in order:
+        _check_cancelled(cancel_event)
+        value = sums.get(vertex)
+        if value is None:
+            continue
+        for target in edges.get(vertex, ()):
+            candidate = value + interval_length(carried(vertex, target)) + lengths[target]
+            if candidate > sums.get(target, -1):
+                sums[target] = candidate
+                predecessors[target] = vertex
+    end = terminal_id if terminal_id is not None else max(sums, key=sums.__getitem__, default=None)
+    if end is None:
+        return _PathResolution(0, True, True)
+    if end not in sums:
+        return _PathResolution(None, True, True)
+    witness: list[tuple[int, int]] = list(intervals.get(end, ()))
+    cursor = end
+    while cursor in predecessors:
+        previous = predecessors[cursor]
+        witness.extend(carried(previous, cursor))
+        witness.extend(intervals.get(previous, ()))
+        cursor = previous
+    if interval_length(interval_union(witness)) == sums[end]:
+        return _PathResolution(sums[end], True, True)
+
+    paths: dict[str, set[tuple[tuple[int, int], ...]]] = defaultdict(set)
+    retained = 0
+    for vertex in starts:
+        paths[vertex].add(interval_union(intervals.get(vertex, ())))
+        retained += 1
+    if retained > _MAX_CRITICAL_PATH_CANDIDATES:
+        return _PathResolution(None, True, False)
+    best = 0
+    terminal_value: int | None = None
+    for vertex in order:
+        _check_cancelled(cancel_event)
+        candidates = paths.get(vertex, set())
+        if candidates:
+            candidate_max = max(interval_length(path) for path in candidates)
+            best = max(best, candidate_max)
+            if vertex == terminal_id:
+                terminal_value = candidate_max
+        for target in edges.get(vertex, ()):
+            target_paths = paths[target]
+            crossing = carried(vertex, target)
+            for path in candidates:
+                candidate = interval_union((*path, *crossing, *intervals.get(target, ())))
+                retained += _retain_nondominated(target_paths, candidate)
+                if retained > _MAX_CRITICAL_PATH_CANDIDATES:
+                    return _PathResolution(None, True, False)
+        retained -= len(candidates)
+        paths.pop(vertex, None)
+    if terminal_id is not None:
+        return _PathResolution(terminal_value, True, True)
+    return _PathResolution(best, True, True)
+
+
+def _retain_nondominated(
+    retained: set[tuple[tuple[int, int], ...]],
+    candidate: tuple[tuple[int, int], ...],
+) -> int:
+    if any(_intervals_subset(candidate, existing) for existing in retained):
+        return 0
+    dominated = {existing for existing in retained if _intervals_subset(existing, candidate)}
+    retained.difference_update(dominated)
+    retained.add(candidate)
+    return 1 - len(dominated)
+
+
+def _intervals_subset(
+    subset: tuple[tuple[int, int], ...],
+    superset: tuple[tuple[int, int], ...],
+) -> bool:
+    superset_index = 0
+    for start, end in subset:
+        while superset_index < len(superset) and superset[superset_index][1] <= start:
+            superset_index += 1
+        if superset_index >= len(superset) or superset[superset_index][0] > start or superset[superset_index][1] < end:
+            return False
+    return True