shellbrain 0.1.55__tar.gz → 0.1.57__tar.gz

{shellbrain-0.1.55 → shellbrain-0.1.57}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shellbrain
-Version: 0.1.55
+Version: 0.1.57
 Summary: Repo-scoped Shellbrain CLI with explicit evidence-backed writes.
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{shellbrain-0.1.55 → shellbrain-0.1.57}/app/core/entities/backups.py

@@ -31,15 +31,5 @@ class BackupManifest:
     compression: str
 
 
-@dataclass(frozen=True)
-class BackupVerificationResult:
-    """Stable result for a verified backup artifact."""
-
-    backup_id: BackupId
-    artifact_sha256: str
-    artifact_size_bytes: int
-    verified: bool
-
-
 class BackupPolicyError(RuntimeError):
     """Raised when a backup or restore request violates core safety policy."""

{shellbrain-0.1.55 → shellbrain-0.1.57}/app/core/entities/concepts.py

@@ -159,14 +159,6 @@ class ConceptCreatedBy(str, Enum):
     IMPORT = "import"
 
 
-class GraphPatchStatus(str, Enum):
-    """Allowed graph patch lifecycle states."""
-
-    PENDING = "pending"
-    APPLIED = "applied"
-    REJECTED = "rejected"
-
-
 @dataclass(frozen=True, kw_only=True)
 class Concept:
     """One durable concept container."""
@@ -311,18 +303,3 @@ class ConceptEvidence:
     transcript_ref: str | None = None
     note: str | None = None
     created_at: datetime | None = None
-
-
-@dataclass(frozen=True, kw_only=True)
-class GraphPatch:
-    """Minimal reserved future graph-patch proposal record."""
-
-    id: str
-    repo_id: str
-    schema_version: str
-    status: GraphPatchStatus
-    proposed_by: ConceptCreatedBy
-    operations_json: list[dict[str, Any]]
-    evidence_summary: str | None = None
-    created_at: datetime | None = None
-    applied_at: datetime | None = None

{shellbrain-0.1.55 → shellbrain-0.1.57}/app/core/entities/episodes.py

@@ -1,4 +1,4 @@
-"""This module defines episodic session entities and transfer provenance entities."""
+"""This module defines episodic session entities."""
 
 from dataclasses import dataclass
 from datetime import datetime
@@ -30,8 +30,6 @@ class Episode:
     repo_id: str
     host_app: str
     thread_id: str | None = None
-    title: str | None = None
-    objective: str | None = None
     status: EpisodeStatus = EpisodeStatus.ACTIVE
     started_at: datetime | None = None
     ended_at: datetime | None = None
@@ -77,18 +75,3 @@ class EpisodeEvent:
     source: EpisodeEventSource
     content: str
     created_at: datetime | None = None
-
-
-@dataclass(kw_only=True)
-class SessionTransfer:
-    """This dataclass models immutable cross-session transfer provenance."""
-
-    id: str
-    repo_id: str
-    from_episode_id: str
-    to_episode_id: str
-    event_id: str
-    transfer_kind: str
-    rationale: str | None = None
-    transferred_by: str | None = None
-    created_at: datetime | None = None

{shellbrain-0.1.55 → shellbrain-0.1.57}/app/core/entities/evidence.py

@@ -7,10 +7,8 @@ from datetime import datetime
 from enum import Enum
 
 from app.core.entities.ids import (
-    AssociationEdgeId,
     EvidenceId,
     EvidenceRefText,
-    MemoryId,
     RepoId,
 )
 
@@ -147,20 +145,6 @@ class EvidenceLinkView:
     created_at: datetime | None = None
 
 
-@dataclass(kw_only=True)
-class MemoryEvidenceLink:
-    """This dataclass models a many-to-many link between shellbrain and evidence."""
-
-    memory_id: MemoryId
-    evidence_id: EvidenceId
-
-
-@dataclass(kw_only=True)
-class AssociationEdgeEvidenceLink:
-    """This dataclass models a many-to-many link between association edges and evidence."""
-
-    edge_id: AssociationEdgeId
-    evidence_id: EvidenceId
 
 
 _SOURCE_REQUIRED_FIELD: dict[EvidenceSourceKind, str] = {

{shellbrain-0.1.55 → shellbrain-0.1.57}/app/core/entities/guidance.py

@@ -26,7 +26,6 @@ class GuidanceDecision:
     problem_id: str | None = None
     memory_ids: list[str] = field(default_factory=list)
     vote_scale_hint: dict[str, float] | None = None
-    setup_hint: str | None = None
 
     def to_payload(self) -> dict[str, Any]:
         """Serialize one guidance decision into the public response shape."""
@@ -42,6 +41,4 @@ class GuidanceDecision:
             payload["memory_ids"] = list(self.memory_ids)
         if self.vote_scale_hint is not None:
             payload["vote_scale_hint"] = dict(self.vote_scale_hint)
-        if self.setup_hint is not None:
-            payload["setup_hint"] = self.setup_hint
         return payload

{shellbrain-0.1.55 → shellbrain-0.1.57}/app/core/entities/identity.py

@@ -17,17 +17,6 @@ class IdentityTrustLevel(str, Enum):
 SUPPORTED_HOST_APPS = frozenset({"codex", "claude_code", "cursor"})
 
 
-def build_canonical_caller_id(
-    *, host_app: str, host_session_key: str, agent_key: str | None = None
-) -> str:
-    """Build the canonical caller identifier from one host session and optional agent key."""
-
-    canonical = f"{host_app}:{host_session_key}"
-    if agent_key:
-        canonical = f"{canonical}:agent:{agent_key}"
-    return canonical
-
-
 @dataclass(frozen=True, kw_only=True)
 class CallerIdentity:
     """Canonical caller identity used to scope episodes, session state, and guidance."""
@@ -57,11 +46,9 @@ class CallerIdentity:
             object.__setattr__(
                 self, "trust_level", IdentityTrustLevel(str(self.trust_level))
             )
-        canonical_id = build_canonical_caller_id(
-            host_app=host_app,
-            host_session_key=host_session_key,
-            agent_key=self.agent_key,
-        )
+        canonical_id = f"{host_app}:{host_session_key}"
+        if self.agent_key:
+            canonical_id = f"{canonical_id}:agent:{self.agent_key}"
         if self.canonical_id is not None and self.canonical_id != canonical_id:
             raise ValueError(
                 "canonical_id must match host_app, host_session_key, and agent_key"

{shellbrain-0.1.55 → shellbrain-0.1.57}/app/core/entities/ids.py

@@ -10,9 +10,7 @@ RepoId = NewType("RepoId", str)
 EpisodeId = NewType("EpisodeId", str)
 EvidenceRefText = NewType("EvidenceRefText", str)
 EvidenceId = NewType("EvidenceId", str)
-InvocationId = NewType("InvocationId", str)
 AssociationEdgeId = NewType("AssociationEdgeId", str)
 
 Confidence = NewType("Confidence", float)
 Salience = NewType("Salience", float)
-UtilityVote = NewType("UtilityVote", float)

{shellbrain-0.1.55 → shellbrain-0.1.57}/app/core/entities/memories.py

@@ -34,33 +34,11 @@ class MemoryKind(str, Enum):
 
         return self in {MemoryKind.SOLUTION, MemoryKind.FAILED_TACTIC}
 
-    @property
-    def is_mature(self) -> bool:
-        """Return whether this kind belongs to the durable mature-memory set."""
-
-        return self in MATURE_MEMORY_KINDS
-
-
-MATURE_MEMORY_KINDS: Final[tuple[MemoryKind, ...]] = (
-    MemoryKind.PROBLEM,
-    MemoryKind.SOLUTION,
-    MemoryKind.FAILED_TACTIC,
-    MemoryKind.FACT,
-    MemoryKind.PREFERENCE,
-    MemoryKind.CHANGE,
-)
 MATURE_MEMORY_KIND_VALUES: Final[tuple[str, ...]] = tuple(
-    kind.value for kind in MATURE_MEMORY_KINDS
+    kind.value for kind in MemoryKind
 )
 
 
-def is_mature_memory_kind(kind: MemoryKind | str) -> bool:
-    """Return whether one kind belongs to the mature durable-memory set."""
-
-    normalized_kind = kind if isinstance(kind, MemoryKind) else MemoryKind(kind)
-    return normalized_kind.is_mature
-
-
 class MemoryScope(str, Enum):
     """This enum defines shellbrain visibility scope."""
 

{shellbrain-0.1.55 → shellbrain-0.1.57}/app/core/entities/session_state.py

@@ -3,14 +3,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from enum import Enum
-
-
-class SessionStateResetReason(str, Enum):
-    """Reasons a working session may be reset while preserving caller identity metadata."""
-
-    IDLE_EXPIRED = "idle_expired"
-    CALLER_SWITCHED = "caller_switched"
 
 
 @dataclass(kw_only=True)

{shellbrain-0.1.55 → shellbrain-0.1.57}/app/core/entities/snapshots.py

@@ -32,13 +32,6 @@ class ShadowGitPathChangeStatus(str, Enum):
     RENAMED = "renamed"
 
 
-class CodeDeltaContextStatus(str, Enum):
-    """Public availability states for code-delta context."""
-
-    AVAILABLE = "available"
-    UNAVAILABLE = "unavailable"
-
-
 class CodeDeltaUnavailableReason(str, Enum):
     """Expected reasons an event window cannot expose code-delta context."""
 
@@ -174,7 +167,6 @@ class ShadowGitCaptureResult:
     shadow_commit_sha: str | None
     parent_shadow_commit_sha: str | None
     changed_paths: tuple[str, ...]
-    tree_sha: str | None = None
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -212,13 +204,10 @@ class AvailableCodeDeltaContext:
     final_shadow_commit_sha: str
     patch_sha: str
     path_changes: tuple[ShadowGitPathChange, ...]
-    status: CodeDeltaContextStatus = CodeDeltaContextStatus.AVAILABLE
 
     def __post_init__(self) -> None:
         """Reject invalid available-context states."""
 
-        if self.status is not CodeDeltaContextStatus.AVAILABLE:
-            raise ValueError("available code delta context requires available status")
         for field_name in (
             "base_snapshot_id",
             "final_snapshot_id",
@@ -249,7 +238,7 @@ class AvailableCodeDeltaContext:
         """Return the stable JSON payload for bounded events."""
 
         return {
-            "status": self.status.value,
+            "status": "available",
             "base_snapshot_id": self.base_snapshot_id,
             "final_snapshot_id": self.final_snapshot_id,
             "base_shadow_commit_sha": self.base_shadow_commit_sha,
@@ -267,22 +256,17 @@ class UnavailableCodeDeltaContext:
     """Expected absence of code-delta evidence for one event window."""
 
     reason: CodeDeltaUnavailableReason
-    status: CodeDeltaContextStatus = CodeDeltaContextStatus.UNAVAILABLE
 
     def __post_init__(self) -> None:
         """Reject unavailable-context states without a typed reason."""
 
-        if self.status is not CodeDeltaContextStatus.UNAVAILABLE:
-            raise ValueError(
-                "unavailable code delta context requires unavailable status"
-            )
         if not isinstance(self.reason, CodeDeltaUnavailableReason):
             raise ValueError("reason must be a CodeDeltaUnavailableReason")
 
     def to_response_data(self) -> dict[str, str]:
         """Return the stable JSON payload for bounded events."""
 
-        return {"status": self.status.value, "reason": self.reason.value}
+        return {"status": "unavailable", "reason": self.reason.value}
 
 
 CodeDeltaContext = AvailableCodeDeltaContext | UnavailableCodeDeltaContext

{shellbrain-0.1.55 → shellbrain-0.1.57}/app/core/errors.py

@@ -16,12 +16,9 @@ class ErrorCode(str, Enum):
     NOT_FOUND = "not_found"
     CONFLICT = "conflict"
     INTERNAL_ERROR = "internal_error"
-    HOST_IDENTITY_UNAVAILABLE = "host_identity_unavailable"
     HOST_IDENTITY_UNSUPPORTED = "host_identity_unsupported"
     HOST_IDENTITY_DRIFTED = "host_identity_drifted"
     HOST_HOOK_MISSING = "host_hook_missing"
-    TRANSCRIPT_SOURCE_NOT_FOUND = "transcript_source_not_found"
-    INNER_AGENT_ERROR = "inner_agent_error"
 
 
 class ErrorDetail(BaseModel):

{shellbrain-0.1.55 → shellbrain-0.1.57}/app/core/policies/memories/add_plan.py

@@ -4,13 +4,13 @@ from typing import Any
 
 from app.core.use_cases.memories.add.result import CreatePlanIds
 from app.core.use_cases.memories.effect_plan import (
+    EffectType,
     AssociationUpsertAndObserveEffectParams,
     MemoryAddEffectParams,
     MemoryEmbeddingUpsertEffectParams,
     EvidenceAttachEffectParams,
     PlannedEffect,
     StructuralProblemLinkEffectParams,
-    make_side_effect,
 )
 from app.core.entities.associations import AssociationSourceMode, AssociationState
 from app.core.entities.memories import (
@@ -34,8 +34,8 @@ def build_create_plan(
     memory_id = plan_ids.memory_id
     evidence_refs = EvidenceRefs.required(memory["evidence_refs"]).values
     plan: list[PlannedEffect] = [
-        make_side_effect(
-            "memory.create",
+        PlannedEffect(
+            EffectType.MEMORY_CREATE,
             MemoryAddEffectParams(
                 memory_id=memory_id,
                 repo_id=repo_id,
@@ -44,16 +44,16 @@ def build_create_plan(
                 text=memory["text"],
             ),
         ),
-        make_side_effect(
-            "memory_embedding.upsert",
+        PlannedEffect(
+            EffectType.MEMORY_EMBEDDING_UPSERT,
             MemoryEmbeddingUpsertEffectParams(
                 memory_id=memory_id,
                 model=embedding_model,
                 text=memory["text"],
             ),
         ),
-        make_side_effect(
-            "evidence.attach",
+        PlannedEffect(
+            EffectType.EVIDENCE_ATTACH,
             EvidenceAttachEffectParams(
                 memory_id=memory_id,
                 repo_id=repo_id,
@@ -66,8 +66,8 @@ def build_create_plan(
     if MemoryKind(memory["kind"]).requires_problem_link and problem_id:
         relation_id = _required_structural_relation_id(plan_ids, 0)
         plan.append(
-            make_side_effect(
-                "structural_problem_link.create",
+            PlannedEffect(
+                EffectType.STRUCTURAL_PROBLEM_LINK_CREATE,
                 StructuralProblemLinkEffectParams(
                     relation_id=relation_id,
                     repo_id=repo_id,
@@ -89,8 +89,8 @@ def build_create_plan(
         confidence = ConfidenceValue(association["confidence"]).value
         salience = SalienceValue(association["salience"]).value
         plan.append(
-            make_side_effect(
-                "association.upsert_and_observe",
+            PlannedEffect(
+                EffectType.ASSOCIATION_UPSERT_AND_OBSERVE,
                 AssociationUpsertAndObserveEffectParams(
                     repo_id=repo_id,
                     edge_id=plan_ids.association_edge_ids[index],

{shellbrain-0.1.55 → shellbrain-0.1.57}/app/core/policies/memories/update_plan.py

@@ -3,13 +3,13 @@
 from typing import Any
 
 from app.core.use_cases.memories.effect_plan import (
+    EffectType,
     AssociationUpsertAndObserveEffectParams,
     EvidenceSourceEffectParams,
     StructuralFactChangeEffectParams,
     MemoryLifecycleUpdateEffectParams,
     PlannedEffect,
     UtilityObservationAppendEffectParams,
-    make_side_effect,
 )
 from app.core.use_cases.memories.update.result import UpdatePlanIds
 from app.core.entities.associations import AssociationSourceMode, AssociationState
@@ -33,8 +33,8 @@ def build_update_plan(
 
     if update_type == "update_lifecycle":
         return [
-            make_side_effect(
-                "memory.lifecycle_update",
+            PlannedEffect(
+                EffectType.MEMORY_LIFECYCLE_UPDATE,
                 MemoryLifecycleUpdateEffectParams(
                     event_id=_required(
                         plan_ids.memory_lifecycle_event_id,
@@ -67,8 +67,8 @@ def build_update_plan(
     if update_type == "utility_vote":
         evidence_refs = EvidenceRefs.optional(update.get("evidence_refs", [])).values
         return [
-            make_side_effect(
-                "utility_observation.append",
+            PlannedEffect(
+                EffectType.UTILITY_OBSERVATION_APPEND,
                 UtilityObservationAppendEffectParams(
                     id=_required(
                         plan_ids.utility_observation_id, "utility_observation_id"
@@ -86,8 +86,8 @@ def build_update_plan(
     if update_type == "fact_update_link":
         evidence_refs = EvidenceRefs.optional(update.get("evidence_refs", [])).values
         return [
-            make_side_effect(
-                "structural_fact_change.create",
+            PlannedEffect(
+                EffectType.STRUCTURAL_FACT_CHANGE_CREATE,
                 StructuralFactChangeEffectParams(
                     repo_id=repo_id,
                     old_fact_id=update["old_fact_id"],
@@ -106,8 +106,8 @@ def build_update_plan(
         salience = SalienceValue(update["salience"]).value
         evidence_refs = EvidenceRefs.required(update["evidence_refs"]).values
         return [
-            make_side_effect(
-                "association.upsert_and_observe",
+            PlannedEffect(
+                EffectType.ASSOCIATION_UPSERT_AND_OBSERVE,
                 AssociationUpsertAndObserveEffectParams(
                     repo_id=repo_id,
                     edge_id=_required(

{shellbrain-0.1.55 → shellbrain-0.1.57}/app/core/policies/retrieval/bm25.py

@@ -36,9 +36,6 @@ class BM25ScoredDocument:
 def score_documents(
     query_terms: Sequence[str],
     documents: Sequence[BM25Document],
-    *,
-    k1: float = _K1,
-    b: float = _B,
 ) -> list[BM25ScoredDocument]:
     """Return BM25 scores and weighted query coverage for partially matching documents."""
 
@@ -81,12 +78,12 @@ def score_documents(
         score = 0.0
         matched_query_weight = 0.0
         document_length = len(document.terms)
-        normalization = k1 * (1 - b + b * document_length / average_length)
+        normalization = _K1 * (1 - _B + _B * document_length / average_length)
         for term in matched_terms:
             inverse_document_frequency = inverse_document_frequencies[term]
             term_frequency = frequencies[term]
             score += inverse_document_frequency * (
-                (term_frequency * (k1 + 1)) / (term_frequency + normalization)
+                (term_frequency * (_K1 + 1)) / (term_frequency + normalization)
             )
             matched_query_weight += inverse_document_frequency
 

{shellbrain-0.1.55 → shellbrain-0.1.57}/app/core/policies/retrieval/context_pack.py

@@ -7,11 +7,6 @@ from app.core.policies.retrieval.ontology_semantics import why_included_for_expa
 
 
 _BUCKET_ORDER = ("direct", "explicit", "implicit")
-_SECTION_NAMES = {
-    "direct": "direct",
-    "explicit": "explicit_related",
-    "implicit": "implicit_related",
-}
 _BUCKET_PRIORITY = {
     bucket_name: index for index, bucket_name in enumerate(_BUCKET_ORDER)
 }

{shellbrain-0.1.55 → shellbrain-0.1.57}/app/core/policies/retrieval/lexical_query.py

@@ -43,8 +43,6 @@ _STOPWORDS = frozenset(
 class LexicalQuery:
     """Normalized lexical query terms used by the keyword retrieval lane."""
 
-    raw_terms: tuple[str, ...]
-    informative_terms: tuple[str, ...]
     terms: tuple[str, ...]
     uses_stopword_fallback: bool
 
@@ -68,14 +66,11 @@ def build_lexical_query(query_text: str) -> LexicalQuery:
     """Build a normalized lexical query with strict informative-term semantics."""
 
     normalized = normalize_lexical_text(query_text)
-    raw_terms = _unique_terms(normalized.raw_terms)
-    informative_terms = _unique_terms(normalized.informative_terms)
+    raw_terms = tuple(dict.fromkeys(normalized.raw_terms))
+    informative_terms = tuple(dict.fromkeys(normalized.informative_terms))
     uses_stopword_fallback = not informative_terms and bool(raw_terms)
-    terms = raw_terms if uses_stopword_fallback else informative_terms
     return LexicalQuery(
-        raw_terms=raw_terms,
-        informative_terms=informative_terms,
-        terms=terms,
+        terms=raw_terms if uses_stopword_fallback else informative_terms,
         uses_stopword_fallback=uses_stopword_fallback,
     )
 
@@ -88,16 +83,3 @@ def normalize_lexical_text(text: str) -> NormalizedLexicalText:
     return NormalizedLexicalText(
         raw_terms=raw_terms, informative_terms=informative_terms
     )
-
-
-def _unique_terms(terms: tuple[str, ...]) -> tuple[str, ...]:
-    """Deduplicate terms while preserving original order."""
-
-    seen: set[str] = set()
-    ordered: list[str] = []
-    for term in terms:
-        if term in seen:
-            continue
-        seen.add(term)
-        ordered.append(term)
-    return tuple(ordered)

{shellbrain-0.1.55 → shellbrain-0.1.57}/app/core/policies/retrieval/ontology_semantics.py

@@ -5,28 +5,23 @@ from __future__ import annotations
 from collections import Counter
 from typing import Any, Iterable, Mapping
 
+from app.core.entities.memories import (
+    DEFAULT_RETRIEVABLE_MEMORY_STATUS_VALUES,
+    MemoryLifecycleStatus,
+)
 
-ACTIVE_STATUS = "active"
-MAYBE_STALE_STATUS = "maybe_stale"
-STALE_STATUS = "stale"
-SUPERSEDED_STATUS = "superseded"
-WRONG_STATUS = "wrong"
-ARCHIVED_STATUS = "archived"
 
-POSITIVE_LIFECYCLE_STATUSES = frozenset(
-    {ACTIVE_STATUS, MAYBE_STALE_STATUS, STALE_STATUS}
-)
-NO_POSITIVE_RETRIEVAL_STATUSES = frozenset(
-    {SUPERSEDED_STATUS, WRONG_STATUS, ARCHIVED_STATUS}
-)
+ACTIVE_STATUS = MemoryLifecycleStatus.ACTIVE.value
+MAYBE_STALE_STATUS = MemoryLifecycleStatus.MAYBE_STALE.value
+STALE_STATUS = MemoryLifecycleStatus.STALE.value
+SUPERSEDED_STATUS = MemoryLifecycleStatus.SUPERSEDED.value
+WRONG_STATUS = MemoryLifecycleStatus.WRONG.value
+ARCHIVED_STATUS = MemoryLifecycleStatus.ARCHIVED.value
+
+POSITIVE_LIFECYCLE_STATUSES = frozenset(DEFAULT_RETRIEVABLE_MEMORY_STATUS_VALUES)
 
 LIFECYCLE_RETRIEVAL_MULTIPLIERS: Mapping[str, float] = {
-    ACTIVE_STATUS: 1.0,
-    MAYBE_STALE_STATUS: 0.65,
-    STALE_STATUS: 0.25,
-    SUPERSEDED_STATUS: 0.0,
-    WRONG_STATUS: 0.0,
-    ARCHIVED_STATUS: 0.0,
+    status.value: status.retrieval_multiplier for status in MemoryLifecycleStatus
 }
 
 BUNDLE_FRESHNESS_MULTIPLIERS: Mapping[str, float] = {
@@ -90,14 +85,6 @@ def lifecycle_retrieval_multiplier(status: Any) -> float:
     """Return the default positive retrieval multiplier for one lifecycle status."""
 
     return LIFECYCLE_RETRIEVAL_MULTIPLIERS[normalize_lifecycle_status(status)]
-
-
-def has_positive_lifecycle_signal(status: Any) -> bool:
-    """Return whether a lifecycle status can contribute normal retrieval signal."""
-
-    return normalize_lifecycle_status(status) in POSITIVE_LIFECYCLE_STATUSES
-
-
 def is_active_lifecycle(status: Any) -> bool:
     """Return whether a lifecycle status is active."""
 
@@ -138,6 +125,16 @@ def concept_bundle_retrieval_multiplier(statuses: Iterable[Any]) -> float:
     return BUNDLE_FRESHNESS_MULTIPLIERS[dominant_lifecycle_status(statuses)]
 
 
+def bundle_lifecycle_statuses(bundle: Mapping[str, Any]) -> tuple[str, ...]:
+    """Return lifecycle status values across every truth-bearing concept facet."""
+
+    return tuple(
+        record.lifecycle.status.value
+        for key in ("claims", "relations", "groundings", "memory_links")
+        for record in bundle[key]
+    )
+
+
 def aggregate_currentness_payload(
     statuses: Iterable[Any], *, record_label: str
 ) -> dict[str, str]:

{shellbrain-0.1.55 → shellbrain-0.1.57}/app/core/policies/retrieval/scoring.py

@@ -4,11 +4,10 @@ from typing import Any
 
 
 def score_candidates(
-    candidates: dict[str, list[dict[str, Any]]], payload: dict[str, Any]
+    candidates: dict[str, list[dict[str, Any]]],
 ) -> dict[str, list[dict[str, Any]]]:
     """This function computes base scores used for bucket ranking and spillover."""
 
-    _ = payload
     return {
         "direct": _score_direct_candidates(candidates.get("direct", [])),
         "explicit": _score_explicit_candidates(candidates.get("explicit", [])),

{shellbrain-0.1.55 → shellbrain-0.1.57}/app/core/ports/db/concept_repositories.py

@@ -12,7 +12,6 @@ from app.core.entities.concepts import (
     ConceptLifecycleTargetType,
     ConceptMemoryLink,
     ConceptRelation,
-    GraphPatch,
 )
 
 
@@ -84,10 +83,6 @@ class IConceptsRepo(ABC):
     ) -> ConceptLifecycleEvent:
         """This method appends one auditable concept lifecycle transition."""
 
-    @abstractmethod
-    def create_graph_patch(self, patch: GraphPatch) -> GraphPatch:
-        """This method stores one future graph-patch proposal record."""
-
     @abstractmethod
     def get_concept_bundle(
         self,