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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: linkedparticles-core
-Version: 1.190.0
+Version: 1.192.2
 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

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

@@ -1096,10 +1096,18 @@ class ExtractionValidityConfig(BaseModel):
     a structural decision (does a boundary exist?), never the stored
     ``confidence.value``. ``enabled: false`` reproduces the pre-0197
     behaviour exactly (no candidate ever carries ``valid_until`` from extraction).
+
+    ``session_source_types`` names the source types a harness deposits as a
+    session transcript. For those, the extractor may anchor a
+    past-tense claim reporting an act performed *in the session* at the
+    reference date as an ``EVENT`` under the ``session`` basis, so a window
+    read finds what a session did; for every other source a past-tense claim
+    with no date gets no start. Empty disables the rule.
     """
 
     enabled: bool = True
     min_boundary_confidence: float = 0.75
+    session_source_types: list[str] = Field(default_factory=lambda: ["CONVERSATION"])
 
 
 class StructuredClaimConfig(BaseModel):
@@ -3081,6 +3089,15 @@ class AuditConfig(BaseModel):
     # 0 probes nothing (disclosed the same way). `particles lint` is not
     # affected: cost gating is the audit's concern, lint stays exhaustive.
     max_contradiction_probes: int = Field(default=50, ge=0)
+    # (the ruling, order, do not drop): under a probe
+    # cap the census probes the pairs some single reader sees first (the
+    # observer precondition reconciles or reviews them) and
+    # reserves this share of the cap for cross-scope pairs, two projects'
+    # claims the precondition declines, so a contradiction between projects
+    # is still discovered and recorded as OBSERVER_DIVERGENCE. A share neither
+    # side fills goes to the other. An ordering, never a filter; a store that
+    # was never rescoped, and uncapped `particles lint`, are not reordered.
+    cross_scope_probe_share: float = Field(default=0.2, ge=0.0, le=1.0)
     # read each pair the probe flagged a second time, on
     # ``llm.verification``, with each claim's source passage, note name and
     # note date, and count only the confirmed pairs in the headline. The report

{linkedparticles_core-1.190.0 → linkedparticles_core-1.192.2}/particles/core/conflict_resolution.py

@@ -699,6 +699,10 @@ def decide_ladder(
 # written and no cascade runs.
 RETIRED_VALUE_KEY = "conflict:retired_value"
 
+#: The ``properties`` key naming the ladder rung whose verdict opened an
+#: INCONSISTENCY record, ``name@version``.
+DECIDED_BY_KEY = "conflict:decided_by"
+
 
 def build_inconsistency_particle(
     existing: Particle,
@@ -709,6 +713,7 @@ def build_inconsistency_particle(
     asserted_by: str = "extract-pipeline",
     trigger_ref_type: ProvenanceRefType = ProvenanceRefType.SOURCE,
     retired_twin: bool = False,
+    decided_by: str | None = None,
 ) -> Particle:
     """Construct the INCONSISTENCY ``Particle`` for an unresolvable pair.
 
@@ -752,6 +757,10 @@ def build_inconsistency_particle(
         headline says so, and :data:`RETIRED_VALUE_KEY` carries the twin's
         ``status_reason`` in ``properties`` so Review can tell the two kinds
         of record apart.
+      - ``decided_by``: the stamp of the ladder rung whose
+        verdict opened the record, carried in ``properties`` under
+        :data:`DECIDED_BY_KEY`; ``None`` leaves it unstamped (a fail-closed
+        record no rung decided, or a retired-value hold).
     """
     # Inherit subject_ids from the existing particle (Particle A). Fall back
     # to the new particle's set if existing has none.
@@ -773,6 +782,8 @@ def build_inconsistency_particle(
             f"Particle A: {existing.id} — {existing.content[:120]}\n"
             f"Particle B (new): {new.content[:120]}"
         )
+    if decided_by is not None:
+        properties = {**(properties or {}), DECIDED_BY_KEY: decided_by}
 
     return Particle(
         content=inc_content,

linkedparticles_core-1.192.2/particles/core/ladders.py

@@ -0,0 +1,244 @@
+# SPDX-FileCopyrightText: 2026 The Particles authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""The engine's ladders: which rungs answer each question kind, in which order.
+
+Each function below declares one :class:`~particles.core.rung_ladder.Ladder`.
+The deterministic rungs carry their own ``decide`` and are defined here; the
+model rungs are declared with ``decide=None`` and bound in the shell to the
+completion they ask. A model rung's version is the prompt hash of the probe
+it stands for (:func:`~particles.core.probe_verdict.prompt_hash`), which the
+shell passes in, so a prompt edit changes the stamp every verdict carries.
+
+**The contradiction ladder** (the census, L-SEM-01):
+
+* ``adjudicability`` (pure): ``NO`` when either claim is not truth-apt,
+  read from the stored modality only.
+* ``generic_guard`` (pure): ``NO`` when exactly one claim is generic.
+* ``duplicate_key`` (local): ``NO`` when the two claims are the same sentence
+  under the §6.10 normalisation, whatever their subject sets and
+  holders; the full §6.10 identity is the narrower case of the same test.
+  A sentence does not contradict itself, and this case was 170 of the 200
+  pairs a capped census probed before the rung existed. The
+  census hands the rung a :class:`NormalizedForms` memo so each text is
+  normalised once per run, not once per pair.
+* ``contradiction_probe`` (model): the census probe.
+* ``second_reading`` (model, confirmation on ``YES``): the context-rich
+  second reading, whose verdict replaces the probe's.
+
+**The update ladder** (rung 2.5): ``update_slot`` (model,
+``semantic_lint``) and ``update_slot_second`` (model, ``verification``,
+confirmation on ``CHANGES``).
+
+**The duplicate ladder**: the ``duplicate_judge`` model rung.
+
+**The candidate ladder** (the abstraction gate):
+``population_quantifier`` (pure, ``NOT_ENTAILED`` on a kind-ranging
+quantifier) and the ``entailment_judge`` model rung.
+
+Pure: no I/O, no logging.
+"""
+
+from __future__ import annotations
+
+from particles.core.conflict_resolution import is_generic_instance_pair
+from particles.core.duplicate_key import normalize_content
+from particles.core.generics import population_quantifier
+from particles.core.rung_ladder import (
+    CandidateVerdict,
+    ContradictionVerdict,
+    CostClass,
+    DuplicateVerdict,
+    Ladder,
+    QuestionKind,
+    Rung,
+    UpdateVerdict,
+)
+from particles.core.schema import Particle, is_truth_apt
+
+__all__ = [
+    "ADJUDICABILITY",
+    "DUPLICATE_KEY",
+    "GENERIC_GUARD",
+    "POPULATION_QUANTIFIER",
+    "CandidateInput",
+    "ClaimPair",
+    "NormalizedForms",
+    "TextPair",
+    "candidate_ladder",
+    "contradiction_ladder",
+    "duplicate_key_rung",
+    "duplicate_ladder",
+    "update_ladder",
+]
+
+#: A pair of stored claims, as the census holds them.
+ClaimPair = tuple[Particle, Particle]
+#: Two claim texts, earlier first where the question is directional.
+TextPair = tuple[str, str]
+#: A candidate abstraction's text and its premises' texts.
+CandidateInput = tuple[str, tuple[str, ...]]
+
+
+def _adjudicability(pair: ClaimPair) -> ContradictionVerdict:
+    a, b = pair
+    if is_truth_apt(a) and is_truth_apt(b):
+        return ContradictionVerdict.ABSTAIN
+    return ContradictionVerdict.NO
+
+
+def _generic_guard(pair: ClaimPair) -> ContradictionVerdict:
+    if is_generic_instance_pair(*pair):
+        return ContradictionVerdict.NO
+    return ContradictionVerdict.ABSTAIN
+
+
+class NormalizedForms:
+    """Each claim's §6.10 normalised text, computed once per particle id.
+
+    The duplicate-key rung compares two normalised texts, and a census asks it
+    of every candidate pair the pure rungs let through: some 2.66 million
+    pairs over 55,578 distinct texts on the owner's store, so normalising per
+    pair did the same work fifty times over. The shell makes one of these per
+    run and hands it to :func:`duplicate_key_rung`; the rung reads a claim's
+    form through it and the first read computes it. A memo of a pure function
+    over the particle's own text: no I/O, and the same answer whoever asks.
+    """
+
+    def __init__(self) -> None:
+        self._forms: dict[str, str] = {}
+
+    def of(self, particle: Particle) -> str:
+        """``normalize_content`` of the particle's text, computed on first read."""
+        form = self._forms.get(particle.id)
+        if form is None:
+            form = self._forms[particle.id] = normalize_content(particle.content)
+        return form
+
+    def __len__(self) -> int:
+        return len(self._forms)
+
+
+def duplicate_key_rung(
+    forms: NormalizedForms | None = None,
+) -> Rung[ClaimPair, ContradictionVerdict]:
+    """The duplicate-key rung, reading normalised texts through ``forms`` when given.
+
+    With no memo each call normalises both texts afresh, which is
+    :data:`DUPLICATE_KEY`; the verdict is the same either way.
+    """
+
+    def decide(pair: ClaimPair) -> ContradictionVerdict:
+        a, b = pair
+        if forms is None:
+            same = normalize_content(a.content) == normalize_content(b.content)
+        else:
+            same = forms.of(a) == forms.of(b)
+        return ContradictionVerdict.NO if same else ContradictionVerdict.ABSTAIN
+
+    return Rung(name="duplicate_key", version="1", cost=CostClass.LOCAL, decide=decide)
+
+
+#: Neither claim is a truth-apt claim, so there is no shared truth to contradict.
+ADJUDICABILITY: Rung[ClaimPair, ContradictionVerdict] = Rung(
+    name="adjudicability",
+    version="1",
+    cost=CostClass.PURE,
+    decide=_adjudicability,
+    # Reads each record's stored modality, not its text.
+    content_keyed=False,
+)
+#: A generic against an instance claim is not an adjudicable pair.
+GENERIC_GUARD: Rung[ClaimPair, ContradictionVerdict] = Rung(
+    name="generic_guard", version="1", cost=CostClass.PURE, decide=_generic_guard
+)
+#: The same sentence twice is not a contradiction (normalisation).
+DUPLICATE_KEY: Rung[ClaimPair, ContradictionVerdict] = duplicate_key_rung()
+
+
+def contradiction_ladder(
+    probe_version: str,
+    reading_version: str,
+    *,
+    forms: NormalizedForms | None = None,
+) -> Ladder[ClaimPair, ContradictionVerdict]:
+    """The census's contradiction ladder at the given prompt versions.
+
+    ``forms`` is the run's memo of normalised texts for the duplicate-key rung
+    (:class:`NormalizedForms`); without one the rung normalises per pair.
+    """
+    return Ladder(
+        kind=QuestionKind.CONTRADICTION,
+        abstain=ContradictionVerdict.ABSTAIN,
+        rungs=(
+            ADJUDICABILITY,
+            GENERIC_GUARD,
+            DUPLICATE_KEY if forms is None else duplicate_key_rung(forms),
+            Rung(name="contradiction_probe", version=probe_version, cost=CostClass.MODEL),
+            Rung(
+                name="second_reading",
+                version=reading_version,
+                cost=CostClass.MODEL,
+                confirms=frozenset({ContradictionVerdict.YES.value}),
+            ),
+        ),
+    )
+
+
+def update_ladder(version: str) -> Ladder[TextPair, UpdateVerdict]:
+    """The update probe as a two-rung ladder with a confirmation rung.
+
+    The first reading answers; a first ``CHANGES`` is read again on
+    ``verification`` and the second reading's verdict, abstention included,
+    replaces it, so rung 2.5 retires only on two ``CHANGES``.
+    """
+    return Ladder(
+        kind=QuestionKind.UPDATE,
+        abstain=UpdateVerdict.ABSTAIN,
+        rungs=(
+            Rung(name="update_slot", version=version, cost=CostClass.MODEL),
+            Rung(
+                name="update_slot_second",
+                version=version,
+                cost=CostClass.MODEL,
+                confirms=frozenset({UpdateVerdict.CHANGES.value}),
+            ),
+        ),
+    )
+
+
+def duplicate_ladder(version: str) -> Ladder[TextPair, DuplicateVerdict]:
+    """The curation duplicate judge as a one-rung ladder."""
+    return Ladder(
+        kind=QuestionKind.DUPLICATE,
+        abstain=DuplicateVerdict.ABSTAIN,
+        rungs=(Rung(name="duplicate_judge", version=version, cost=CostClass.MODEL),),
+    )
+
+
+def _population_quantifier(item: CandidateInput) -> CandidateVerdict:
+    if population_quantifier(item[0]) is not None:
+        return CandidateVerdict.NOT_ENTAILED
+    return CandidateVerdict.ABSTAIN
+
+
+#: A claim ranging over a kind is not entailed by claims about its members.
+POPULATION_QUANTIFIER: Rung[CandidateInput, CandidateVerdict] = Rung(
+    name="population_quantifier",
+    version="1",
+    cost=CostClass.PURE,
+    decide=_population_quantifier,
+)
+
+
+def candidate_ladder(judge_version: str) -> Ladder[CandidateInput, CandidateVerdict]:
+    """The abstraction gate: the deterministic pre-check, then the entailment judge."""
+    return Ladder(
+        kind=QuestionKind.ENTAILMENT,
+        abstain=CandidateVerdict.ABSTAIN,
+        rungs=(
+            POPULATION_QUANTIFIER,
+            Rung(name="entailment_judge", version=judge_version, cost=CostClass.MODEL),
+        ),
+    )

{linkedparticles_core-1.190.0 → linkedparticles_core-1.192.2}/particles/core/probe_verdict.py

@@ -23,6 +23,8 @@ operations that consult it:
   clear it, so no new call is needed.
 * :func:`subject_link_key` keys the one kind that is not a pair of claims: the
   subject-link judge's pick among a name's Wikidata candidates.
+* :func:`rung_kind` names the record set of a deterministic ladder rung,
+  whose verdicts the ledger keeps beside the probes'.
 
 An edit to either claim changes its content hash and misses the record, and a
 prompt change misses too. Pure: no I/O, no logging.
@@ -37,10 +39,12 @@ from enum import StrEnum
 from particles.core.duplicate_key import content_hash
 
 __all__ = [
+    "RUNG_KIND_PREFIX",
     "ProbeKind",
     "VerdictKey",
     "prompt_hash",
     "remembered_clear",
+    "rung_kind",
     "subject_link_key",
     "verdict_key",
 ]
@@ -78,6 +82,22 @@ _SYMMETRIC = frozenset(
 )
 
 
+#: The ``probe_kind`` prefix of a deterministic rung's ledger rows.
+RUNG_KIND_PREFIX = "rung:"
+
+
+def rung_kind(name: str) -> str:
+    """The ledger kind a deterministic rung's verdicts are recorded under: one per rung.
+
+    A model rung records under its probe's own :class:`ProbeKind`; every other
+    rung under ``rung:<name>``, so each rung's rows are its own record set.
+    """
+    kind = f"{RUNG_KIND_PREFIX}{name}"
+    if len(kind) > 32:
+        raise ValueError(f"rung name too long for the ledger: {name!r}")
+    return kind
+
+
 def prompt_hash(*parts: str) -> str:
     """A short, stable version string for a prompt rendered with placeholders.