loom-continuity 0.1.0__tar.gz

loom_continuity-0.1.0/PKG-INFO

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: loom-continuity
+Version: 0.1.0
+Summary: Runtime for durable derived knowledge: versioned results with evidence, staleness, safe recomputation across processes, and crash-safe notification.
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# Loom Continuity
+
+`loom_continuity` is a durable coordination and knowledge-state runtime.
+It is not an agent framework.
+It is designed to sit underneath application harnesses and agent frameworks.
+
+It answers one question: a value was derived from some evidence; is that evidence still current, and if not, who may recompute it without duplicating the work, committing a stale result, or losing the notice that state changed.
+
+The package does not choose the application shape. A caller reads knowledge, checks validity, claims a repair, commits only if the evidence versions still match, and leaves a durable notification. A web app, a worker, a graph runtime, a batch job, or a plain function decides when to make those calls.
+
+## Using it
+
+The first mode is a library inside one process. An application opens `SqliteKnowledgeStore`, `SqliteOutbox`, and `SqliteRepairLease` on one database file. A request looks up a fact. `VALID` returns the stored value. `MISSING` computes it. `STALE` claims the lease, computes outside the database transaction, and commits only if the dependency versions are unchanged. FastAPI, or any other process, is just a client of that runtime. Importing the package does not pull FastAPI in.
+
+The production shape splits roles across processes that share the file. The request process writes evidence and can return before the expensive work. A worker finds stale or missing facts, claims the lease, computes, and commits. A dispatcher delivers pending outbox events and re-reads the current value. Any one of those processes can die. The fact, the pending obligation, and the lease expiry remain in the file.
+
+Several processes can see the same stale key. One claim is `ACQUIRED`. The others are `DENIED` until the lease expires or is released, then they read the repaired value. That is the coordination, not a database wrapper. The SQLite implementation is for one shared file. Several machines should not share that file. The protocols are `KnowledgeStore`, `Outbox`, and `RepairLeaseStore`; a later backend would be a new implementation, not a change to the caller's questions.
+
+An agent framework sits above this. A graph or agent node asks for a fact and skips the expensive chain while the lookup is `VALID`. It runs only when the fact is `STALE` or `MISSING`, then writes the result with provenance. Reuse lasts until the evidence version changes. It is not a time-to-live cache.
+
+A batch job can do the same without a server: `get_valid_fact` for each item, skip what is still `VALID`, repair what is `STALE`, compute what is `MISSING`. A scheduler such as Temporal or Celery can start the activity. This package does not replace that scheduler. The scheduler decides when to run. The runtime decides whether the result is still current and whether the write is still safe.
+
+A later HTTP service can wrap the same calls for other languages. That service is not this package. Callers that can import Python should use the library.
+
+An agent tool can hide the protocol and return the current fact, or report `STALE` and leave repair to an orchestrator. Several agents can share one store. When evidence moves, the derived fact becomes `STALE` for all of them. That is shared institutional knowledge, not conversation history.
+
+The compute step can be a Python function. Nothing in the core requires a model.
+
+The distribution version is declared once, in `pyproject.toml`. This cut is `0.1.0`.
+The base install has no FastAPI, torch, or model-runtime dependency.
+
+## What it guarantees
+
+- Versioned knowledge survives process death. A later process can reopen the same store.
+- `LookupStatus.VALID` means every provenance dependency version is still current, including transitive dependencies.
+- A fact whose dependency moved is `STALE`. The stored revision is not deleted.
+- If `A -> B -> C` and `A` changes, `C` is stale even when `B`'s revision number has not changed.
+- The store does not repair itself. A caller claims a per-scope, per-key lease, computes outside any database transaction, and commits only if the dependency versions still match.
+- A lease expires. After the owner process dies, another worker can acquire it. The lease is not held as a long transaction across the computation.
+- A repair computed against old dependency versions is rejected. That result never becomes the current committed value.
+- A fact revision and its outbox obligation commit in one transaction. A crash after commit leaves both. A crash before commit leaves neither.
+- Delivery is at-least-once. Pending events remain until the consumer returns.
+- Reopen, stale detection, single-owner repair, rejected stale commits, crash boundaries, and current-state delivery are covered by `loom_continuity_e2e`.
+
+## What it does not guarantee
+
+- `VALID` does not mean semantically correct, true, safe, approved, or high confidence. A wrong value is `VALID` while its dependency chain is current.
+- Delivery is not exactly-once.
+- The package does not deduplicate consumer side effects.
+- Outbox events are not an event log of authoritative values. This is not event sourcing.
+- There is no agent loop, tool framework, conversation memory, or semantic/vector memory.
+- There is no auth, UI, or deployment framework.
+
+## Not in this cut
+
+v0.1 is one SQLite file and process coordination around it. It is not a city. These are outside the frozen contract:
+
+- identity service
+- permissions
+- scheduler
+- service discovery
+- policy enforcement beyond provenance freshness
+- a second storage backend
+- coordination across nodes
+
+`KnowledgeStore`, `Outbox`, and `RepairLeaseStore` are protocols with a SQLite implementation. Another backend is an open slot, not a delivered adapter. `scope` is a namespace string, not an identity. Lease TTL is an expiry, not a scheduler.
+
+## `scope`
+
+`scope` is the isolation namespace for independent knowledge state.
+It may name a tenant, workflow, project, incident, job, or another application domain.
+It is not a conversation id.
+
+Public methods take `scope`. The SQLite primary key column is already `scope`. There is no `session_id` column and no schema migration in this cut.
+
+## Public import surface
+
+```python
+from loom_continuity import (
+    KnowledgeStore,
+    SqliteKnowledgeStore,
+    FactRevision,
+    ProvenanceRef,
+    Lookup,
+    LookupStatus,
+    Outbox,
+    SqliteOutbox,
+    OutboxEvent,
+    OutboxStatus,
+    commit_fact_with_event,
+    commit_fact_with_event_if_versions_match,
+    dispatch_pending,
+    RepairLeaseStore,
+    SqliteRepairLease,
+    Lease,
+    ClaimStatus,
+    ClaimResult,
+    LLMBackend,
+    StatefulLLMBackend,
+)
+```
+
+`KnowledgeStore` is the storage protocol. `SqliteKnowledgeStore` is the SQLite implementation.
+`FactRevision` is the only fact value type. There is no separate `Fact` alias.
+`Lease` is the only lease value type. `claim` returns `ClaimStatus.DENIED` and does not raise.
+`commit_fact_with_event` and `commit_fact_with_event_if_versions_match` are the public atomic write and conditional-commit operations. They are not private helpers.
+`LLMBackend` and `StatefulLLMBackend` are dependency-free call contracts. Model runtimes are not part of the base package.
+
+## Current-State Notification Semantics
+
+An outbox event identifies that state changed. It carries `scope`, `key`, `version`, and a stable `event_id`. It does not carry the authoritative fact value.
+
+The consumer re-reads the current value from `SqliteKnowledgeStore`.
+If revision 1 then revision 2 were committed, delivering the newer event and then the older event still reads revision 2 both times.
+A delayed older notification cannot restore an older value.
+
+This is not event sourcing.
+
+## Consumer idempotency
+
+Dispatch is at-least-once. The same `event_id` can be handed to the consumer more than once, including after a crash before acknowledgement.
+
+The package does not suppress that repeat. A consumer that must apply a logical effect once deduplicates on `event_id` itself, for example with `INSERT OR IGNORE`.
+
+## Install and acceptance
+
+From a clean environment, install the package, then run the acceptance suite from a checkout of this repository. The suite is not inside the wheel, and the runner does not put the source tree on `PYTHONPATH`.
+
+```bash
+python -m venv /tmp/loom-continuity-accept
+source /tmp/loom-continuity-accept/bin/activate
+pip install loom-continuity
+python loom_continuity_e2e/run_all.py
+```
+
+Expected result: `10/10 PASS`, and `loom_continuity.__file__` under that environment's `site-packages`.
+
+Package-local unit checks, from this directory:
+
+```bash
+python -m unittest discover -s tests -v
+```
+
+A separate minimal consumer lives at `examples/minimal_consumer/` in the repository. It imports only the public package API.

loom_continuity-0.1.0/README.md

@@ -0,0 +1,144 @@
+# Loom Continuity
+
+`loom_continuity` is a durable coordination and knowledge-state runtime.
+It is not an agent framework.
+It is designed to sit underneath application harnesses and agent frameworks.
+
+It answers one question: a value was derived from some evidence; is that evidence still current, and if not, who may recompute it without duplicating the work, committing a stale result, or losing the notice that state changed.
+
+The package does not choose the application shape. A caller reads knowledge, checks validity, claims a repair, commits only if the evidence versions still match, and leaves a durable notification. A web app, a worker, a graph runtime, a batch job, or a plain function decides when to make those calls.
+
+## Using it
+
+The first mode is a library inside one process. An application opens `SqliteKnowledgeStore`, `SqliteOutbox`, and `SqliteRepairLease` on one database file. A request looks up a fact. `VALID` returns the stored value. `MISSING` computes it. `STALE` claims the lease, computes outside the database transaction, and commits only if the dependency versions are unchanged. FastAPI, or any other process, is just a client of that runtime. Importing the package does not pull FastAPI in.
+
+The production shape splits roles across processes that share the file. The request process writes evidence and can return before the expensive work. A worker finds stale or missing facts, claims the lease, computes, and commits. A dispatcher delivers pending outbox events and re-reads the current value. Any one of those processes can die. The fact, the pending obligation, and the lease expiry remain in the file.
+
+Several processes can see the same stale key. One claim is `ACQUIRED`. The others are `DENIED` until the lease expires or is released, then they read the repaired value. That is the coordination, not a database wrapper. The SQLite implementation is for one shared file. Several machines should not share that file. The protocols are `KnowledgeStore`, `Outbox`, and `RepairLeaseStore`; a later backend would be a new implementation, not a change to the caller's questions.
+
+An agent framework sits above this. A graph or agent node asks for a fact and skips the expensive chain while the lookup is `VALID`. It runs only when the fact is `STALE` or `MISSING`, then writes the result with provenance. Reuse lasts until the evidence version changes. It is not a time-to-live cache.
+
+A batch job can do the same without a server: `get_valid_fact` for each item, skip what is still `VALID`, repair what is `STALE`, compute what is `MISSING`. A scheduler such as Temporal or Celery can start the activity. This package does not replace that scheduler. The scheduler decides when to run. The runtime decides whether the result is still current and whether the write is still safe.
+
+A later HTTP service can wrap the same calls for other languages. That service is not this package. Callers that can import Python should use the library.
+
+An agent tool can hide the protocol and return the current fact, or report `STALE` and leave repair to an orchestrator. Several agents can share one store. When evidence moves, the derived fact becomes `STALE` for all of them. That is shared institutional knowledge, not conversation history.
+
+The compute step can be a Python function. Nothing in the core requires a model.
+
+The distribution version is declared once, in `pyproject.toml`. This cut is `0.1.0`.
+The base install has no FastAPI, torch, or model-runtime dependency.
+
+## What it guarantees
+
+- Versioned knowledge survives process death. A later process can reopen the same store.
+- `LookupStatus.VALID` means every provenance dependency version is still current, including transitive dependencies.
+- A fact whose dependency moved is `STALE`. The stored revision is not deleted.
+- If `A -> B -> C` and `A` changes, `C` is stale even when `B`'s revision number has not changed.
+- The store does not repair itself. A caller claims a per-scope, per-key lease, computes outside any database transaction, and commits only if the dependency versions still match.
+- A lease expires. After the owner process dies, another worker can acquire it. The lease is not held as a long transaction across the computation.
+- A repair computed against old dependency versions is rejected. That result never becomes the current committed value.
+- A fact revision and its outbox obligation commit in one transaction. A crash after commit leaves both. A crash before commit leaves neither.
+- Delivery is at-least-once. Pending events remain until the consumer returns.
+- Reopen, stale detection, single-owner repair, rejected stale commits, crash boundaries, and current-state delivery are covered by `loom_continuity_e2e`.
+
+## What it does not guarantee
+
+- `VALID` does not mean semantically correct, true, safe, approved, or high confidence. A wrong value is `VALID` while its dependency chain is current.
+- Delivery is not exactly-once.
+- The package does not deduplicate consumer side effects.
+- Outbox events are not an event log of authoritative values. This is not event sourcing.
+- There is no agent loop, tool framework, conversation memory, or semantic/vector memory.
+- There is no auth, UI, or deployment framework.
+
+## Not in this cut
+
+v0.1 is one SQLite file and process coordination around it. It is not a city. These are outside the frozen contract:
+
+- identity service
+- permissions
+- scheduler
+- service discovery
+- policy enforcement beyond provenance freshness
+- a second storage backend
+- coordination across nodes
+
+`KnowledgeStore`, `Outbox`, and `RepairLeaseStore` are protocols with a SQLite implementation. Another backend is an open slot, not a delivered adapter. `scope` is a namespace string, not an identity. Lease TTL is an expiry, not a scheduler.
+
+## `scope`
+
+`scope` is the isolation namespace for independent knowledge state.
+It may name a tenant, workflow, project, incident, job, or another application domain.
+It is not a conversation id.
+
+Public methods take `scope`. The SQLite primary key column is already `scope`. There is no `session_id` column and no schema migration in this cut.
+
+## Public import surface
+
+```python
+from loom_continuity import (
+    KnowledgeStore,
+    SqliteKnowledgeStore,
+    FactRevision,
+    ProvenanceRef,
+    Lookup,
+    LookupStatus,
+    Outbox,
+    SqliteOutbox,
+    OutboxEvent,
+    OutboxStatus,
+    commit_fact_with_event,
+    commit_fact_with_event_if_versions_match,
+    dispatch_pending,
+    RepairLeaseStore,
+    SqliteRepairLease,
+    Lease,
+    ClaimStatus,
+    ClaimResult,
+    LLMBackend,
+    StatefulLLMBackend,
+)
+```
+
+`KnowledgeStore` is the storage protocol. `SqliteKnowledgeStore` is the SQLite implementation.
+`FactRevision` is the only fact value type. There is no separate `Fact` alias.
+`Lease` is the only lease value type. `claim` returns `ClaimStatus.DENIED` and does not raise.
+`commit_fact_with_event` and `commit_fact_with_event_if_versions_match` are the public atomic write and conditional-commit operations. They are not private helpers.
+`LLMBackend` and `StatefulLLMBackend` are dependency-free call contracts. Model runtimes are not part of the base package.
+
+## Current-State Notification Semantics
+
+An outbox event identifies that state changed. It carries `scope`, `key`, `version`, and a stable `event_id`. It does not carry the authoritative fact value.
+
+The consumer re-reads the current value from `SqliteKnowledgeStore`.
+If revision 1 then revision 2 were committed, delivering the newer event and then the older event still reads revision 2 both times.
+A delayed older notification cannot restore an older value.
+
+This is not event sourcing.
+
+## Consumer idempotency
+
+Dispatch is at-least-once. The same `event_id` can be handed to the consumer more than once, including after a crash before acknowledgement.
+
+The package does not suppress that repeat. A consumer that must apply a logical effect once deduplicates on `event_id` itself, for example with `INSERT OR IGNORE`.
+
+## Install and acceptance
+
+From a clean environment, install the package, then run the acceptance suite from a checkout of this repository. The suite is not inside the wheel, and the runner does not put the source tree on `PYTHONPATH`.
+
+```bash
+python -m venv /tmp/loom-continuity-accept
+source /tmp/loom-continuity-accept/bin/activate
+pip install loom-continuity
+python loom_continuity_e2e/run_all.py
+```
+
+Expected result: `10/10 PASS`, and `loom_continuity.__file__` under that environment's `site-packages`.
+
+Package-local unit checks, from this directory:
+
+```bash
+python -m unittest discover -s tests -v
+```
+
+A separate minimal consumer lives at `examples/minimal_consumer/` in the repository. It imports only the public package API.

loom_continuity-0.1.0/pyproject.toml

@@ -0,0 +1,14 @@
+[project]
+name = "loom-continuity"
+version = "0.1.0"
+description = "Runtime for durable derived knowledge: versioned results with evidence, staleness, safe recomputation across processes, and crash-safe notification."
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = []
+
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]

loom_continuity-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

loom_continuity-0.1.0/src/loom_continuity/__init__.py

@@ -0,0 +1,44 @@
+"""loom_continuity maintains durable, versioned knowledge whose reusability is
+determined by current provenance, and coordinates safe repair and propagation
+across process failure.
+
+VALID means provenance dependencies are current, not that a value is true.
+Outbox events notify that authoritative state changed; they do not carry it.
+"""
+from loom_continuity.backends.base import LLMBackend, StatefulLLMBackend
+from loom_continuity.coordination.lease_protocol import RepairLeaseStore
+from loom_continuity.coordination.lease_types import ClaimResult, ClaimStatus, Lease
+from loom_continuity.coordination.outbox_protocol import Outbox, dispatch_pending
+from loom_continuity.coordination.outbox_types import OutboxEvent, OutboxStatus
+from loom_continuity.coordination.sqlite_lease import SqliteRepairLease
+from loom_continuity.coordination.sqlite_outbox import (
+    SqliteOutbox,
+    commit_fact_with_event,
+    commit_fact_with_event_if_versions_match,
+)
+from loom_continuity.knowledge.protocol import KnowledgeStore
+from loom_continuity.knowledge.sqlite import SqliteKnowledgeStore
+from loom_continuity.knowledge.types import FactRevision, Lookup, LookupStatus, ProvenanceRef
+
+__all__ = [
+    "LLMBackend",
+    "StatefulLLMBackend",
+    "FactRevision",
+    "ProvenanceRef",
+    "Lookup",
+    "LookupStatus",
+    "KnowledgeStore",
+    "SqliteKnowledgeStore",
+    "OutboxEvent",
+    "OutboxStatus",
+    "Outbox",
+    "SqliteOutbox",
+    "commit_fact_with_event",
+    "commit_fact_with_event_if_versions_match",
+    "dispatch_pending",
+    "Lease",
+    "ClaimStatus",
+    "ClaimResult",
+    "RepairLeaseStore",
+    "SqliteRepairLease",
+]

loom_continuity-0.1.0/src/loom_continuity/backends/__init__.py

@@ -0,0 +1,4 @@
+"""Importing the backends package loads contracts only, not Ollama or Qwen."""
+from loom_continuity.backends.base import LLMBackend, StatefulLLMBackend
+
+__all__ = ["LLMBackend", "StatefulLLMBackend"]

loom_continuity-0.1.0/src/loom_continuity/backends/base.py

@@ -0,0 +1,16 @@
+"""Backend contracts only. Importing this module loads no HTTP client and no model weights."""
+from __future__ import annotations
+
+from typing import Protocol
+
+
+class LLMBackend(Protocol):
+    async def generate(self, messages: list[dict], format: str | dict | None = None,
+                        options: dict | None = None, trace_id: str | None = None) -> str: ...
+
+
+class StatefulLLMBackend(LLMBackend, Protocol):
+    def prefill(self, tokens: list[int]): ...
+    def continue_from(self, state, tokens: list[int]): ...
+    def clone_state(self, state): ...
+    def commit_token(self, state, token_id: int): ...

loom_continuity-0.1.0/src/loom_continuity/coordination/__init__.py

@@ -0,0 +1,25 @@
+from loom_continuity.coordination.lease_protocol import RepairLeaseStore
+from loom_continuity.coordination.lease_types import ClaimResult, ClaimStatus, Lease
+from loom_continuity.coordination.outbox_protocol import Outbox, dispatch_pending
+from loom_continuity.coordination.outbox_types import OutboxEvent, OutboxStatus
+from loom_continuity.coordination.sqlite_lease import SqliteRepairLease
+from loom_continuity.coordination.sqlite_outbox import (
+    SqliteOutbox,
+    commit_fact_with_event,
+    commit_fact_with_event_if_versions_match,
+)
+
+__all__ = [
+    "OutboxEvent",
+    "OutboxStatus",
+    "Outbox",
+    "SqliteOutbox",
+    "commit_fact_with_event",
+    "commit_fact_with_event_if_versions_match",
+    "dispatch_pending",
+    "Lease",
+    "ClaimResult",
+    "ClaimStatus",
+    "RepairLeaseStore",
+    "SqliteRepairLease",
+]

loom_continuity-0.1.0/src/loom_continuity/coordination/lease_protocol.py

@@ -0,0 +1,21 @@
+"""Storage-independent repair-lease contract."""
+
+from typing import Protocol, runtime_checkable
+
+from loom_continuity.coordination.lease_types import ClaimResult, Lease
+
+
+@runtime_checkable
+class RepairLeaseStore(Protocol):
+    def claim(
+        self,
+        scope: str,
+        key: str,
+        owner_id: str,
+        expected_versions: dict[str, int],
+        lease_seconds: float = 30.0,
+    ) -> ClaimResult: ...
+
+    def get_current(self, scope: str, key: str) -> Lease | None: ...
+
+    def release(self, scope: str, key: str, owner_id: str) -> None: ...

loom_continuity-0.1.0/src/loom_continuity/coordination/lease_types.py

@@ -0,0 +1,27 @@
+"""Storage-independent repair-lease values.
+
+`claim` reports a busy lease as `ClaimStatus.DENIED`. It does not raise.
+"""
+
+from dataclasses import dataclass
+from enum import StrEnum
+
+
+@dataclass(frozen=True)
+class Lease:
+    scope: str
+    key: str
+    owner_id: str
+    expected_versions: dict[str, int]
+    lease_until: str
+
+
+class ClaimStatus(StrEnum):
+    ACQUIRED = "ACQUIRED"
+    DENIED = "DENIED"
+
+
+@dataclass(frozen=True)
+class ClaimResult:
+    status: ClaimStatus
+    lease: Lease | None = None

loom_continuity-0.1.0/src/loom_continuity/coordination/outbox_protocol.py

@@ -0,0 +1,27 @@
+"""Outbox and delivery contracts without persistence assumptions."""
+
+from typing import Callable, Protocol, runtime_checkable
+
+from loom_continuity.coordination.outbox_types import OutboxEvent
+
+
+@runtime_checkable
+class Outbox(Protocol):
+    def pending(self, scope: str | None = None) -> list[OutboxEvent]: ...
+
+    def mark_delivered(self, event_id: str) -> None: ...
+
+    def get(self, event_id: str) -> OutboxEvent | None: ...
+
+
+def dispatch_pending(
+    outbox: Outbox,
+    consumer: Callable[[OutboxEvent], None],
+    scope: str | None = None,
+) -> list[str]:
+    delivered = []
+    for event in outbox.pending(scope=scope):
+        consumer(event)
+        outbox.mark_delivered(event.event_id)
+        delivered.append(event.event_id)
+    return delivered

loom_continuity-0.1.0/src/loom_continuity/coordination/outbox_types.py

@@ -0,0 +1,32 @@
+"""Storage-independent outbox values.
+
+Current-State Notification Semantics
+
+Outbox events do not carry authoritative fact values.
+A consumer reacts to the event by re-reading the current value from KnowledgeStore.
+Therefore an older delayed notification does not restore an older value.
+
+This is not event sourcing and does not preserve historical transition payload semantics.
+`scope` on an event identifies the knowledge domain. `version` identifies which
+revision was committed. Neither field is a copy of that revision's value.
+"""
+
+from dataclasses import dataclass
+from enum import StrEnum
+
+
+class OutboxStatus(StrEnum):
+    PENDING = "pending"
+    DELIVERED = "delivered"
+
+
+@dataclass(frozen=True)
+class OutboxEvent:
+    event_id: str
+    scope: str
+    key: str
+    version: int
+    previous_version: int | None
+    event_type: str
+    created_at: str
+    status: OutboxStatus

loom_continuity-0.1.0/src/loom_continuity/coordination/sqlite_lease.py

@@ -0,0 +1,84 @@
+"""SQLite adapter for durable per-key repair leases."""
+
+import json
+import sqlite3
+from contextlib import closing
+from datetime import datetime, timedelta, timezone
+
+from loom_continuity.coordination.lease_types import ClaimResult, ClaimStatus, Lease
+
+
+class SqliteRepairLease:
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+        self._init_schema()
+
+    def claim(
+        self,
+        scope: str,
+        key: str,
+        owner_id: str,
+        expected_versions: dict[str, int],
+        lease_seconds: float = 30.0,
+    ) -> ClaimResult:
+        now = datetime.now(timezone.utc)
+        now_iso = now.isoformat()
+        lease_until = (now + timedelta(seconds=lease_seconds)).isoformat()
+        conn = sqlite3.connect(self.db_path, isolation_level=None, timeout=10)
+        try:
+            conn.execute("BEGIN IMMEDIATE")
+            row = conn.execute(
+                "SELECT owner_id, lease_until FROM repair_leases WHERE scope = ? AND key = ?",
+                (scope, key),
+            ).fetchone()
+            if row is not None:
+                existing_owner, existing_until = row
+                if existing_until > now_iso and existing_owner != owner_id:
+                    conn.execute("ROLLBACK")
+                    return ClaimResult(status=ClaimStatus.DENIED)
+            conn.execute(
+                "INSERT INTO repair_leases (scope, key, owner_id, expected_versions, lease_until) "
+                "VALUES (?, ?, ?, ?, ?) "
+                "ON CONFLICT(scope, key) DO UPDATE SET owner_id = excluded.owner_id, "
+                "expected_versions = excluded.expected_versions, lease_until = excluded.lease_until",
+                (scope, key, owner_id, json.dumps(expected_versions), lease_until),
+            )
+            conn.execute("COMMIT")
+        finally:
+            conn.close()
+        lease = Lease(scope, key, owner_id, expected_versions, lease_until)
+        return ClaimResult(status=ClaimStatus.ACQUIRED, lease=lease)
+
+    def get_current(self, scope: str, key: str) -> Lease | None:
+        with closing(sqlite3.connect(self.db_path)) as conn:
+            row = conn.execute(
+                "SELECT owner_id, expected_versions, lease_until FROM repair_leases "
+                "WHERE scope = ? AND key = ?",
+                (scope, key),
+            ).fetchone()
+        if row is None:
+            return None
+        owner_id, expected_versions, lease_until = row
+        return Lease(scope, key, owner_id, json.loads(expected_versions), lease_until)
+
+    def release(self, scope: str, key: str, owner_id: str) -> None:
+        with closing(sqlite3.connect(self.db_path)) as conn:
+            conn.execute(
+                "DELETE FROM repair_leases WHERE scope = ? AND key = ? AND owner_id = ?",
+                (scope, key, owner_id),
+            )
+            conn.commit()
+
+    def _init_schema(self) -> None:
+        with closing(sqlite3.connect(self.db_path)) as conn:
+            conn.execute(
+                """CREATE TABLE IF NOT EXISTS repair_leases (
+                    scope TEXT NOT NULL,
+                    key TEXT NOT NULL,
+                    owner_id TEXT NOT NULL,
+                    expected_versions TEXT NOT NULL,
+                    lease_until TEXT NOT NULL,
+                    PRIMARY KEY (scope, key)
+                )"""
+            )
+            conn.commit()

loom_continuity-0.1.0/src/loom_continuity/coordination/sqlite_outbox.py

@@ -0,0 +1,154 @@
+"""SQLite outbox adapter and atomic SQLite memory/outbox commit."""
+
+import sqlite3
+import uuid
+from contextlib import closing
+from datetime import datetime, timezone
+from typing import Any, Sequence
+
+from loom_continuity.coordination.outbox_types import OutboxEvent, OutboxStatus
+from loom_continuity.knowledge.sqlite import SqliteKnowledgeStore
+from loom_continuity.knowledge.types import ProvenanceRef
+
+EVENT_TYPE_FACT_REVISION_CREATED = "FactRevisionCreated"
+
+
+class SqliteOutbox:
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+        with closing(sqlite3.connect(self.db_path)) as conn:
+            conn.execute(
+                """CREATE TABLE IF NOT EXISTS outbox (
+                    event_id TEXT PRIMARY KEY,
+                    scope TEXT NOT NULL,
+                    key TEXT NOT NULL,
+                    version INTEGER NOT NULL,
+                    previous_version INTEGER,
+                    event_type TEXT NOT NULL,
+                    created_at TEXT NOT NULL,
+                    status TEXT NOT NULL
+                )"""
+            )
+            conn.commit()
+
+    def enqueue(
+        self,
+        conn: sqlite3.Connection,
+        scope: str,
+        key: str,
+        version: int,
+        previous_version: int | None,
+        event_type: str = EVENT_TYPE_FACT_REVISION_CREATED,
+    ) -> str:
+        event_id = str(uuid.uuid4())
+        conn.execute(
+            "INSERT INTO outbox (event_id, scope, key, version, previous_version, event_type, created_at, status) "
+            "VALUES (?, ?, ?, ?, ?, ?, ?, 'pending')",
+            (
+                event_id,
+                scope,
+                key,
+                version,
+                previous_version,
+                event_type,
+                datetime.now(timezone.utc).isoformat(),
+            ),
+        )
+        return event_id
+
+    def pending(self, scope: str | None = None) -> list[OutboxEvent]:
+        with closing(sqlite3.connect(self.db_path)) as conn:
+            if scope is None:
+                rows = conn.execute(
+                    "SELECT event_id, scope, key, version, previous_version, event_type, created_at, status "
+                    "FROM outbox WHERE status = 'pending' ORDER BY created_at"
+                ).fetchall()
+            else:
+                rows = conn.execute(
+                    "SELECT event_id, scope, key, version, previous_version, event_type, created_at, status "
+                    "FROM outbox WHERE status = 'pending' AND scope = ? ORDER BY created_at",
+                    (scope,),
+                ).fetchall()
+        return [self._row_to_event(row) for row in rows]
+
+    def mark_delivered(self, event_id: str) -> None:
+        with closing(sqlite3.connect(self.db_path)) as conn:
+            conn.execute("UPDATE outbox SET status = 'delivered' WHERE event_id = ?", (event_id,))
+            conn.commit()
+
+    def get(self, event_id: str) -> OutboxEvent | None:
+        with closing(sqlite3.connect(self.db_path)) as conn:
+            row = conn.execute(
+                "SELECT event_id, scope, key, version, previous_version, event_type, created_at, status "
+                "FROM outbox WHERE event_id = ?",
+                (event_id,),
+            ).fetchone()
+        return None if row is None else self._row_to_event(row)
+
+    @staticmethod
+    def _row_to_event(row) -> OutboxEvent:
+        return OutboxEvent(*row[:-1], status=OutboxStatus(row[-1]))
+
+
+def commit_fact_with_event(
+    memory: SqliteKnowledgeStore,
+    outbox: SqliteOutbox,
+    scope: str,
+    key: str,
+    value: Any,
+    source_step: str,
+    provenance: Sequence[ProvenanceRef],
+    event_type: str = EVENT_TYPE_FACT_REVISION_CREATED,
+) -> tuple[int, str]:
+    _require_shared_database(memory, outbox)
+    previous_version = memory.get_current_version(scope, key)
+    conn = sqlite3.connect(memory.db_path)
+    try:
+        version = memory.put_fact(scope, key, value, source_step, provenance, _conn=conn)
+        event_id = outbox.enqueue(conn, scope, key, version, previous_version, event_type)
+        conn.commit()
+    finally:
+        conn.close()
+    return version, event_id
+
+
+def commit_fact_with_event_if_versions_match(
+    memory: SqliteKnowledgeStore,
+    outbox: SqliteOutbox,
+    scope: str,
+    key: str,
+    value: Any,
+    source_step: str,
+    provenance: Sequence[ProvenanceRef],
+    expected_versions: dict[str, int],
+    event_type: str = EVENT_TYPE_FACT_REVISION_CREATED,
+) -> tuple[int, str] | None:
+    _require_shared_database(memory, outbox)
+    conn = sqlite3.connect(memory.db_path, isolation_level=None, timeout=10)
+    try:
+        conn.execute("BEGIN IMMEDIATE")
+        for dependency_key, expected_version in expected_versions.items():
+            row = conn.execute(
+                "SELECT MAX(version) FROM facts WHERE scope = ? AND key = ?",
+                (scope, dependency_key),
+            ).fetchone()
+            current_version = row[0] if row and row[0] is not None else None
+            if current_version != expected_version:
+                conn.execute("ROLLBACK")
+                return None
+        previous_row = conn.execute(
+            "SELECT MAX(version) FROM facts WHERE scope = ? AND key = ?",
+            (scope, key),
+        ).fetchone()
+        previous_version = previous_row[0] if previous_row and previous_row[0] is not None else None
+        version = memory.put_fact(scope, key, value, source_step, provenance, _conn=conn)
+        event_id = outbox.enqueue(conn, scope, key, version, previous_version, event_type)
+        conn.execute("COMMIT")
+    finally:
+        conn.close()
+    return version, event_id
+
+
+def _require_shared_database(memory: SqliteKnowledgeStore, outbox: SqliteOutbox) -> None:
+    if memory.db_path != outbox.db_path:
+        raise ValueError("SQLite memory and outbox must share the same database file")

loom_continuity-0.1.0/src/loom_continuity/knowledge/__init__.py

@@ -0,0 +1,12 @@
+from loom_continuity.knowledge.protocol import KnowledgeStore
+from loom_continuity.knowledge.sqlite import SqliteKnowledgeStore
+from loom_continuity.knowledge.types import FactRevision, Lookup, LookupStatus, ProvenanceRef
+
+__all__ = [
+    "FactRevision",
+    "Lookup",
+    "LookupStatus",
+    "ProvenanceRef",
+    "KnowledgeStore",
+    "SqliteKnowledgeStore",
+]

loom_continuity-0.1.0/src/loom_continuity/knowledge/protocol.py

@@ -0,0 +1,33 @@
+"""Storage-independent durable-knowledge contract.
+
+`scope` isolates an independent knowledge domain. It is not a chat session.
+It may name a workflow, tenant, project, incident, job, or agent run.
+
+`LookupStatus.VALID` means provenance dependencies are current.
+It does not mean the stored value is semantically true.
+"""
+
+from typing import Any, Protocol, Sequence, runtime_checkable
+
+from loom_continuity.knowledge.types import FactRevision, Lookup, ProvenanceRef
+
+
+@runtime_checkable
+class KnowledgeStore(Protocol):
+    def put_fact(
+        self,
+        scope: str,
+        key: str,
+        value: Any,
+        source_step: str,
+        provenance: Sequence[ProvenanceRef],
+        status: str = "established",
+    ) -> int: ...
+
+    def get_fact(self, scope: str, key: str) -> FactRevision | None: ...
+
+    def get_revisions(self, scope: str, key: str) -> list[FactRevision]: ...
+
+    def get_current_version(self, scope: str, key: str) -> int | None: ...
+
+    def get_valid_fact(self, scope: str, key: str) -> Lookup: ...

loom_continuity-0.1.0/src/loom_continuity/knowledge/sqlite.py

@@ -0,0 +1,130 @@
+"""SQLite adapter for append-only, provenance-aware knowledge."""
+
+import json
+import sqlite3
+from contextlib import closing
+from datetime import datetime, timezone
+from typing import Any, Sequence
+
+from loom_continuity.knowledge.types import FactRevision, Lookup, LookupStatus, ProvenanceRef
+
+
+class SqliteKnowledgeStore:
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+        with closing(sqlite3.connect(self.db_path)) as conn:
+            conn.execute(
+                """CREATE TABLE IF NOT EXISTS facts (
+                    scope TEXT NOT NULL,
+                    key TEXT NOT NULL,
+                    version INTEGER NOT NULL,
+                    value TEXT NOT NULL,
+                    source_step TEXT NOT NULL,
+                    provenance TEXT NOT NULL,
+                    status TEXT NOT NULL,
+                    created_at TEXT NOT NULL,
+                    PRIMARY KEY (scope, key, version)
+                )"""
+            )
+            conn.commit()
+
+    def put_fact(
+        self,
+        scope: str,
+        key: str,
+        value: Any,
+        source_step: str,
+        provenance: Sequence[ProvenanceRef],
+        status: str = "established",
+        _conn: sqlite3.Connection | None = None,
+    ) -> int:
+        created_at = datetime.now(timezone.utc).isoformat()
+        owns_conn = _conn is None
+        conn = _conn if _conn is not None else sqlite3.connect(self.db_path)
+        try:
+            row = conn.execute(
+                "SELECT MAX(version) FROM facts WHERE scope = ? AND key = ?",
+                (scope, key),
+            ).fetchone()
+            version = (row[0] + 1) if row and row[0] is not None else 1
+            conn.execute(
+                "INSERT INTO facts (scope, key, version, value, source_step, provenance, status, created_at) "
+                "VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+                (
+                    scope,
+                    key,
+                    version,
+                    json.dumps(value),
+                    source_step,
+                    json.dumps(list(provenance)),
+                    status,
+                    created_at,
+                ),
+            )
+            if owns_conn:
+                conn.commit()
+        finally:
+            if owns_conn:
+                conn.close()
+        return version
+
+    def get_fact(self, scope: str, key: str) -> FactRevision | None:
+        with closing(sqlite3.connect(self.db_path)) as conn:
+            row = conn.execute(
+                "SELECT key, value, source_step, provenance, status, created_at, version FROM facts "
+                "WHERE scope = ? AND key = ? ORDER BY version DESC LIMIT 1",
+                (scope, key),
+            ).fetchone()
+        return None if row is None else self._row_to_fact(row)
+
+    def get_revisions(self, scope: str, key: str) -> list[FactRevision]:
+        with closing(sqlite3.connect(self.db_path)) as conn:
+            rows = conn.execute(
+                "SELECT key, value, source_step, provenance, status, created_at, version FROM facts "
+                "WHERE scope = ? AND key = ? ORDER BY version ASC",
+                (scope, key),
+            ).fetchall()
+        return [self._row_to_fact(row) for row in rows]
+
+    def get_current_version(self, scope: str, key: str) -> int | None:
+        with closing(sqlite3.connect(self.db_path)) as conn:
+            row = conn.execute(
+                "SELECT MAX(version) FROM facts WHERE scope = ? AND key = ?",
+                (scope, key),
+            ).fetchone()
+        return row[0] if row and row[0] is not None else None
+
+    def get_valid_fact(
+        self,
+        scope: str,
+        key: str,
+        _seen: frozenset[str] = frozenset(),
+    ) -> Lookup:
+        fact = self.get_fact(scope, key)
+        if fact is None:
+            return Lookup(status=LookupStatus.MISSING, fact=None)
+        if key in _seen:
+            return Lookup(status=LookupStatus.VALID, fact=fact)
+        for dependency in fact.provenance:
+            if not isinstance(dependency, dict) or "key" not in dependency or "version" not in dependency:
+                continue
+            dependency_key = dependency["key"]
+            if self.get_current_version(scope, dependency_key) != dependency["version"]:
+                return Lookup(status=LookupStatus.STALE, fact=fact)
+            dependency_lookup = self.get_valid_fact(scope, dependency_key, _seen | {key})
+            if dependency_lookup.status != LookupStatus.VALID:
+                return Lookup(status=LookupStatus.STALE, fact=fact)
+        return Lookup(status=LookupStatus.VALID, fact=fact)
+
+    @staticmethod
+    def _row_to_fact(row) -> FactRevision:
+        key, value, source_step, provenance, status, created_at, version = row
+        return FactRevision(
+            key=key,
+            value=json.loads(value),
+            source_step=source_step,
+            provenance=json.loads(provenance),
+            status=status,
+            created_at=created_at,
+            version=version,
+        )

loom_continuity-0.1.0/src/loom_continuity/knowledge/types.py

@@ -0,0 +1,37 @@
+"""Stable value types for versioned durable knowledge.
+
+`LookupStatus.VALID` means provenance dependencies are current.
+It does not mean the stored value is semantically true.
+"""
+
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import Any, TypedDict
+
+
+class LookupStatus(StrEnum):
+    MISSING = "MISSING"
+    STALE = "STALE"
+    VALID = "VALID"
+
+
+class ProvenanceRef(TypedDict):
+    key: str
+    version: int
+
+
+@dataclass(frozen=True)
+class FactRevision:
+    key: str
+    value: Any
+    source_step: str
+    provenance: list[ProvenanceRef]
+    status: str = "established"
+    created_at: str | None = None
+    version: int = 1
+
+
+@dataclass(frozen=True)
+class Lookup:
+    status: LookupStatus
+    fact: FactRevision | None

loom_continuity-0.1.0/src/loom_continuity.egg-info/PKG-INFO

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: loom-continuity
+Version: 0.1.0
+Summary: Runtime for durable derived knowledge: versioned results with evidence, staleness, safe recomputation across processes, and crash-safe notification.
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# Loom Continuity
+
+`loom_continuity` is a durable coordination and knowledge-state runtime.
+It is not an agent framework.
+It is designed to sit underneath application harnesses and agent frameworks.
+
+It answers one question: a value was derived from some evidence; is that evidence still current, and if not, who may recompute it without duplicating the work, committing a stale result, or losing the notice that state changed.
+
+The package does not choose the application shape. A caller reads knowledge, checks validity, claims a repair, commits only if the evidence versions still match, and leaves a durable notification. A web app, a worker, a graph runtime, a batch job, or a plain function decides when to make those calls.
+
+## Using it
+
+The first mode is a library inside one process. An application opens `SqliteKnowledgeStore`, `SqliteOutbox`, and `SqliteRepairLease` on one database file. A request looks up a fact. `VALID` returns the stored value. `MISSING` computes it. `STALE` claims the lease, computes outside the database transaction, and commits only if the dependency versions are unchanged. FastAPI, or any other process, is just a client of that runtime. Importing the package does not pull FastAPI in.
+
+The production shape splits roles across processes that share the file. The request process writes evidence and can return before the expensive work. A worker finds stale or missing facts, claims the lease, computes, and commits. A dispatcher delivers pending outbox events and re-reads the current value. Any one of those processes can die. The fact, the pending obligation, and the lease expiry remain in the file.
+
+Several processes can see the same stale key. One claim is `ACQUIRED`. The others are `DENIED` until the lease expires or is released, then they read the repaired value. That is the coordination, not a database wrapper. The SQLite implementation is for one shared file. Several machines should not share that file. The protocols are `KnowledgeStore`, `Outbox`, and `RepairLeaseStore`; a later backend would be a new implementation, not a change to the caller's questions.
+
+An agent framework sits above this. A graph or agent node asks for a fact and skips the expensive chain while the lookup is `VALID`. It runs only when the fact is `STALE` or `MISSING`, then writes the result with provenance. Reuse lasts until the evidence version changes. It is not a time-to-live cache.
+
+A batch job can do the same without a server: `get_valid_fact` for each item, skip what is still `VALID`, repair what is `STALE`, compute what is `MISSING`. A scheduler such as Temporal or Celery can start the activity. This package does not replace that scheduler. The scheduler decides when to run. The runtime decides whether the result is still current and whether the write is still safe.
+
+A later HTTP service can wrap the same calls for other languages. That service is not this package. Callers that can import Python should use the library.
+
+An agent tool can hide the protocol and return the current fact, or report `STALE` and leave repair to an orchestrator. Several agents can share one store. When evidence moves, the derived fact becomes `STALE` for all of them. That is shared institutional knowledge, not conversation history.
+
+The compute step can be a Python function. Nothing in the core requires a model.
+
+The distribution version is declared once, in `pyproject.toml`. This cut is `0.1.0`.
+The base install has no FastAPI, torch, or model-runtime dependency.
+
+## What it guarantees
+
+- Versioned knowledge survives process death. A later process can reopen the same store.
+- `LookupStatus.VALID` means every provenance dependency version is still current, including transitive dependencies.
+- A fact whose dependency moved is `STALE`. The stored revision is not deleted.
+- If `A -> B -> C` and `A` changes, `C` is stale even when `B`'s revision number has not changed.
+- The store does not repair itself. A caller claims a per-scope, per-key lease, computes outside any database transaction, and commits only if the dependency versions still match.
+- A lease expires. After the owner process dies, another worker can acquire it. The lease is not held as a long transaction across the computation.
+- A repair computed against old dependency versions is rejected. That result never becomes the current committed value.
+- A fact revision and its outbox obligation commit in one transaction. A crash after commit leaves both. A crash before commit leaves neither.
+- Delivery is at-least-once. Pending events remain until the consumer returns.
+- Reopen, stale detection, single-owner repair, rejected stale commits, crash boundaries, and current-state delivery are covered by `loom_continuity_e2e`.
+
+## What it does not guarantee
+
+- `VALID` does not mean semantically correct, true, safe, approved, or high confidence. A wrong value is `VALID` while its dependency chain is current.
+- Delivery is not exactly-once.
+- The package does not deduplicate consumer side effects.
+- Outbox events are not an event log of authoritative values. This is not event sourcing.
+- There is no agent loop, tool framework, conversation memory, or semantic/vector memory.
+- There is no auth, UI, or deployment framework.
+
+## Not in this cut
+
+v0.1 is one SQLite file and process coordination around it. It is not a city. These are outside the frozen contract:
+
+- identity service
+- permissions
+- scheduler
+- service discovery
+- policy enforcement beyond provenance freshness
+- a second storage backend
+- coordination across nodes
+
+`KnowledgeStore`, `Outbox`, and `RepairLeaseStore` are protocols with a SQLite implementation. Another backend is an open slot, not a delivered adapter. `scope` is a namespace string, not an identity. Lease TTL is an expiry, not a scheduler.
+
+## `scope`
+
+`scope` is the isolation namespace for independent knowledge state.
+It may name a tenant, workflow, project, incident, job, or another application domain.
+It is not a conversation id.
+
+Public methods take `scope`. The SQLite primary key column is already `scope`. There is no `session_id` column and no schema migration in this cut.
+
+## Public import surface
+
+```python
+from loom_continuity import (
+    KnowledgeStore,
+    SqliteKnowledgeStore,
+    FactRevision,
+    ProvenanceRef,
+    Lookup,
+    LookupStatus,
+    Outbox,
+    SqliteOutbox,
+    OutboxEvent,
+    OutboxStatus,
+    commit_fact_with_event,
+    commit_fact_with_event_if_versions_match,
+    dispatch_pending,
+    RepairLeaseStore,
+    SqliteRepairLease,
+    Lease,
+    ClaimStatus,
+    ClaimResult,
+    LLMBackend,
+    StatefulLLMBackend,
+)
+```
+
+`KnowledgeStore` is the storage protocol. `SqliteKnowledgeStore` is the SQLite implementation.
+`FactRevision` is the only fact value type. There is no separate `Fact` alias.
+`Lease` is the only lease value type. `claim` returns `ClaimStatus.DENIED` and does not raise.
+`commit_fact_with_event` and `commit_fact_with_event_if_versions_match` are the public atomic write and conditional-commit operations. They are not private helpers.
+`LLMBackend` and `StatefulLLMBackend` are dependency-free call contracts. Model runtimes are not part of the base package.
+
+## Current-State Notification Semantics
+
+An outbox event identifies that state changed. It carries `scope`, `key`, `version`, and a stable `event_id`. It does not carry the authoritative fact value.
+
+The consumer re-reads the current value from `SqliteKnowledgeStore`.
+If revision 1 then revision 2 were committed, delivering the newer event and then the older event still reads revision 2 both times.
+A delayed older notification cannot restore an older value.
+
+This is not event sourcing.
+
+## Consumer idempotency
+
+Dispatch is at-least-once. The same `event_id` can be handed to the consumer more than once, including after a crash before acknowledgement.
+
+The package does not suppress that repeat. A consumer that must apply a logical effect once deduplicates on `event_id` itself, for example with `INSERT OR IGNORE`.
+
+## Install and acceptance
+
+From a clean environment, install the package, then run the acceptance suite from a checkout of this repository. The suite is not inside the wheel, and the runner does not put the source tree on `PYTHONPATH`.
+
+```bash
+python -m venv /tmp/loom-continuity-accept
+source /tmp/loom-continuity-accept/bin/activate
+pip install loom-continuity
+python loom_continuity_e2e/run_all.py
+```
+
+Expected result: `10/10 PASS`, and `loom_continuity.__file__` under that environment's `site-packages`.
+
+Package-local unit checks, from this directory:
+
+```bash
+python -m unittest discover -s tests -v
+```
+
+A separate minimal consumer lives at `examples/minimal_consumer/` in the repository. It imports only the public package API.

loom_continuity-0.1.0/src/loom_continuity.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+README.md
+pyproject.toml
+src/loom_continuity/__init__.py
+src/loom_continuity.egg-info/PKG-INFO
+src/loom_continuity.egg-info/SOURCES.txt
+src/loom_continuity.egg-info/dependency_links.txt
+src/loom_continuity.egg-info/top_level.txt
+src/loom_continuity/backends/__init__.py
+src/loom_continuity/backends/base.py
+src/loom_continuity/coordination/__init__.py
+src/loom_continuity/coordination/lease_protocol.py
+src/loom_continuity/coordination/lease_types.py
+src/loom_continuity/coordination/outbox_protocol.py
+src/loom_continuity/coordination/outbox_types.py
+src/loom_continuity/coordination/sqlite_lease.py
+src/loom_continuity/coordination/sqlite_outbox.py
+src/loom_continuity/knowledge/__init__.py
+src/loom_continuity/knowledge/protocol.py
+src/loom_continuity/knowledge/sqlite.py
+src/loom_continuity/knowledge/types.py
+tests/test_v01_core.py

loom_continuity-0.1.0/src/loom_continuity.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

loom_continuity-0.1.0/src/loom_continuity.egg-info/top_level.txt

@@ -0,0 +1 @@
+loom_continuity

loom_continuity-0.1.0/tests/test_v01_core.py

@@ -0,0 +1,131 @@
+"""Proofs that travel with the package, not with ticket_harness."""
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+
+PUBLIC_API = {
+    "LLMBackend",
+    "StatefulLLMBackend",
+    "FactRevision",
+    "ProvenanceRef",
+    "Lookup",
+    "LookupStatus",
+    "KnowledgeStore",
+    "SqliteKnowledgeStore",
+    "OutboxEvent",
+    "OutboxStatus",
+    "Outbox",
+    "SqliteOutbox",
+    "commit_fact_with_event",
+    "commit_fact_with_event_if_versions_match",
+    "dispatch_pending",
+    "Lease",
+    "ClaimStatus",
+    "ClaimResult",
+    "RepairLeaseStore",
+    "SqliteRepairLease",
+}
+
+
+class ImportBoundaryTest(unittest.TestCase):
+    def test_public_surface_matches_frozen_snapshot(self):
+        import loom_continuity
+
+        self.assertEqual(set(loom_continuity.__all__), PUBLIC_API)
+        for name in ("Fact", "RepairLease", "LeaseDenied", "SessionMemory", "DurableKnowledge"):
+            self.assertNotIn(name, loom_continuity.__all__)
+            self.assertFalse(hasattr(loom_continuity, name))
+
+    def test_root_import_pulls_no_adapter_or_app(self):
+        import loom_continuity
+        loaded = set(sys.modules)
+        self.assertIn("loom_continuity.knowledge.protocol", loaded)
+        self.assertIn("loom_continuity.knowledge.sqlite", loaded)
+        banned = ("torch", "transformers", "httpx", "fastapi", "sentence_transformers")
+        self.assertFalse(any(name == b or name.startswith(b + ".") for name in loaded for b in banned))
+        self.assertTrue(hasattr(loom_continuity, "SqliteKnowledgeStore"))
+        self.assertTrue(hasattr(loom_continuity, "LLMBackend"))
+
+
+class MemoryTest(unittest.TestCase):
+    def test_sqlite_adapter_satisfies_memory_protocol(self):
+        from loom_continuity import KnowledgeStore, SqliteKnowledgeStore
+
+        with tempfile.TemporaryDirectory() as tmp:
+            self.assertIsInstance(SqliteKnowledgeStore(str(Path(tmp) / "m.sqlite3")), KnowledgeStore)
+
+    def test_valid_means_dependency_versions_match(self):
+        from loom_continuity import SqliteKnowledgeStore
+
+        with tempfile.TemporaryDirectory() as tmp:
+            memory = SqliteKnowledgeStore(str(Path(tmp) / "m.sqlite3"))
+            memory.put_fact("s", "color", "blue", "seed", [])
+            v = memory.get_current_version("s", "color")
+            memory.put_fact("s", "action", "monitor", "derive", [{"key": "color", "version": v}])
+            self.assertEqual(memory.get_valid_fact("s", "action").status, "VALID")
+            memory.put_fact("s", "color", "red", "mutate", [])
+            lookup = memory.get_valid_fact("s", "action")
+            self.assertEqual(lookup.status, "STALE")
+            self.assertEqual(lookup.fact.value, "monitor")
+
+
+class OutboxTest(unittest.TestCase):
+    def test_sqlite_adapter_satisfies_outbox_protocol(self):
+        from loom_continuity import Outbox, SqliteOutbox
+
+        with tempfile.TemporaryDirectory() as tmp:
+            self.assertIsInstance(SqliteOutbox(str(Path(tmp) / "o.sqlite3")), Outbox)
+
+    def test_commit_is_atomic_and_cas_rejects_moved_evidence(self):
+        from loom_continuity import SqliteOutbox, SqliteKnowledgeStore, commit_fact_with_event, commit_fact_with_event_if_versions_match
+
+        with tempfile.TemporaryDirectory() as tmp:
+            path = str(Path(tmp) / "o.sqlite3")
+            memory = SqliteKnowledgeStore(path)
+            outbox = SqliteOutbox(path)
+            memory.put_fact("s", "policy", "platform", "seed", [])
+            version, event_id = commit_fact_with_event(
+                memory, outbox, "s", "route", {"team": "platform"}, "compute",
+                [{"key": "policy", "version": 1}],
+            )
+            self.assertEqual(version, 1)
+            self.assertEqual(len(outbox.pending("s")), 1)
+            self.assertEqual(outbox.get(event_id).version, 1)
+
+            memory.put_fact("s", "policy", "escalations", "change", [])
+            rejected = commit_fact_with_event_if_versions_match(
+                memory, outbox, "s", "route", {"team": "old"}, "repair",
+                [{"key": "policy", "version": 1}],
+                {"policy": 1},
+            )
+            self.assertIsNone(rejected)
+            self.assertEqual(memory.get_fact("s", "route").value["team"], "platform")
+            self.assertEqual(len(outbox.pending("s")), 1)
+
+
+class LeaseTest(unittest.TestCase):
+    def test_sqlite_adapter_satisfies_lease_protocol(self):
+        from loom_continuity import RepairLeaseStore, SqliteRepairLease
+
+        with tempfile.TemporaryDirectory() as tmp:
+            self.assertIsInstance(SqliteRepairLease(str(Path(tmp) / "l.sqlite3")), RepairLeaseStore)
+
+    def test_second_owner_is_denied_until_release(self):
+        from loom_continuity import ClaimStatus, SqliteRepairLease
+
+        with tempfile.TemporaryDirectory() as tmp:
+            path = str(Path(tmp) / "l.sqlite3")
+            leases = SqliteRepairLease(path)
+            first = leases.claim("s", "route", "owner-a", {"policy": 1}, lease_seconds=30)
+            denied = leases.claim("s", "route", "owner-b", {"policy": 1}, lease_seconds=30)
+            self.assertEqual(first.status, ClaimStatus.ACQUIRED)
+            self.assertEqual(denied.status, ClaimStatus.DENIED)
+            leases.release("s", "route", "owner-a")
+            acquired = leases.claim("s", "route", "owner-b", {"policy": 2}, lease_seconds=30)
+            self.assertEqual(acquired.status, ClaimStatus.ACQUIRED)
+
+
+if __name__ == "__main__":
+    unittest.main()