chimera-memory-types 0.1.0__py3-none-any.whl

chimera_memory_types/__init__.py

@@ -0,0 +1,47 @@
+"""chimera-memory-types — minimal public schema types for chimera-memory."""
+
+from chimera_memory_types.falsifier import Falsifier, SettlementWindow
+from chimera_memory_types.finding import EvidenceRef, EvidenceRefType
+from chimera_memory_types.knowledge import (
+    Claim,
+    ClaimStatus,
+    ClaimType,
+    EvidenceBundle,
+)
+from chimera_memory_types.optimization import Intervention
+from chimera_memory_types.reality_class import RealityClass, SubstrateLayer
+from chimera_memory_types.settlement import (
+    ScoreConfig,
+    ScoredOutcome,
+    ScoreFamily,
+    SettlementEvent,
+    SettlementRecord,
+    SettlementState,
+    SettlementStatus,
+)
+from chimera_memory_types.temporal import LeakageStatus, TemporalSeal
+from chimera_memory_types.warrant import Warrant
+
+__all__ = [
+    "Claim",
+    "ClaimStatus",
+    "ClaimType",
+    "EvidenceBundle",
+    "EvidenceRef",
+    "EvidenceRefType",
+    "Falsifier",
+    "Intervention",
+    "LeakageStatus",
+    "RealityClass",
+    "ScoreConfig",
+    "ScoreFamily",
+    "ScoredOutcome",
+    "SettlementEvent",
+    "SettlementRecord",
+    "SettlementState",
+    "SettlementStatus",
+    "SettlementWindow",
+    "SubstrateLayer",
+    "TemporalSeal",
+    "Warrant",
+]

chimera_memory_types/falsifier.py

@@ -0,0 +1,27 @@
+"""Falsifier schema models."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+
+class SettlementWindow(BaseModel):
+    opens_at: datetime | None = None
+    closes_at: datetime | None = None
+    max_delay_seconds: int | None = Field(default=None, ge=0)
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class Falsifier(BaseModel):
+    predicate: str
+    predicate_kind: Literal["threshold", "boolean", "membership", "absence"]
+    settlement_window: SettlementWindow | None = None
+    vacuous: bool = False
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+    def require_promotable(self) -> None:
+        if self.vacuous:
+            raise ValueError("vacuous falsifier cannot be promoted")

chimera_memory_types/finding.py

@@ -0,0 +1,89 @@
+"""Finding, EvidencePack, Scorecard — the output contracts of a run."""
+
+import uuid
+from datetime import UTC, datetime
+from enum import StrEnum
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+
+class FindingSeverity(StrEnum):
+    BLOCKER = "blocker"
+    WARNING = "warning"
+    INFO = "info"
+
+
+class EvidenceRefType(StrEnum):
+    """Discriminant for a typed evidence reference."""
+
+    SESSION = "session"
+    ARTIFACT = "artifact"
+    SPAN = "span"
+    FINDING = "finding"
+    RUN = "run"
+    EXTERNAL = "external"
+
+
+class EvidenceRef(BaseModel):
+    """Typed, machine-parseable reference to a piece of evidence."""
+
+    ref_type: EvidenceRefType
+    ref_id: str
+    available_at: datetime | None = None
+    content_hash: str | None = None
+
+
+class BaselineComparison(BaseModel):
+    baseline_run_id: str
+    was_present_in_baseline: bool
+    severity_change: Literal["new", "worsened", "unchanged", "improved"] | None = None
+    delta_summary: str | None = None
+
+
+class Finding(BaseModel):
+    finding_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    run_id: str
+    severity: FindingSeverity
+    category: str
+    title: str
+    summary: str
+    evidence_refs: list[str] = []
+    typed_evidence_refs: list[EvidenceRef] = []
+    reproduction_path: list[str] = []
+    affected_segments: list[str] = []
+    root_cause_hypothesis: str | None = None
+    suggested_fix: str | None = None
+    confidence: float = Field(ge=0.0, le=1.0)
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    baseline_comparison: BaselineComparison | None = None
+    branch_id: str | None = None
+    divergence_point: int | None = None
+    branch_lineage_ref: str | None = None
+    determinism_certificate_id: str | None = None
+
+
+class ArtifactRef(BaseModel):
+    artifact_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    artifact_type: str
+    storage_uri: str
+    content_hash: str
+    run_id: str
+
+
+class Scorecard(BaseModel):
+    run_id: str
+    overall_result: Literal["pass", "block", "review_required"]
+    metric_results: dict[str, float] = {}
+    rule_results: dict[str, Any] = {}
+    finding_count_by_severity: dict[str, int] = {}
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+
+class EvidencePack(BaseModel):
+    evidence_pack_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    run_id: str
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    artifact_refs: list[ArtifactRef] = []
+    span_refs: list[str] = []
+    scorecard: Scorecard | None = None

chimera_memory_types/knowledge.py

@@ -0,0 +1,176 @@
+"""Knowledge layer contracts for chimera-memory-types."""
+
+from __future__ import annotations
+
+import uuid
+from datetime import UTC, datetime
+from enum import StrEnum
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+from chimera_memory_types.falsifier import Falsifier
+from chimera_memory_types.finding import EvidenceRef
+from chimera_memory_types.optimization import Intervention
+from chimera_memory_types.reality_class import RealityClass
+from chimera_memory_types.settlement import SettlementState
+from chimera_memory_types.temporal import TemporalSeal
+from chimera_memory_types.warrant import Warrant
+
+
+class ClaimType(StrEnum):
+    INTERVENTION_EFFECT = "intervention_effect"
+    FAILURE_PATTERN = "failure_pattern"
+    REGRESSION_RISK = "regression_risk"
+    TRADEOFF_PATTERN = "tradeoff_pattern"
+    DOMINANCE_PATTERN = "dominance_pattern"
+    BACKTESTED_PREDICTION = "backtested_prediction"
+    CAUSAL_POINT = "causal_point"
+    CAUSAL_BOUNDED = "causal_bounded"
+    NEGATIVE = "negative"
+    ADMISSIBLE_WORLD = "admissible_world"
+    UNANSWERABLE = "unanswerable"
+
+
+class ClaimStatus(StrEnum):
+    PROPOSED = "proposed"
+    SUPPORTED = "supported"
+    VALIDATED = "validated"
+    STALE = "stale"
+    CONTRADICTED = "contradicted"
+    REJECTED = "rejected"
+
+
+class DriftStatus(StrEnum):
+    FRESH = "fresh"
+    AGING = "aging"
+    STALE = "stale"
+    CONTRADICTED = "contradicted"
+
+
+class PatternType(StrEnum):
+    REPEATED_FINDING = "repeated_finding"
+    REPEATED_SUCCESS = "repeated_success"
+    REPEATED_FAILURE = "repeated_failure"
+    REPEATED_TRADEOFF = "repeated_tradeoff"
+    DOMINANCE_CLUSTER = "dominance_cluster"
+
+
+class EvidenceBundle(BaseModel):
+    """A traceable collection of evidence linked to a Claim or Pattern."""
+
+    bundle_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    run_ids: list[str] = Field(default_factory=list)
+    finding_ids: list[str] = Field(default_factory=list)
+    recommendation_ids: list[str] = Field(default_factory=list)
+    branch_refs: list[str] = Field(default_factory=list)
+    artifact_refs: list[str] = Field(default_factory=list)
+    evidence_refs: list[EvidenceRef] = Field(default_factory=list)
+    summary: str = ""
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    reality_class: RealityClass = RealityClass.INFERRED
+
+
+class ValidityRange(BaseModel):
+    world_types: list[str] = Field(default_factory=list)
+    context_signature_ids: list[str] = Field(default_factory=list)
+    min_evidence_count: int = 1
+    expires_after_runs: int | None = None
+    scope_note: str = ""
+
+
+class ContextSignature(BaseModel):
+    signature_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    world_type: str
+    target_class: str | None = None
+    actor_mix: dict[str, Any] = Field(default_factory=dict)
+    scenario_family: str | None = None
+    mutation_family: str | None = None
+    objective_family: str | None = None
+    complexity_bucket: str | None = None
+    resource_regime: dict[str, Any] = Field(default_factory=dict)
+    dimensions: dict[str, Any] = Field(default_factory=dict)
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+
+class Claim(BaseModel):
+    """An evidence-backed assertion about world behavior."""
+
+    claim_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    claim_type: ClaimType
+    claim_status: ClaimStatus = ClaimStatus.PROPOSED
+    title: str
+    summary: str
+    evidence: EvidenceBundle
+    context_signature_id: str | None = None
+    validity_range: ValidityRange = Field(default_factory=ValidityRange)
+    confidence: float = Field(ge=0.0, le=1.0, default=0.5)
+    formal_statement: str | None = None
+    temporal_seal: TemporalSeal | None = None
+    warrant: Warrant | None = None
+    falsifier: Falsifier | None = None
+    settlement: SettlementState | None = None
+    world_version: str | None = None
+    model_version: str | None = None
+    registry_record_id: str | None = None
+    drift_status: DriftStatus = DriftStatus.FRESH
+    supporting_run_ids: list[str] = Field(default_factory=list)
+    contradicting_run_ids: list[str] = Field(default_factory=list)
+    linked_intervention_ids: list[str] = Field(default_factory=list)
+    linked_pattern_ids: list[str] = Field(default_factory=list)
+    world_type: str
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    updated_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    metadata: dict[str, Any] = Field(default_factory=dict)
+    reality_class: RealityClass = RealityClass.INFERRED
+
+
+class Pattern(BaseModel):
+    pattern_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    pattern_type: PatternType
+    title: str
+    description: str
+    supporting_claim_ids: list[str] = Field(default_factory=list)
+    occurrence_count: int = 1
+    world_type: str
+    context_signature_id: str | None = None
+    confidence: float = Field(ge=0.0, le=1.0, default=0.5)
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    metadata: dict[str, Any] = Field(default_factory=dict)
+    reality_class: RealityClass = RealityClass.INFERRED
+
+
+class InterventionEvaluation(BaseModel):
+    optimization_run_id: str
+    candidate_id: str
+    score_delta: dict[str, float] = Field(default_factory=dict)
+    status: str = "scored"
+    rank: int | None = None
+    accepted: bool = False
+    evaluated_at: datetime | None = None
+
+
+class InterventionMemory(BaseModel):
+    memory_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    intervention: Intervention
+    world_type: str
+    context_signature_id: str | None = None
+    evaluations: list[InterventionEvaluation] = Field(default_factory=list)
+    claim_ids: list[str] = Field(default_factory=list)
+    pattern_ids: list[str] = Field(default_factory=list)
+    times_tried: int = 0
+    times_succeeded: int = 0
+    times_failed: int = 0
+    times_dominated: int = 0
+    last_evaluated_at: datetime | None = None
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class KnowledgeRef(BaseModel):
+    ref_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    ref_type: Literal["claim", "pattern", "intervention_memory"]
+    ref_target_id: str
+    world_type: str
+    context_note: str = ""
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))

chimera_memory_types/optimization.py

@@ -0,0 +1,161 @@
+"""Optimization and decision layer contracts."""
+
+from __future__ import annotations
+
+import uuid
+from datetime import UTC, datetime
+from enum import StrEnum
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+
+class OptimizationStatus(StrEnum):
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+OPTIMIZATION_STATUS_TRANSITIONS: dict[OptimizationStatus, set[OptimizationStatus]] = {
+    OptimizationStatus.PENDING: {OptimizationStatus.RUNNING, OptimizationStatus.CANCELLED},
+    OptimizationStatus.RUNNING: {
+        OptimizationStatus.COMPLETED,
+        OptimizationStatus.FAILED,
+        OptimizationStatus.CANCELLED,
+    },
+    OptimizationStatus.COMPLETED: set(),
+    OptimizationStatus.FAILED: set(),
+    OptimizationStatus.CANCELLED: set(),
+}
+
+
+def validate_optimization_status_transition(
+    current: OptimizationStatus,
+    target: OptimizationStatus,
+) -> None:
+    allowed = OPTIMIZATION_STATUS_TRANSITIONS.get(current, set())
+    if target not in allowed:
+        raise ValueError(f"Invalid OptimizationStatus transition: {current.value} → {target.value}")
+
+
+class Intervention(BaseModel):
+    """A generic change applied to a world snapshot."""
+
+    intervention_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    intervention_type: str
+    target: str
+    parameters: dict[str, Any] = Field(default_factory=dict)
+    label: str = ""
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class InterventionSet(BaseModel):
+    set_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    label: str
+    interventions: list[Intervention]
+    world_type: str
+    version: str = "0.1.0"
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class CandidateIntervention(BaseModel):
+    candidate_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    intervention: Intervention
+    run_id: str | None = None
+    score_delta: dict[str, float] = Field(default_factory=dict)
+    scorecard: dict[str, Any] = Field(default_factory=dict)
+    rank: int | None = None
+    status: Literal["pending", "running", "simulation_launched", "scored", "failed", "skipped"] = (
+        "pending"
+    )
+    error: str | None = None
+    evaluated_at: datetime | None = None
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class Constraint(BaseModel):
+    constraint_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    label: str
+    metric: str
+    operator: Literal["gte", "lte", "gt", "lt", "eq", "neq"]
+    threshold: float
+
+
+class Objective(BaseModel):
+    objective_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    label: str
+    metric: str
+    direction: Literal["maximize", "minimize"]
+    weight: float = 1.0
+
+
+class SearchStrategy(StrEnum):
+    NONE = "none"
+    RANDOM = "random"
+    GRID = "grid"
+
+
+class OptimizationSpec(BaseModel):
+    spec_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    world_type: str
+    snapshot_id: str
+    baseline_run_id: str
+    objectives: list[Objective]
+    constraints: list[Constraint] = Field(default_factory=list)
+    candidates: list[CandidateIntervention]
+    search_budget: int = 20
+    seed: int = 0
+    search_strategy: SearchStrategy = SearchStrategy.NONE
+    warm_start_candidates: list[Intervention] = Field(default_factory=list)
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class Recommendation(BaseModel):
+    recommendation_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    title: str
+    summary: str
+    intervention: Intervention
+    evidence_run_ids: list[str]
+    tradeoffs: dict[str, Any] = Field(default_factory=dict)
+    confidence: float = Field(ge=0.0, le=1.0)
+    rank: int
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+
+class TradeoffSummary(BaseModel):
+    summary_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    optimization_run_id: str
+    dominated_pairs: list[dict[str, Any]] = Field(default_factory=list)
+    pareto_front_candidate_ids: list[str] = Field(default_factory=list)
+    metric_improvements: dict[str, int] = Field(default_factory=dict)
+    narrative: str = ""
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+
+class OptimizationResult(BaseModel):
+    result_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    optimization_run_id: str
+    top_candidates: list[CandidateIntervention]
+    recommendations: list[Recommendation]
+    tradeoff_summary: TradeoffSummary | None = None
+    candidates_evaluated: int
+    candidates_skipped: int
+    status: OptimizationStatus
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+
+
+class DecisionMemoryEntry(BaseModel):
+    entry_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    optimization_run_id: str
+    candidate_id: str
+    intervention: Intervention
+    world_type: str
+    snapshot_id: str
+    run_id: str
+    score_delta: dict[str, float] = Field(default_factory=dict)
+    passed_constraints: bool = True
+    rank: int | None = None
+    context: dict[str, Any] = Field(default_factory=dict)
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))

chimera_memory_types/reality_class.py

@@ -0,0 +1,35 @@
+"""Reality classification enum for chimera-memory-types.
+
+Standalone copy — no chimera_substrate dependency.
+"""
+
+from __future__ import annotations
+
+from enum import StrEnum
+
+
+class RealityClass(StrEnum):
+    """Explicit classification of what kind of truth a record represents."""
+
+    OBSERVED = "observed"
+    SIMULATED = "simulated"
+    COUNTERFACTUAL = "counterfactual"
+    INFERRED = "inferred"
+    RECOMMENDED = "recommended"
+
+    @classmethod
+    def require(cls, value: RealityClass | str | None) -> RealityClass:
+        if value is None:
+            raise ValueError("reality_class is required.")
+        if isinstance(value, cls):
+            return value
+        return cls(value)
+
+
+class SubstrateLayer(StrEnum):
+    """Which logical substrate layer produced or owns a record."""
+
+    CANONICAL = "canonical"
+    SIGNAL = "signal"
+    PROJECTION = "projection"
+    CONTROL = "control"

chimera_memory_types/settlement.py

@@ -0,0 +1,81 @@
+"""Settlement and wealth bookkeeping schema models."""
+
+from __future__ import annotations
+
+import uuid
+from datetime import UTC, datetime
+from enum import StrEnum
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class ScoreFamily(StrEnum):
+    BRIER = "brier"
+    LOG = "log"
+    CRPS_GAUSSIAN = "crps_gaussian"
+    CRPS_ENSEMBLE = "crps_ensemble"
+    INTERVAL = "interval"
+    NEGATIVE_DEPTH = "negative_depth"
+
+
+class ScoreConfig(BaseModel):
+    family: ScoreFamily = ScoreFamily.BRIER
+    params: dict[str, Any] = Field(default_factory=dict)
+
+
+class ScoredOutcome(BaseModel):
+    value: Any
+    observed_at: datetime | None = None
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class SettlementStatus(StrEnum):
+    PENDING = "pending"
+    SETTLED = "settled"
+    VALIDATED = "validated"
+    CONTRADICTED = "contradicted"
+    INCONCLUSIVE = "inconclusive"
+
+
+class SettlementEvent(BaseModel):
+    event_key: str
+    observed_at: datetime
+    outcome: Any
+    source_ref: str | None = None
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class WealthUpdate(BaseModel):
+    event_key: str
+    proper_score: float | None = None
+    wealth_multiplier: float = Field(default=1.0, gt=0.0)
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class WealthState(BaseModel):
+    wealth: float = Field(default=1.0, gt=0.0)
+    log_wealth: float = 0.0
+    updates: list[WealthUpdate] = Field(default_factory=list)
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class SettlementState(BaseModel):
+    status: SettlementStatus = SettlementStatus.PENDING
+    score_config: ScoreConfig = Field(default_factory=ScoreConfig)
+    events: list[SettlementEvent] = Field(default_factory=list)
+    scored_outcomes: list[ScoredOutcome] = Field(default_factory=list)
+    proper_score: float | None = None
+    wealth: WealthState = Field(default_factory=WealthState)
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class SettlementRecord(BaseModel):
+    record_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    claim_id: str
+    settlement: SettlementState
+    content_hash: str | None = None
+    signature: str | None = None
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    metadata: dict[str, Any] = Field(default_factory=dict)

chimera_memory_types/temporal.py

@@ -0,0 +1,43 @@
+"""Temporal sealing schema models."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from enum import StrEnum
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class LeakageStatus(StrEnum):
+    CLEAN = "clean"
+    POISONED = "poisoned"
+
+
+class TemporalSeal(BaseModel):
+    seal_id: str | None = None
+    claim_time: datetime
+    evidence_window_start: datetime | None = None
+    evidence_window_end: datetime | None = None
+    outcome_time: datetime | None = None
+    leakage_status: LeakageStatus = LeakageStatus.CLEAN
+    metadata: dict[str, str] = Field(default_factory=dict)
+
+    @model_validator(mode="after")
+    def compute_leakage_status(self) -> TemporalSeal:
+        if self.claim_time.tzinfo is None:
+            self.claim_time = self.claim_time.replace(tzinfo=UTC)
+        if self.evidence_window_start is not None and self.evidence_window_start.tzinfo is None:
+            self.evidence_window_start = self.evidence_window_start.replace(tzinfo=UTC)
+        if self.evidence_window_end is not None and self.evidence_window_end.tzinfo is None:
+            self.evidence_window_end = self.evidence_window_end.replace(tzinfo=UTC)
+        if self.outcome_time is not None and self.outcome_time.tzinfo is None:
+            self.outcome_time = self.outcome_time.replace(tzinfo=UTC)
+
+        poisoned = False
+        if self.evidence_window_end is not None:
+            poisoned = self.evidence_window_end > self.claim_time
+        if self.outcome_time is not None:
+            poisoned = poisoned or self.outcome_time <= self.claim_time
+
+        self.leakage_status = LeakageStatus.POISONED if poisoned else LeakageStatus.CLEAN
+        return self

chimera_memory_types/warrant.py

@@ -0,0 +1,52 @@
+"""Warrant schema models."""
+
+from __future__ import annotations
+
+from enum import StrEnum
+from typing import Any
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class ComputabilityVerdict(StrEnum):
+    COMPUTABLE = "computable"
+    APPROXIMABLE = "approximable"
+    UNCOMPUTABLE = "uncomputable"
+
+
+class CausalVerdict(StrEnum):
+    IDENTIFIED = "identified"
+    BOUNDED = "bounded"
+    UNIDENTIFIABLE = "unidentifiable"
+
+
+class ExperimentSpec(BaseModel):
+    name: str
+    design: str
+    assignment_unit: str | None = None
+    outcome_metric: str | None = None
+    minimum_sample_size: int | None = Field(default=None, ge=1)
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class Warrant(BaseModel):
+    computability: ComputabilityVerdict = ComputabilityVerdict.COMPUTABLE
+    causal_verdict: CausalVerdict
+    estimand: str | None = None
+    bounds: tuple[float, float] | None = None
+    experiment_spec: ExperimentSpec | None = None
+    assumptions: list[str] = Field(default_factory=list)
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+    @model_validator(mode="after")
+    def validate_verdict_requirements(self) -> Warrant:
+        if self.causal_verdict is CausalVerdict.IDENTIFIED and self.estimand is None:
+            raise ValueError("IDENTIFIED warrant requires estimand")
+        if self.causal_verdict is CausalVerdict.BOUNDED and self.bounds is None:
+            raise ValueError("BOUNDED warrant requires bounds")
+        if (
+            self.causal_verdict is CausalVerdict.UNIDENTIFIABLE
+            and self.experiment_spec is None
+        ):
+            raise ValueError("UNIDENTIFIABLE warrant requires experiment_spec")
+        return self

chimera_memory_types-0.1.0.dist-info/METADATA

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: chimera-memory-types
+Version: 0.1.0
+Summary: Minimal schema types for chimera-memory — claims, settlements, evidence refs, and temporal seals
+License: MIT License
+        
+        Copyright (c) 2026 Chimera / ORIAS
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Requires-Dist: pydantic>=2.9.0

chimera_memory_types-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+chimera_memory_types/__init__.py,sha256=NarE4vdEbSRWnHD7hZa6p6CHMBUSn0KcVhqNY8JOd4g,1212
+chimera_memory_types/falsifier.py,sha256=vVuib4baCdJDvmYVY2p4TO-Iw1p-_-gKTCV868thbSo,804
+chimera_memory_types/finding.py,sha256=vXGrpl2yUpdR6feq7HNb3gU3r6ImJIHXZk6Z9MRAoUs,2585
+chimera_memory_types/knowledge.py,sha256=QnqEPfhzJp5Pr83MqoXDs8qQp633dkx2pC0bCMPa7nE,6438
+chimera_memory_types/optimization.py,sha256=Jkqa4b4qPp9RwAZp854nV07JUvg6b84CG2VU-zjiEOU,5234
+chimera_memory_types/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chimera_memory_types/reality_class.py,sha256=-PjmENypT4511ASj_JpcRAFbcZ4t6Hu33HknvV4In8E,902
+chimera_memory_types/settlement.py,sha256=fvTW_4mAJKNjbtZrUrZjbAfCiDhJ1TqJUtFYpl2VQ9U,2403
+chimera_memory_types/temporal.py,sha256=SdcXAb63cQ-jRiqu5X2_UMK5E4OB5VtZH4zKBwjJkyQ,1688
+chimera_memory_types/warrant.py,sha256=znIanJOvaAJOwvB5r9zzqzbnSg_5j3AzDFCLmqNAfXw,1701
+chimera_memory_types-0.1.0.dist-info/METADATA,sha256=RP8pk3tYfLFo8H4YziwhqxAp1H_5G7SDFS71rJsjI7g,1801
+chimera_memory_types-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+chimera_memory_types-0.1.0.dist-info/licenses/LICENSE,sha256=_SDgjN43B53BtJt-gcEICy1qICF5rkA2mzHRNarsz70,1072
+chimera_memory_types-0.1.0.dist-info/RECORD,,

chimera_memory_types-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

chimera_memory_types-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chimera / ORIAS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.