linkedparticles-core 1.192.2__tar.gz → 1.192.28__tar.gz

{linkedparticles_core-1.192.2 → linkedparticles_core-1.192.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: linkedparticles-core
-Version: 1.192.2
+Version: 1.192.28
 Summary: Store-free client library for Particles: define, validate, serialize, and extract provenance-tracked belief particles
 Project-URL: Homepage, https://linkedparticles.org
 Project-URL: Documentation, https://docs.linkedparticles.org
@@ -29,7 +29,7 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Python: >=3.11
-Requires-Dist: anthropic>=0.28
+Requires-Dist: anthropic>=1.0
 Requires-Dist: html2text>=2024.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: jsonschema>=4.22
@@ -37,17 +37,17 @@ Requires-Dist: lxml-stubs>=0.5.1
 Requires-Dist: numpy>=1.26
 Requires-Dist: opentelemetry-api>=1.27
 Requires-Dist: pydantic>=2.7
-Requires-Dist: pyld<4,>=2.0
-Requires-Dist: pypdf>=6.15.0
-Requires-Dist: pyshacl<0.32,>=0.26
+Requires-Dist: pyld<4,>=3.0
+Requires-Dist: pypdf>=6.19.0
+Requires-Dist: pyshacl<0.41,>=0.40
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: rdflib<8,>=7.0
 Requires-Dist: scipy>=1.13
-Requires-Dist: sentence-transformers>=2.7
-Requires-Dist: sqlalchemy[asyncio]<2.2,>=2.0
+Requires-Dist: sentence-transformers>=5.6.0
+Requires-Dist: sqlalchemy[asyncio]<2.2,>=2.1
 Requires-Dist: torch
 Provides-Extra: vision
-Requires-Dist: pypdfium2>=4.30; extra == 'vision'
+Requires-Dist: pypdfium2>=5.0; extra == 'vision'
 Description-Content-Type: text/markdown
 
 # linkedparticles-core

{linkedparticles_core-1.192.2 → linkedparticles_core-1.192.28}/constraints.txt

@@ -10,7 +10,7 @@ annotated-doc==0.0.5
     #   typer
 annotated-types==0.8.0
     # via pydantic
-anthropic==1.11.0
+anthropic==1.13.0
     # via linkedparticles
 anyio==4.14.2 ; python_full_version < '3.15'
     # via
@@ -42,7 +42,7 @@ attrs==26.1.0
     #   referencing
 cachetools==7.2.0
     # via pyld
-certifi==2026.7.22
+certifi==2026.10.19
     # via
     #   httpcore
     #   httpx
@@ -67,9 +67,9 @@ distro==1.9.0
     # via langsmith
 docstring-parser==0.18.0
     # via anthropic
-fastapi==0.142.2
+fastapi==0.143.0
     # via linkedparticles
-filelock==4.0.12
+filelock==4.1.1
     # via
     #   huggingface-hub
     #   linkedparticles
@@ -148,7 +148,7 @@ jsonschema==4.26.0
     #   mcp
 jsonschema-specifications==2025.9.1
     # via jsonschema
-langchain-core==1.6.7
+langchain-core==1.6.10
     # via linkedparticles
 langchain-protocol==0.0.19
     # via langchain-core
@@ -266,7 +266,7 @@ protobuf==7.36.2
     #   opentelemetry-proto
 pycparser==3.0 ; implementation_name != 'PyPy' and platform_python_implementation != 'PyPy'
     # via cffi
-pydantic==2.13.5
+pydantic==2.14.1
     # via
     #   anthropic
     #   fastapi
@@ -275,7 +275,7 @@ pydantic==2.13.5
     #   linkedparticles
     #   mcp
     #   pydantic-settings
-pydantic-core==2.46.5
+pydantic-core==2.50.1
     # via pydantic
 pydantic-settings==2.15.0
     # via mcp
@@ -287,7 +287,7 @@ pyld==3.3.0
     # via linkedparticles
 pyparsing==3.3.3
     # via rdflib
-pypdf==6.19.0
+pypdf==6.20.1
     # via linkedparticles
 pypdfium2==5.14.0
     # via linkedparticles
@@ -356,7 +356,7 @@ sniffio==1.3.1
     # via
     #   anthropic
     #   langsmith
-sqlalchemy==2.1.3
+sqlalchemy==2.1.4
     # via
     #   alembic
     #   linkedparticles

{linkedparticles_core-1.192.2 → linkedparticles_core-1.192.28}/particles/config.py

@@ -595,6 +595,27 @@ _SHIPPED_EXTRACTION_OUTPUT_TOKENS: dict[str, int] = {
     "claude-sonnet-4-6": 5_363,
 }
 
+# Cache-read multipliers that differ from ``llm.cache_read_price_multiplier``'s
+# standard 0.1x, from the pricing page's footnotes (read 2026-10-18): cache hits
+# on claude-opus-5-5 and claude-sonnet-5-5 bill at 0.05x base input, and on
+# claude-fable-5-1 at 0.025x. Every other model uses the standard multiplier.
+_SHIPPED_CACHE_READ_MULTIPLIER: dict[str, float] = {
+    "claude-fable-5-1": 0.025,
+    "claude-opus-5-5": 0.05,
+    "claude-sonnet-5-5": 0.05,
+}
+
+# How much less output a source type's extraction calls write per character
+# than the documents ``audit.estimate_output_tokens_per_source_char`` was
+# fitted on (memory notes and design records, about 5 claims per 1,000
+# characters). A Claude Code transcript states about 1.9 per 1,000 (the
+# general extractor's transcript deltas), so 0.4. Checked against
+# the five metered consolidation nights of 2026-10-12 to 10-16 on the owner's
+# store (claude-sonnet-5-5, mostly CONVERSATION snapshots): the expected
+# output came out 1.1 to 1.9 times what the provider reported, before the
+# estimate's high end adds its spread.
+_SHIPPED_OUTPUT_SCALE_BY_SOURCE_TYPE: dict[str, float] = {"CONVERSATION": 0.4}
+
 _T = TypeVar("_T")
 
 
@@ -731,6 +752,39 @@ class LLMConfig(BaseModel):
     # at 1.25x input and a cache read at 0.1x.
     cache_write_price_multiplier: float = Field(default=1.25, ge=0.0)
     cache_read_price_multiplier: float = Field(default=0.1, ge=0.0)
+    # Per-model cache-read multipliers, keyed like ``price_per_mtok``, for the
+    # models the pricing page bills below the standard 0.1x
+    # (``_SHIPPED_CACHE_READ_MULTIPLIER``). Entries set here merge over the
+    # shipped ones; a model with no entry uses ``cache_read_price_multiplier``.
+    cache_read_price_multiplier_by_model: dict[str, float] = Field(
+        default_factory=lambda: dict(_SHIPPED_CACHE_READ_MULTIPLIER)
+    )
+
+    @field_validator("cache_read_price_multiplier_by_model", mode="before")
+    @classmethod
+    def _merge_over_shipped_cache_reads(cls, value: Any) -> Any:
+        """Operator entries replace the shipped ones key by key; the rest stay."""
+        if isinstance(value, dict):
+            return {**_SHIPPED_CACHE_READ_MULTIPLIER, **value}
+        return value
+
+    @field_validator("cache_read_price_multiplier_by_model")
+    @classmethod
+    def _non_negative_cache_reads(cls, value: dict[str, float]) -> dict[str, float]:
+        """A cache-read multiplier is a price ratio: zero or more."""
+        for key, factor in value.items():
+            if factor < 0:
+                raise ValueError(
+                    f"llm.cache_read_price_multiplier_by_model[{key!r}] must be >= 0, got {factor}"
+                )
+        return value
+
+    def cache_read_multiplier_for(self, selection: ProviderSelection) -> float:
+        """The cache-read price as a multiple of ``selection``'s input price."""
+        factor, _ = lookup_by_model(
+            self.cache_read_price_multiplier_by_model, selection.provider, selection.model
+        )
+        return self.cache_read_price_multiplier if factor is None else factor
 
     @field_validator("price_per_mtok", mode="before")
     @classmethod
@@ -936,6 +990,14 @@ class ExtractionConfig(BaseModel):
     # alone. On a short source it rivals the source itself. Read by the audit
     # estimate and the memory-rot benchmark.
     estimate_prompt_overhead_tokens: int = Field(default=2500, ge=0)
+    # The part of that system prompt sent as a prompt-cache prefix,
+    # which a batch of extraction calls writes once and then reads at the
+    # model's cache-read price (``llm.cache_read_price_multiplier_by_model``).
+    # The consolidation estimate adds it per call on top of the overhead above;
+    # with ``llm.prompt_cache.enabled`` off it is priced as plain input.
+    # Measured: claude-sonnet-5-5 wrote a 2,868-token prefix on each of the
+    # metered nights of 2026-10-12 to 10-16.
+    estimate_cached_prefix_tokens: int = Field(default=2900, ge=0)
     # The bulk extraction paths skip an unextracted snapshot of a MUTABLE
     # entry once a newer extractable snapshot of the same entry exists: the
     # generation cascade would retire the older generation's beliefs anyway,
@@ -956,6 +1018,12 @@ class ExtractionConfig(BaseModel):
     # The largest delta chunk sent in one call. Each chunk after the first
     # takes the end of the chunk before it as its context.
     append_chunk_chars: int = Field(default=7500, ge=1000)
+    # the agent extractor's prompt (the Stop hook's ask and its API
+    # proxy) tells the model how many claims text of its size usually yields,
+    # as a thoroughness guide, never a quota. 1.9 is the median claims per
+    # 1000 characters of the general extractor's transcript deltas in the
+    # maintainers' store (262 reads, measured 2026-10-16).
+    agent_expected_claims_per_kchar: float = Field(default=1.9, gt=0.0)
     # a pair the §6.6 contradiction probe confirms is read a second
     # time, before the write loop, with each claim's source kind, name, time
     # and passage (on ``llm.verification``). A pair the reading does not
@@ -1627,6 +1695,15 @@ class UtilityMiningConfig(BaseModel):
     behavioural_matching: bool = True
     max_behavioural_calls: int = Field(default=150, ge=0)
     behavioural_candidate_limit: int = Field(default=200, ge=0)
+    # Characters per input token the consolidation estimate prices a judge
+    # prompt at. The prompt is mostly tool-call lines (paths, ids, shell
+    # commands), which tokenize denser than prose: on the metered nights of
+    # 2026-10-12 to 10-16, claude-sonnet-5-5 billed 3,560 to 4,240 input
+    # tokens a call for prompts of about 9,100 characters (the action
+    # evidence is capped, so the size holds night to night), 2.1 to 2.6
+    # characters a token. The lower figure keeps the estimate above the bill.
+    # The estimate uses the smaller of this and the model's own factor.
+    estimate_chars_per_token: float = Field(default=2.1, gt=0.0)
 
 
 class UtilityConfig(BaseModel):
@@ -2085,6 +2162,21 @@ class RedditConfig(BaseModel):
     top_comment_count: int = 200
     # Raised 500→1000 for parity with the gist comment body limit.
     comment_body_limit: int = 1000
+    # Where the importer fetches a thread's post and comment tree from. Reddit
+    # bot-walls its own ``.json`` endpoint for unauthenticated clients (403), so
+    # the default reads the Arctic Shift archive, a free third-party mirror that
+    # serves Reddit's own field names. ``reddit`` keeps the direct curl fetch for
+    # an operator whose network can still reach it. The share-link redirect is
+    # always resolved through reddit.com, whichever backend is chosen.
+    fetch_backend: Literal["arctic_shift", "reddit"] = "arctic_shift"
+    # Base URL of the Arctic Shift API host (no trailing path).
+    arctic_shift_base_url: str = "https://arctic-shift.photon-reddit.com"
+    # ``limit`` passed to the archive's comment-tree endpoint: the most comments
+    # one deposit pulls. The extractor still sends only ``top_comment_count``.
+    arctic_shift_comment_limit: int = Field(default=25000, ge=1)
+    # Longest wait honoured on an HTTP 429 before the one retry. A reset further
+    # away than this fails the deposit at once instead of stalling it.
+    arctic_shift_max_wait_seconds: float = Field(default=30.0, ge=0.0)
 
 
 class HackerNewsConfig(BaseModel):
@@ -2216,6 +2308,19 @@ class QueryConfig(BaseModel):
     # default follows the leakage measurement recorded in
     # docs/benchmarks/leakage.md.
     grounded_answers: bool = False
+    # Keep each store's ACTIVE candidates decoded in memory between reads,
+    # re-reading only the rows the store's change journal names as changed
+    # (particles/store/candidate_cache.py). Semantic query, extraction, the
+    # write-time reconciliation seam and the maintenance passes read through
+    # it. Results are identical either way; off reads and decodes every
+    # candidate on every read. The cache holds one decoded row per ACTIVE
+    # belief for the life of the process.
+    candidate_cache: bool = True
+    # After a full build of a cache this many rows or larger, exempt the
+    # process's live objects from Python's cyclic garbage collector
+    # (gc.freeze), which otherwise walks the whole cache on most queries
+    # (about 0.3 s at 56k rows). Process-wide; 0 never freezes.
+    candidate_cache_freeze_rows: int = Field(default=10_000, ge=0)
 
 
 class ContestednessConfig(BaseModel):
@@ -2801,12 +2906,21 @@ class AgentExtractionConfig(BaseModel):
     # An ask unanswered after this many seconds is expired.
     ask_ttl_seconds: int = Field(default=900, ge=60)
     # A submission covers its span only with at least this many accepted claims
-    # per 1000 characters. 2.7 is the 10th percentile of the general
-    # extractor's own transcript deltas in the maintainers' store.
-    min_claims_per_kchar: float = Field(default=2.7, ge=0.0)
+    # per 1000 characters. 1.27 is the 10th percentile of the general
+    # extractor's own transcript deltas in the maintainers' store (262 delta
+    # reads, measured 2026-10-16; it was 2.7 on 2026-10-09, before the
+    # session-state and tool-turn filters thinned transcript extraction).
+    min_claims_per_kchar: float = Field(default=1.27, ge=0.0)
     # ...and with no more than this share of candidates dropped for evidence
     # not found in the span. Placeholder until the shadow week measures it.
     max_evidence_drop_ratio: float = Field(default=0.5, ge=0.0, le=1.0)
+    # In shadow mode, keep each submission's accepted candidates (claim text,
+    # stated confidence, evidence) in a local JSONL file, so a later labelling
+    # pass can fit a calibration map on real session claims. The
+    # operator event log keeps counts only. Off writes nothing.
+    keep_shadow_candidates: bool = True
+    # None ⇒ ``<claude_code.state_dir>/agent-extraction-shadow.jsonl``.
+    shadow_candidates_path: str | None = None
 
     @field_validator("mode", mode="before")
     @classmethod
@@ -3210,6 +3324,36 @@ class AuditConfig(BaseModel):
     # Wall time per second reading: the measured runs read 22 flags in ~41 s.
     estimate_seconds_per_verification: float = Field(default=2.0, ge=0.0)
 
+    # Multiplies the per-character output rate above for a source type that
+    # states fewer (or more) claims per character than the documents it was
+    # fitted on, keyed by corpus-entry source type (``CONVERSATION``). The
+    # per-call base is unchanged. Read by the consolidation estimate, which
+    # knows each snapshot's source type. Ships with a measured entry for
+    # transcripts (``_SHIPPED_OUTPUT_SCALE_BY_SOURCE_TYPE``); operator entries
+    # merge over it key by key, and a type with no entry is scaled by 1.
+    estimate_output_scale_by_source_type: dict[str, float] = Field(
+        default_factory=lambda: dict(_SHIPPED_OUTPUT_SCALE_BY_SOURCE_TYPE)
+    )
+
+    @field_validator("estimate_output_scale_by_source_type", mode="before")
+    @classmethod
+    def _merge_over_shipped_type_scales(cls, value: Any) -> Any:
+        """Operator entries replace the shipped ones key by key; the rest stay."""
+        if isinstance(value, dict):
+            return {**_SHIPPED_OUTPUT_SCALE_BY_SOURCE_TYPE, **value}
+        return value
+
+    @field_validator("estimate_output_scale_by_source_type")
+    @classmethod
+    def _non_negative_type_scale(cls, value: dict[str, float]) -> dict[str, float]:
+        """Every per-type output scale is a multiplier: zero or more."""
+        for key, scale in value.items():
+            if scale < 0:
+                raise ValueError(
+                    f"audit.estimate_output_scale_by_source_type[{key!r}] must be >= 0, got {scale}"
+                )
+        return value
+
     @field_validator("estimate_output_scale_by_model", mode="before")
     @classmethod
     def _merge_over_shipped_scales(cls, value: Any) -> Any:

{linkedparticles_core-1.192.2 → linkedparticles_core-1.192.28}/particles/core/closure_measure.py

@@ -24,13 +24,20 @@ A transition is one of three kinds:
   and *autonomous* otherwise: the trust ladder, update supersession,
   duplicate merge, re-anchor, staleness, abstraction revalidation.
 - ``contradiction_closed``: an INCONSISTENCY record closed, by a review
-  (gesture) or by the nightly disclosure pass (autonomous).
+  (gesture) or by a nightly pass (autonomous): the disclosure pass
+  or the held-claim release.
 - ``promotion``: an abstraction asserted, by the accept gesture or
   by the pass itself in ``auto`` mode.
 
 A gesture is an explicit write verb, whether an operator or an agent ran it;
 ``gesture_by_actor`` keeps the two apart for a reader who needs them apart.
 
+An autonomous closure is also tallied by its cause, and by whether it
+returned a held claim to the store (:func:`tally_closures`). Most causes
+release nothing: a lapsed or regrouped census record held no claim. A
+withdrawn extraction record and a partner-retired one each restore the
+claim the record held, and that release is the one no person approved.
+
 Pure: the Engine gathers plain values and this module decides the tally.
 Nothing here is stored on a particle; the result rides the
 ``CONSOLIDATION_RUN`` event.
@@ -39,8 +46,9 @@ Nothing here is stored on a particle; the result rides the
 from __future__ import annotations
 
 from collections import Counter
-from collections.abc import Sequence
+from collections.abc import Mapping, Sequence
 from dataclasses import dataclass, field
+from typing import Any
 
 #: Event types whose PARTICLE refs name the beliefs an explicit write retired.
 GESTURE_RETIREMENT_EVENTS: frozenset[str] = frozenset(
@@ -55,6 +63,10 @@ TRANSITION_KINDS: tuple[str, ...] = ("retirement", "contradiction_closed", "prom
 #: The reason key for a retired row that carries no ``status_reason``.
 UNSPECIFIED_REASON = "UNSPECIFIED"
 
+#: The ``INCONSISTENCY_CLOSED`` payload keys that name the claim a close
+#: returned to the store: a minted successor, or the ACTIVE twin it folded into.
+RELEASE_KEYS: tuple[str, ...] = ("successor", "folded_into")
+
 
 @dataclass(frozen=True)
 class Retirement:
@@ -73,6 +85,51 @@ class GestureEvent:
     particle_ids: tuple[str, ...] = ()
 
 
+@dataclass(frozen=True)
+class Closure:
+    """One autonomous ``INCONSISTENCY_CLOSED`` event, reduced to what the tally reads."""
+
+    cause: str
+    #: Whether the close returned a held claim to the store.
+    released: bool = False
+
+
+def closure_from_payload(payload: Mapping[str, Any] | None) -> Closure:
+    """Read one close event's cause and whether it released a held claim."""
+    data = payload or {}
+    cause = data.get("cause")
+    return Closure(
+        cause=cause if isinstance(cause, str) and cause else UNSPECIFIED_REASON,
+        released=any(data.get(key) for key in RELEASE_KEYS),
+    )
+
+
+@dataclass(frozen=True)
+class ClosureTally:
+    """Autonomous closures by cause, and the held-claim releases among them."""
+
+    closed_by_cause: dict[str, int] = field(default_factory=dict)
+    released_by_cause: dict[str, int] = field(default_factory=dict)
+
+    @property
+    def closed(self) -> int:
+        return sum(self.closed_by_cause.values())
+
+    @property
+    def released(self) -> int:
+        return sum(self.released_by_cause.values())
+
+
+def tally_closures(closures: Sequence[Closure]) -> ClosureTally:
+    """Count closures and held-claim releases per cause, causes sorted."""
+    closed = Counter(c.cause for c in closures)
+    released = Counter(c.cause for c in closures if c.released)
+    return ClosureTally(
+        closed_by_cause=dict(sorted(closed.items())),
+        released_by_cause=dict(sorted(released.items())),
+    )
+
+
 @dataclass(frozen=True)
 class TransitionTally:
     """Lifecycle transitions in one window, split autonomous versus gesture."""

{linkedparticles_core-1.192.2 → linkedparticles_core-1.192.28}/particles/core/conflict_review.py

@@ -31,6 +31,42 @@ from particles.core.status import Status, StatusReason
 
 _TERMINAL = (Status.RETRACTED, Status.SUPERSEDED)
 
+CLOSED_RECORD: tuple[Status, StatusReason] = (Status.RETRACTED, StatusReason.CONFLICT_RESOLVED)
+"""The state every non-DEFER resolution leaves an INCONSISTENCY record in.
+
+The §6.6 wrapper-terminal rule: review, the trust cascade, the held-claim
+release and the disclosure sweep all close a record this way. A record the
+cascade closed before 1.192.15 was left ``PROVENANCE_STALE`` /
+``CONFLICT_RESOLVED`` instead; migration 053 moves those here."""
+
+CASCADE_ACTOR = "trust-cascade"
+"""``asserted_by`` on the REVIEW particle the trust cascade writes per record."""
+
+_CASCADE_REVIEW_PREFIX = "CASCADE REVIEW: auto-resolved INCONSISTENCY "
+
+
+def cascade_review_content(
+    inconsistency_id: str, winner_id: str, loser_id: str, statement_id: str
+) -> str:
+    """The content of the REVIEW particle the trust cascade writes for one record."""
+    return (
+        f"{_CASCADE_REVIEW_PREFIX}{inconsistency_id}. "
+        f"Winner: {winner_id}. Loser: {loser_id}. "
+        f"Triggered by trust statement {statement_id}."
+    )
+
+
+def cascade_reviewed_record_id(content: str) -> str | None:
+    """The record a cascade REVIEW particle's content names, or None for other content.
+
+    The cascade writes no operator event, so its REVIEW particle is the one
+    trace that says which closed records it closed.
+    """
+    if not content.startswith(_CASCADE_REVIEW_PREFIX):
+        return None
+    record_id, sep, _rest = content[len(_CASCADE_REVIEW_PREFIX) :].partition(". ")
+    return record_id if sep and record_id else None
+
 
 class Demotion(Enum):
     """What demoting a conflict's losing claim takes, given its current status."""

{linkedparticles_core-1.192.2 → linkedparticles_core-1.192.28}/particles/core/contradiction_disclosure.py

@@ -76,8 +76,7 @@ DISCLOSURE_ACTOR = "memory-consolidate"
 READING_STANDING = "standing/1"
 #: The instruction for a pair with a claim from a time-stamped record (a
 #: session transcript, another append-only log): a value observed at a later
-#: time may be a change, and only the same moment or a fixed fact confirms
-#:.
+#: time may be a change, and only the same moment or a fixed fact confirms.
 READING_OBSERVED = "observed/1"
 
 _EXCERPT_CHARS = 120
@@ -420,7 +419,7 @@ class CloseCause(StrEnum):
     REVIEW = "review"
     """A review action: a ``REVIEW_RESOLVED`` event names the record."""
     CASCADE = "cascade"
-    """The trust cascade: ``PROVENANCE_STALE``, with no event."""
+    """The trust cascade: no event; its REVIEW particle names the record."""
     LAPSED = "lapsed"
     """The lapse sweep: a side has no member left."""
     REGROUPED = "regrouped"

{linkedparticles_core-1.192.2 → linkedparticles_core-1.192.28}/particles/core/held_release.py

@@ -31,9 +31,9 @@ from particles.core.observer_scope import PairPrecondition
 from particles.core.schema import Particle
 from particles.core.status import Status, StatusReason
 
-#: The retirements an autonomous pass writes: rung 2.5 and its sweep
-#:, the re-anchor pass, and the document sweep
-#:. A claim a person retired is not among them, and a record
+#: The retirements an autonomous pass writes: rung 2.5 and its sweep,
+#: the re-anchor pass, and the document sweep.
+#: A claim a person retired is not among them, and a record
 #: behind one stays with review.
 AUTONOMOUS_RETIREMENTS: frozenset[StatusReason] = frozenset(
     {

{linkedparticles_core-1.192.2 → linkedparticles_core-1.192.28}/particles/core/observer_scope.py

@@ -158,6 +158,26 @@ def meet(premises: Iterable[BeliefScope]) -> BeliefScope:
     return BeliefScope(keys=keys, lapsed=lapsed and not keys)
 
 
+def join(members: Iterable[BeliefScope]) -> BeliefScope:
+    """The scope a ``CO_EVIDENTIAL`` merge gives every sourced member: their union.
+
+    The join pools the group's attesting entries, so the merged
+    scope is global as soon as one member is, and otherwise the union of their
+    keys. A union with no keys is in view for no project; it is reported as
+    lapsed when some member was lapsed, which is a reading for display only,
+    since the pooled entries decide between lapsed and unattributed. Applies to
+    sourced beliefs: a derived belief keeps the meet of its premises.
+    """
+    keys: set[str] = set()
+    lapsed = False
+    for member in members:
+        if member.is_global:
+            return GLOBAL_SCOPE
+        keys |= member.keys
+        lapsed = lapsed or member.lapsed
+    return BeliefScope(keys=frozenset(keys), lapsed=lapsed and not keys)
+
+
 def visible(scope: BeliefScope, observer_project: str | None, *, widened: bool = False) -> bool:
     """The predicate: is a belief with ``scope`` in view for this observer?
 
@@ -187,6 +207,30 @@ def share_an_observer(a: BeliefScope, b: BeliefScope) -> bool:
     return bool(a.keys & b.keys)
 
 
+def same_scope(a: BeliefScope, b: BeliefScope) -> bool:
+    """Whether two beliefs have exactly the same observers: the agent link test.
+
+    A ``CO_EVIDENTIAL`` edge unions the two groups' sources, so it leaves both
+    scopes unchanged only when they are already equal. Visibility is not
+    enough: a project's belief linked to a global one becomes global. Lapsed
+    and unattributed are distinct readings and only equal themselves.
+    """
+    if a.is_global or b.is_global:
+        return a.is_global and b.is_global
+    if a.keys or b.keys:
+        return a.keys == b.keys
+    return a.lapsed == b.lapsed
+
+
+def describe_scope(scope: BeliefScope) -> str:
+    """A short operator-facing reading of a scope, for refusals and reports."""
+    if scope.is_global:
+        return "global"
+    if scope.keys:
+        return "project " + ", ".join(sorted(scope.keys))
+    return "lapsed" if scope.lapsed else "unattributed"
+
+
 class PairPrecondition(StrEnum):
     """Whether a (candidate, existing) pair may be reconciled."""
 

{linkedparticles_core-1.192.2 → linkedparticles_core-1.192.28}/particles/core/status.py

@@ -81,8 +81,11 @@ _ALLOWED: frozenset[tuple[Status | None, Status]] = frozenset(
         (Status.ACTIVE, Status.SUPERSEDED),
         (Status.ACTIVE, Status.RETRACTED),
         (Status.ACTIVE, Status.PROVENANCE_STALE),
-        (Status.INCONSISTENCY, Status.PROVENANCE_STALE),  # PREFER A/B: loser demoted
-        (Status.INCONSISTENCY, Status.RETRACTED),  # BOTH VALID: INCONSISTENCY particle retracted
+        # Every non-DEFER resolution retracts the record (§6.6 wrapper-terminal
+        # rule): review, the trust cascade, the held-claim release and the
+        # disclosure sweep. There is no INCONSISTENCY → PROVENANCE_STALE edge;
+        # the cascade wrote one until 1.192.15 (migration 053).
+        (Status.INCONSISTENCY, Status.RETRACTED),
         (Status.INCONSISTENCY, Status.INCONSISTENCY),  # DEFER: re-set same status
         (Status.PROVENANCE_STALE, Status.SUPERSEDED),  # Reindex supersession of stale particle
         (Status.PROVENANCE_STALE, Status.RETRACTED),  # Explicit operator cleanup

{linkedparticles_core-1.192.2 → linkedparticles_core-1.192.28}/particles/embeddings.py

@@ -26,6 +26,7 @@ from __future__ import annotations
 import contextlib
 import logging
 import threading
+from collections.abc import Sequence
 from dataclasses import dataclass
 from typing import Any
 
@@ -134,6 +135,31 @@ def cosine_similarity(
     return max(0.0, min(1.0, raw))
 
 
+def cosine_similarities(
+    query: np.ndarray[Any, np.dtype[np.floating[Any]]],
+    vectors: Sequence[np.ndarray[Any, np.dtype[np.floating[Any]]]],
+) -> list[float]:
+    """:func:`cosine_similarity` of ``query`` against each vector, in one pass.
+
+    The same formula, the same ``1e-10`` epsilon and the same ``[0, 1]`` clamp,
+    computed over a stacked matrix instead of once per pair: on the
+    query-latency baseline the per-pair loop cost 81 ms at 56k candidates and
+    the matrix form 6 ms. A value can differ from the per-pair one in its last
+    bit, because the dot products are summed in another order. Each row is
+    reduced by the same loop wherever it sits in the matrix (``einsum``, not a
+    BLAS kernel that blocks rows by position), so two identical vectors always
+    get identical scores and keep their tie.
+    """
+    if not vectors:
+        return []
+    matrix = np.stack(vectors)
+    dots = np.einsum("ij,j->i", matrix, query)
+    norms = np.sqrt(np.einsum("ij,ij->i", matrix, matrix))
+    raw = dots / (norms * np.linalg.norm(query) + 1e-10)
+    clamped: list[float] = np.clip(raw, 0.0, 1.0).tolist()
+    return clamped
+
+
 class EmbeddingModel:
     """Protocol-compatible wrapper around sentence-transformers SentenceTransformer."""