shellbrain 0.1.56__tar.gz → 0.1.57__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shellbrain
-Version: 0.1.56
+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.56 → 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.56 → 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.56 → 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.56 → 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.56 → 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.56 → 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.56 → shellbrain-0.1.57}/app/core/entities/memories.py

@@ -34,17 +34,11 @@ class MemoryKind(str, Enum):
 
         return self in {MemoryKind.SOLUTION, MemoryKind.FAILED_TACTIC}
 
-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
 )
+
+
 class MemoryScope(str, Enum):
     """This enum defines shellbrain visibility scope."""
 

{shellbrain-0.1.56 → 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."""
 
@@ -211,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",
@@ -248,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,
@@ -266,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.56 → 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.56 → 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.56 → 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.56 → 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.56 → 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.56 → shellbrain-0.1.57}/app/core/policies/retrieval/ontology_semantics.py

@@ -5,25 +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}
-)
+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] = {
@@ -127,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.56 → 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,

{shellbrain-0.1.56 → shellbrain-0.1.57}/app/core/ports/db/episode_repositories.py

@@ -1,15 +1,9 @@
 """Repository ports for episode persistence."""
 
 from abc import ABC, abstractmethod
-from datetime import datetime
 from typing import Sequence
 
-from app.core.entities.episodes import (
-    Episode,
-    EpisodeBuildSnapshot,
-    EpisodeEvent,
-    SessionTransfer,
-)
+from app.core.entities.episodes import Episode, EpisodeBuildSnapshot, EpisodeEvent
 
 
 class IEpisodesRepo(ABC):
@@ -55,10 +49,6 @@ class IEpisodesRepo(ABC):
     ) -> EpisodeEvent | None:
         """This method fetches one repo-visible event by id inside an episode."""
 
-    @abstractmethod
-    def list_event_keys(self, *, episode_id: str) -> Sequence[str]:
-        """This method returns already-imported upstream event keys for one episode."""
-
     @abstractmethod
     def next_event_seq(self, *, episode_id: str) -> int:
         """This method returns the next append sequence number for one episode."""
@@ -71,14 +61,6 @@ class IEpisodesRepo(ABC):
     def append_event_if_new(self, event: EpisodeEvent) -> bool:
         """This method appends an event only when its host_event_key is not already present."""
 
-    @abstractmethod
-    def close_episode(self, *, episode_id: str, ended_at: datetime) -> None:
-        """This method marks an active episode closed."""
-
-    @abstractmethod
-    def append_transfer(self, transfer: SessionTransfer) -> None:
-        """This method appends a cross-session transfer row."""
-
     @abstractmethod
     def list_existing_event_ids(self, *, event_ids: Sequence[str]) -> Sequence[str]:
         """This method returns episode-event ids that exist anywhere in storage."""

{shellbrain-0.1.56 → shellbrain-0.1.57}/app/core/use_cases/admin/backfill_model_usage/__init__.py

@@ -5,13 +5,11 @@ from app.core.use_cases.admin.backfill_model_usage.backfill_model_usage import (
     linked_session_from_mapping,
 )
 from app.core.use_cases.admin.backfill_model_usage.request import (
-    BackfillModelUsageRequest,
     LinkedModelUsageSession,
 )
 from app.core.use_cases.admin.backfill_model_usage.result import BackfillSummary
 
 __all__ = [
-    "BackfillModelUsageRequest",
     "BackfillSummary",
     "LinkedModelUsageSession",
     "backfill_model_usage",

{shellbrain-0.1.56 → shellbrain-0.1.57}/app/core/use_cases/admin/backfill_model_usage/backfill_model_usage.py

@@ -7,14 +7,13 @@ from collections.abc import Callable, Sequence
 from pathlib import Path
 
 from app.core.use_cases.admin.backfill_model_usage.request import (
-    BackfillModelUsageRequest,
     LinkedModelUsageSession,
 )
 from app.core.use_cases.admin.backfill_model_usage.result import BackfillSummary
 
 
 def backfill_model_usage(
-    request: BackfillModelUsageRequest,
+    sessions: tuple[LinkedModelUsageSession, ...],
     *,
     collect_model_usage_records_for_session: Callable[..., Sequence[object]],
     persist_model_usage_records: Callable[[Sequence[object]], None],
@@ -28,7 +27,7 @@ def backfill_model_usage(
     sessions_failed = 0
     records_attempted = 0
 
-    for session in request.sessions:
+    for session in sessions:
         try:
             records = collect_model_usage_records_for_session(
                 repo_id=session.repo_id,
@@ -58,7 +57,7 @@ def backfill_model_usage(
         host_counts[session.host_app] += len(records)
 
     return BackfillSummary(
-        sessions_examined=len(request.sessions),
+        sessions_examined=len(sessions),
         sessions_with_records=sessions_with_records,
         sessions_skipped=sessions_skipped,
         sessions_failed=sessions_failed,

{shellbrain-0.1.56 → shellbrain-0.1.57}/app/core/use_cases/admin/backfill_model_usage/request.py

@@ -15,10 +15,3 @@ class LinkedModelUsageSession:
     thread_id: str | None
     episode_id: str | None
     transcript_path: str
-
-
-@dataclass(frozen=True)
-class BackfillModelUsageRequest:
-    """Canonical model-usage backfill request."""
-
-    sessions: tuple[LinkedModelUsageSession, ...]

{shellbrain-0.1.56 → shellbrain-0.1.57}/app/core/use_cases/concepts/add/execute.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 from typing import Any
 
-from app.core.errors import DomainValidationError, ErrorCode, ErrorDetail
 from app.core.entities.concepts import Concept, ConceptKind, ConceptStatus
 from app.core.ports.embeddings.provider import IEmbeddingProvider
 from app.core.ports.system.idgen import IIdGenerator
@@ -25,22 +24,10 @@ def add_concepts(
 ) -> ConceptAddResult:
     """Create concept containers, failing when any target concept already exists."""
 
-    normalized_slugs: list[str] = []
-    seen_slugs: set[str] = set()
-    for action in request.actions:
-        normalized_slug = require_missing_concept(request.repo_id, action.slug, uow)
-        if normalized_slug in seen_slugs:
-            raise DomainValidationError(
-                [
-                    ErrorDetail(
-                        code=ErrorCode.SEMANTIC_ERROR,
-                        message=f"Concept add request contains duplicate slug: {normalized_slug}",
-                        field="actions.slug",
-                    )
-                ]
-            )
-        normalized_slugs.append(normalized_slug)
-        seen_slugs.add(normalized_slug)
+    normalized_slugs = [
+        require_missing_concept(request.repo_id, action.slug, uow)
+        for action in request.actions
+    ]
 
     results: list[dict[str, Any]] = []
     concept_ids: list[str] = []