copresence 0.1.0__tar.gz

copresence-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,16 @@
+name: ci
+on: [push, pull_request]
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        python: ["3.10", "3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with: { python-version: "${{ matrix.python }}" }
+      - run: pip install -e . pytest
+      - run: pytest tests/ -q
+      - run: copresence demo

copresence-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+.venv/
+dist/
+__pycache__/
+*.egg-info/
+copresence_layers/

copresence-0.1.0/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

copresence-0.1.0/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: copresence
+Version: 0.1.0
+Summary: Associative memory for event streams: link moments by co-presence (what was there), not just similarity (what it resembles).
+Project-URL: Homepage, https://github.com/myfjin/copresence
+Author: Illia Hladkyi
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: agents,associative,context,memory,recall,spreading-activation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Provides-Extra: embeddings
+Requires-Dist: sentence-transformers>=2.2; extra == 'embeddings'
+Description-Content-Type: text/markdown
+
+# copresence
+
+**Associative memory for event streams: link moments by co-presence (what was
+_there_), not just similarity (what it _resembles_). A complement to embedding
+recall, not a replacement.**
+
+Zero dependencies. Pure stdlib. `pip install copresence`
+
+## The black t-shirt law
+
+You're trying to remember a conversation from years ago. Searching your memory by
+*content* gives you nothing — the conversation doesn't resemble anything you can
+name. Then a friend says: *"you were wearing that black t-shirt… the kettle was
+on… it was the day the heater broke"* — and the whole context **rebuilds itself**.
+
+The t-shirt never resembled the conversation. It was simply **there**.
+
+Embedding-based recall (RAG, vector search) is content-similarity: it finds what
+*resembles* the query. It systematically misses everything that was merely
+*co-present* — the peripheral details, the same-day decisions, the parallel
+threads. `copresence` adds that missing axis: it links moments **by having shared
+a scene, a day, an era**, and recalls by **spreading activation** through those
+links.
+
+## Quickstart
+
+```python
+from copresence import Store, ref, hash_embedder, probe
+
+events = [  # any event stream: chat logs, journals, tickets, commits…
+    {"timestamp": "2026-01-05T10:00:00+00:00", "speaker": "a", "content": "…"},
+    # {"timestamp": ISO-8601, "speaker": str, "content": str}
+]
+
+store = Store("./layers")
+store.link(events)                        # co-presence links: scene + day + era
+store.notice(ref(events[3]), "me", "this mattered")   # authored mark
+
+# recall by cascade: seeds spread through co-presence, not similarity
+adj = store.graph("me")
+context = store.cascade({ref(events[3])}, adj)
+```
+
+Or just run the built-in demonstration:
+
+```
+pip install copresence
+copresence demo
+```
+
+which builds a small synthetic corpus where a red kettle whistles near lighthouse
+work (separate moments, same scenes), shows that similarity recall ranks the
+target poorly for the kettle cue, and then rebuilds it through the co-presence
+cascade. Deterministic; runs anywhere; no model download.
+
+## Concepts
+
+- **Layers are sovereign.** Every member (person, agent) gets their own link
+  files. `links.jsonl` is *authored* — appended, never rebuilt. `auto_links.jsonl`
+  is *derived* — rebuilt by the linker on every run. Structural co-presence is
+  shared because it's computable from timestamps alone.
+- **"That day" is a memory node.** Co-presence works at three scales: adjacency
+  (the scene), day-hubs, era-hubs (the week). Touching one moment can pull what
+  else the day held.
+- **Presence weighting.** Not every co-occurrence is equal: moments carrying
+  gravity markers or notice-marks weigh their links up; incidental co-occurrence
+  weighs half.
+- **Decay with resurrection.** Unused links fade toward a dormant floor — dormancy,
+  never death. When a cascade touches a dormant link, it re-animates the *whole
+  scene* around it, not just the node.
+- **Warming.** `warm()` scores which *dormant* moments are heating up under the
+  current context (heat = kinship-to-now × dormancy), with a `should_interrupt`
+  attention boundary — the caller decides whether to speak. Feed it the record's
+  **tail**, not a query: continuity anchors in time, not similarity. We learned
+  that from a failed probe and kept the law.
+- **Discovery.** `discover_regular()` maps the day-to-day roads (themes alive
+  across many days); `discover_deep()` hunts dormant chains — strong kinship
+  across a long gap, never cross-referenced. These are **candidates, not claims**:
+  whether a deep pair "hits" is the member's subjective call.
+- **Resonance.** Which moments live in one member's layer (private wealth), two,
+  or all? The field is computed; verdicts are not — private wealth is never
+  forced shared.
+
+## Embedders
+
+The cascade, linker, notices and layers are pure stdlib. `discover`, `warm` and
+`probe` need an embedder — any callable `list[str] -> vectors`:
+
+```python
+from copresence import hash_embedder      # zero-dep hashing bag-of-words (a TOY —
+                                          # fine for demos/tests, no real semantics)
+from copresence import st_embedder        # real: pip install copresence[embeddings]
+embed = st_embedder()                     # sentence-transformers MiniLM
+```
+
+## Honest notes
+
+- The mechanism is young. In our own (private) corpus of ~520 events, a target
+  that content-recall ranked 265th was rebuilt by a two-hop cascade from six
+  peripheral cues (similarity 0.03–0.18 to the query), and a negative control —
+  the same cues against a different-day target — was correctly *not* reached.
+  The bundled demo reproduces the same geometry synthetically on your machine;
+  it proves the mechanism, not magic on your data.
+- Mood/register link heuristics exist but are **experimental and off by default**
+  (`Store(registers=...)`) — our own instance is too young to have proven them.
+- The hashing embedder is a toy. Real corpora deserve a real embedder.
+- `discover_deep` can surface echo-shaped pairs (a summary of a moment vs the
+  moment). The identity cap catches most; your judgment catches the rest.
+
+## License
+
+Apache-2.0

copresence-0.1.0/README.md

@@ -0,0 +1,112 @@
+# copresence
+
+**Associative memory for event streams: link moments by co-presence (what was
+_there_), not just similarity (what it _resembles_). A complement to embedding
+recall, not a replacement.**
+
+Zero dependencies. Pure stdlib. `pip install copresence`
+
+## The black t-shirt law
+
+You're trying to remember a conversation from years ago. Searching your memory by
+*content* gives you nothing — the conversation doesn't resemble anything you can
+name. Then a friend says: *"you were wearing that black t-shirt… the kettle was
+on… it was the day the heater broke"* — and the whole context **rebuilds itself**.
+
+The t-shirt never resembled the conversation. It was simply **there**.
+
+Embedding-based recall (RAG, vector search) is content-similarity: it finds what
+*resembles* the query. It systematically misses everything that was merely
+*co-present* — the peripheral details, the same-day decisions, the parallel
+threads. `copresence` adds that missing axis: it links moments **by having shared
+a scene, a day, an era**, and recalls by **spreading activation** through those
+links.
+
+## Quickstart
+
+```python
+from copresence import Store, ref, hash_embedder, probe
+
+events = [  # any event stream: chat logs, journals, tickets, commits…
+    {"timestamp": "2026-01-05T10:00:00+00:00", "speaker": "a", "content": "…"},
+    # {"timestamp": ISO-8601, "speaker": str, "content": str}
+]
+
+store = Store("./layers")
+store.link(events)                        # co-presence links: scene + day + era
+store.notice(ref(events[3]), "me", "this mattered")   # authored mark
+
+# recall by cascade: seeds spread through co-presence, not similarity
+adj = store.graph("me")
+context = store.cascade({ref(events[3])}, adj)
+```
+
+Or just run the built-in demonstration:
+
+```
+pip install copresence
+copresence demo
+```
+
+which builds a small synthetic corpus where a red kettle whistles near lighthouse
+work (separate moments, same scenes), shows that similarity recall ranks the
+target poorly for the kettle cue, and then rebuilds it through the co-presence
+cascade. Deterministic; runs anywhere; no model download.
+
+## Concepts
+
+- **Layers are sovereign.** Every member (person, agent) gets their own link
+  files. `links.jsonl` is *authored* — appended, never rebuilt. `auto_links.jsonl`
+  is *derived* — rebuilt by the linker on every run. Structural co-presence is
+  shared because it's computable from timestamps alone.
+- **"That day" is a memory node.** Co-presence works at three scales: adjacency
+  (the scene), day-hubs, era-hubs (the week). Touching one moment can pull what
+  else the day held.
+- **Presence weighting.** Not every co-occurrence is equal: moments carrying
+  gravity markers or notice-marks weigh their links up; incidental co-occurrence
+  weighs half.
+- **Decay with resurrection.** Unused links fade toward a dormant floor — dormancy,
+  never death. When a cascade touches a dormant link, it re-animates the *whole
+  scene* around it, not just the node.
+- **Warming.** `warm()` scores which *dormant* moments are heating up under the
+  current context (heat = kinship-to-now × dormancy), with a `should_interrupt`
+  attention boundary — the caller decides whether to speak. Feed it the record's
+  **tail**, not a query: continuity anchors in time, not similarity. We learned
+  that from a failed probe and kept the law.
+- **Discovery.** `discover_regular()` maps the day-to-day roads (themes alive
+  across many days); `discover_deep()` hunts dormant chains — strong kinship
+  across a long gap, never cross-referenced. These are **candidates, not claims**:
+  whether a deep pair "hits" is the member's subjective call.
+- **Resonance.** Which moments live in one member's layer (private wealth), two,
+  or all? The field is computed; verdicts are not — private wealth is never
+  forced shared.
+
+## Embedders
+
+The cascade, linker, notices and layers are pure stdlib. `discover`, `warm` and
+`probe` need an embedder — any callable `list[str] -> vectors`:
+
+```python
+from copresence import hash_embedder      # zero-dep hashing bag-of-words (a TOY —
+                                          # fine for demos/tests, no real semantics)
+from copresence import st_embedder        # real: pip install copresence[embeddings]
+embed = st_embedder()                     # sentence-transformers MiniLM
+```
+
+## Honest notes
+
+- The mechanism is young. In our own (private) corpus of ~520 events, a target
+  that content-recall ranked 265th was rebuilt by a two-hop cascade from six
+  peripheral cues (similarity 0.03–0.18 to the query), and a negative control —
+  the same cues against a different-day target — was correctly *not* reached.
+  The bundled demo reproduces the same geometry synthetically on your machine;
+  it proves the mechanism, not magic on your data.
+- Mood/register link heuristics exist but are **experimental and off by default**
+  (`Store(registers=...)`) — our own instance is too young to have proven them.
+- The hashing embedder is a toy. Real corpora deserve a real embedder.
+- `discover_deep` can surface echo-shaped pairs (a summary of a moment vs the
+  moment). The identity cap catches most; your judgment catches the rest.
+
+## License
+
+Apache-2.0

copresence-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "copresence"
+version = "0.1.0"
+description = "Associative memory for event streams: link moments by co-presence (what was there), not just similarity (what it resembles)."
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.10"
+authors = [{ name = "Illia Hladkyi" }]
+keywords = ["memory", "associative", "recall", "agents", "context", "spreading-activation"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[project.optional-dependencies]
+embeddings = ["sentence-transformers>=2.2"]
+
+[project.scripts]
+copresence = "copresence.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/myfjin/copresence"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/copresence"]

copresence-0.1.0/src/copresence/__init__.py

@@ -0,0 +1,12 @@
+"""copresence — associative memory for event streams.
+
+Link moments by co-presence (what was THERE), not just similarity (what it
+RESEMBLES). A complement to embedding recall, not a replacement.
+"""
+from .core import Store, ref
+from .recall import (discover_deep, discover_regular, hash_embedder, probe,
+                     st_embedder, warm)
+
+__version__ = "0.1.0"
+__all__ = ["Store", "ref", "hash_embedder", "st_embedder",
+           "discover_regular", "discover_deep", "warm", "probe", "__version__"]

copresence-0.1.0/src/copresence/cli.py

@@ -0,0 +1,63 @@
+"""copresence CLI — link, notice, discover, warm, demo over an events.jsonl.
+
+Events file: one JSON object per line: {"timestamp": ISO-8601, "speaker": str,
+"content": str}. Layers live under --root (default ./copresence_layers).
+"""
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from .core import Store, ref
+from .recall import discover_deep, discover_regular, hash_embedder, warm
+
+
+def _events(p: str) -> list[dict]:
+    return [json.loads(l) for l in Path(p).read_text(encoding="utf-8").splitlines() if l.strip()]
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="copresence", description=__doc__)
+    ap.add_argument("cmd", choices=["link", "notice", "discover", "warm", "demo"])
+    ap.add_argument("--events", default="events.jsonl")
+    ap.add_argument("--root", default="copresence_layers")
+    ap.add_argument("--member", default="member")
+    ap.add_argument("--note", default="")
+    ap.add_argument("--ref", default="last")
+    ap.add_argument("--gap", type=int, default=7)
+    a = ap.parse_args(argv)
+
+    if a.cmd == "demo":
+        from .demo import run
+        run()
+        return
+    store = Store(a.root)
+    ev = _events(a.events)
+    if a.cmd == "link":
+        print(json.dumps(store.link(ev)))
+    elif a.cmd == "notice":
+        r = ref(ev[-1]) if a.ref == "last" else a.ref
+        row = store.notice(r, a.member, a.note)
+        print(f"noticed {row['from']} by {a.member} ({row['link_id']})")
+    elif a.cmd == "discover":
+        X = hash_embedder([e["content"] for e in ev])
+        print("== regular roads (themes alive across days) ==")
+        for r in discover_regular(ev, X):
+            print(f"  {r['days_alive']}d alive · {r['n_events']} events · “{r['exemplar'][:70]}”")
+        print(f"== deep candidates (kin across ≥{a.gap}d, never cross-referenced) ==")
+        for d in discover_deep(ev, X, gap_days=a.gap):
+            print(f"  sim {d['sim']} across {d['gap_days']}d")
+            print(f"    THEN “{d['then']['excerpt'][:70]}”\n    NOW  “{d['now']['excerpt'][:70]}”")
+        print("(candidates, not claims — whether one HITS is the member's call)")
+    elif a.cmd == "warm":
+        X = hash_embedder([e["content"] for e in ev])
+        tail = " ".join(e["content"][:400] for e in ev[-3:])
+        v = hash_embedder([tail])[0]
+        for w in warm(ev, X, v):
+            mark = " ⚡" if w["should_interrupt"] else ""
+            print(f"  heat {w['heat']} · {w['age_days']}d dormant{mark} · “{w['excerpt'][:70]}”")
+
+
+if __name__ == "__main__":
+    main()

copresence-0.1.0/src/copresence/core.py

@@ -0,0 +1,223 @@
+"""copresence.core — link moments by co-presence (what was THERE),
+not just similarity (what it RESEMBLES).
+
+Pure stdlib. The mechanics:
+
+  EVENTS   a list of {"timestamp": ISO-8601, "speaker": str, "content": str}
+  LAYERS   per-member link files under a root dir:
+             <root>/<member>/links.jsonl        AUTHORED — appended, never rebuilt
+             <root>/<member>/auto_links.jsonl   DERIVED — rebuilt by the linker
+             <root>/_structural/                fact-derived co-presence (shared)
+  LINKER   co-presence at three scales: adjacency (the scene), day-hubs ("that day"
+           is itself a memory node), era-hubs (the week). Weights carry PRESENCE
+           (gravity moments outweigh incidental co-occurrence) and DECAY at read
+           time (dormancy, never death).
+  CASCADE  spreading activation with RESURRECTION: touching a dormant link
+           re-animates its whole scene, not just the node.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+from collections import defaultdict
+from datetime import datetime, timezone
+from pathlib import Path
+
+# ── tunables (documented defaults; override via Store kwargs) ───────────────────
+ADJ_MIN = 45           # minutes: adjacency = the scene
+HALF_LIFE_D = 14       # days: effective link weight halves per half-life unused
+DORMANT_FLOOR = 0.05   # links fade to dormancy, never to zero
+RESURRECT_T = 0.15     # touching a link this weak re-animates its scene
+CASCADE_HOPS = 2
+
+# gravity: markers of moments that MATTER (generic defaults — pass your own)
+GRAVITY = ("this matters", "important", "remember this", "decision",
+           "never forget", "sealed", "i was wrong")
+
+
+def _ts(s: str) -> datetime:
+    return datetime.fromisoformat(s.replace("Z", "+00:00"))
+
+
+def _day(e: dict) -> str:
+    return e["timestamp"][:10]
+
+
+def ref(e: dict) -> str:
+    """Stable reference for an event: ev:<timestamp>:<speaker>."""
+    return f"ev:{e['timestamp']}:{e.get('speaker', '?')}"
+
+
+class Store:
+    """A copresence layer store rooted at a directory. Sovereignty by construction:
+    every member's layer is a separate file; authored rows are never rebuilt."""
+
+    def __init__(self, root: str | Path, adj_min: int = ADJ_MIN,
+                 half_life_d: float = HALF_LIFE_D, gravity: tuple = GRAVITY,
+                 registers: dict[str, tuple] | None = None):
+        self.root = Path(root)
+        self.adj_min = adj_min
+        self.half_life_d = half_life_d
+        self.gravity = tuple(g.lower() for g in gravity)
+        # registers: OPTIONAL per-member mood heuristics {register: (markers,)}.
+        # Experimental — off by default; mood links are openly subjective.
+        self.registers = registers or {}
+
+    # ── files ────────────────────────────────────────────────────────────────
+    def layer_file(self, member: str, auto: bool = False) -> Path:
+        d = self.root / member
+        d.mkdir(parents=True, exist_ok=True)
+        return d / ("auto_links.jsonl" if auto else "links.jsonl")
+
+    @staticmethod
+    def _load(p: Path) -> list[dict]:
+        if not p.exists():
+            return []
+        return [json.loads(l) for l in p.read_text(encoding="utf-8").splitlines() if l.strip()]
+
+    def _mk(self, member, kind, fr, to, weight, texture="", authored="linker", note=""):
+        return {"link_id": hashlib.sha1(f"{member}|{kind}|{fr}|{to}".encode()).hexdigest()[:12],
+                "ts": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+                "member": member, "kind": kind, "from": fr, "to": to,
+                "weight": round(float(weight), 3), "texture": texture,
+                "authored_by": authored, "note": note}
+
+    # ── presence & decay ─────────────────────────────────────────────────────
+    def _notice_refs(self) -> set:
+        refs = set()
+        if self.root.exists():
+            for p in self.root.glob("*/links.jsonl"):
+                for l in self._load(p):
+                    if l.get("kind") == "notice":
+                        refs.add(l["from"])
+        return refs
+
+    def presence(self, e: dict, notice_refs: set) -> float:
+        """0.5 incidental · +0.3 gravity marker · +0.2 notice-marked · cap 1.0"""
+        p, low = 0.5, e["content"].lower()
+        if any(g in low for g in self.gravity):
+            p += 0.3
+        if ref(e) in notice_refs:
+            p += 0.2
+        return min(1.0, p)
+
+    def decayed(self, w: float, r: str, now: datetime | None = None) -> float:
+        """Read-time decay toward the dormant floor. Hubs (day:/era:) don't decay —
+        they are places, not moments."""
+        if not r.startswith("ev:"):
+            return w
+        try:
+            age_d = ((now or datetime.now(timezone.utc))
+                     - _ts(r.split(":", 1)[1].rsplit(":", 1)[0])).days
+        except ValueError:
+            return w
+        return max(DORMANT_FLOOR, w * (0.5 ** (age_d / self.half_life_d)))
+
+    # ── the linker (derived layers, rebuilt each run) ────────────────────────
+    def link(self, events: list[dict]) -> dict:
+        nrefs = self._notice_refs()
+        srows = []
+        for a, b in zip(events, events[1:]):
+            gap_min = (_ts(b["timestamp"]) - _ts(a["timestamp"])).total_seconds() / 60
+            if 0 <= gap_min <= self.adj_min:
+                base = max(0.3, 1 - gap_min / self.adj_min)
+                pres = (self.presence(a, nrefs) + self.presence(b, nrefs)) / 2
+                srows.append(self._mk("_structural", "co-presence", ref(a), ref(b), base * pres))
+        for e in events:
+            srows.append(self._mk("_structural", "day", f"day:{_day(e)}", ref(e),
+                                  0.4 * self.presence(e, nrefs)))
+        for d in sorted({_day(e) for e in events}):
+            y, w, _ = datetime.fromisoformat(d).isocalendar()
+            srows.append(self._mk("_structural", "era", f"era:{y}-W{w:02d}", f"day:{d}", 0.3))
+        self.layer_file("_structural", auto=True).write_text(
+            "".join(json.dumps(r, ensure_ascii=False) + "\n" for r in srows), encoding="utf-8")
+        out = {"structural": len(srows)}
+        # optional mood roads (experimental, per-member registers)
+        for member, regs in self.registers.items():
+            by = defaultdict(list)
+            for e in events:
+                best, hits = "", 0
+                low = e["content"].lower()
+                for k, sigs in regs.items():
+                    h = sum(1 for s in sigs if s.lower() in low)
+                    if h > hits:
+                        best, hits = k, h
+                if best:
+                    by[best].append(e)
+            arows = []
+            for reg, evs in by.items():
+                for a, b in zip(evs, evs[1:]):
+                    if (_ts(b["timestamp"]) - _ts(a["timestamp"])).total_seconds() >= 12 * 3600:
+                        arows.append(self._mk(member, "mood", ref(a), ref(b), 0.5, texture=reg))
+            self.layer_file(member, auto=True).write_text(
+                "".join(json.dumps(r, ensure_ascii=False) + "\n" for r in arows), encoding="utf-8")
+            out[f"{member}_mood"] = len(arows)
+        return out
+
+    # ── authored rows (never rebuilt) ────────────────────────────────────────
+    def notice(self, r: str, member: str, note: str = "") -> dict:
+        """'This moment should be noticed' — an authored mark, a fact whose content
+        is subjective."""
+        row = self._mk(member, "notice", r, r, 1.0, authored="notice", note=note)
+        with self.layer_file(member).open("a", encoding="utf-8") as f:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+        return row
+
+    def add_link(self, member, kind, fr, to, weight=1.0, texture="", note="") -> dict:
+        row = self._mk(member, kind, fr, to, weight, texture=texture, authored="member", note=note)
+        with self.layer_file(member).open("a", encoding="utf-8") as f:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+        return row
+
+    # ── graph + cascade ──────────────────────────────────────────────────────
+    def graph(self, member: str) -> dict:
+        adj = defaultdict(list)
+        for src in ("_structural", member):
+            for auto in (False, True):
+                for l in self._load(self.layer_file(src, auto=auto)):
+                    adj[l["from"]].append((l["to"], l["weight"], l["kind"]))
+                    adj[l["to"]].append((l["from"], l["weight"], l["kind"]))
+        return adj
+
+    def cascade(self, seeds: set, adj: dict, hops: int = CASCADE_HOPS) -> set:
+        """Spreading activation, hop-bounded. RESURRECTION: reaching a moment
+        through a dormant link re-animates its whole scene (its day-hub spokes)."""
+        now = datetime.now(timezone.utc)
+        seen, frontier = set(seeds), list(seeds)
+        for _ in range(hops):
+            nxt = []
+            for r in frontier:
+                for t, w, _k in adj.get(r, ()):
+                    if t in seen:
+                        continue
+                    seen.add(t)
+                    nxt.append(t)
+                    if t.startswith("ev:") and self.decayed(w, t, now) <= RESURRECT_T:
+                        for d in (x for x, _w2, k2 in adj.get(t, ()) if k2 == "day"):
+                            for spoke, _w3, _k3 in adj.get(d, ()):
+                                if spoke not in seen:
+                                    seen.add(spoke)
+                                    nxt.append(spoke)
+            frontier = nxt
+        return seen
+
+    def resonance(self) -> dict:
+        """Which moments live in which members' layers: all-three / two / private
+        wealth. The field, not a verdict — private wealth is never forced shared."""
+        members = [d.name for d in self.root.iterdir()
+                   if d.is_dir() and d.name != "_structural"] if self.root.exists() else []
+        holds = defaultdict(set)
+        for m in members:
+            for auto in (False, True):
+                for l in self._load(self.layer_file(m, auto=auto)):
+                    for r in (l["from"], l["to"]):
+                        if not r.startswith(("day:", "era:")):
+                            holds[r].add(m)
+        field = {"members": members, "shared_by_all": [], "shared_by_two": [], "private_wealth": []}
+        for r, ms in holds.items():
+            key = ("shared_by_all" if len(ms) >= 3 else
+                   "shared_by_two" if len(ms) == 2 else "private_wealth")
+            field[key].append({"ref": r, "held_by": sorted(ms)})
+        field["counts"] = {k: len(field[k]) for k in
+                           ("shared_by_all", "shared_by_two", "private_wealth")}
+        return field

copresence-0.1.0/src/copresence/demo.py

@@ -0,0 +1,80 @@
+"""The reproducible demo: a small life, a cold recall, the black t-shirt law.
+
+A synthetic three-day corpus where a peripheral detail (a red kettle) co-occurs
+with real content (lighthouse work) in SEPARATE moments of the same scenes —
+so similarity alone cannot bridge cue → content. Then the probe: direct recall
+ranks the target poorly; six peripheral cues + a two-hop cascade rebuild it.
+
+Run:  python -m copresence.cli demo     (or: copresence demo)
+"""
+from __future__ import annotations
+
+import tempfile
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+from .core import Store, ref
+from .recall import hash_embedder, probe
+
+T0 = datetime(2026, 1, 5, 10, 0, tzinfo=timezone.utc)
+
+DAYS = [
+    (1, [("keeper", "Today I'm building the lighthouse dataset - labeling foghorn audio clips."),
+         ("helper", "Understood - foghorn clips, labeling pass one."),
+         ("keeper", "Listen to that - my red kettle has been whistling this whole time."),
+         ("helper", "I hear it. Back to the clips."),
+         ("keeper", "Rule for the lighthouse work: keep only clips longer than four seconds.")]),
+    (3, [("keeper", "Different job today: migrating the beehive logs to the new format."),
+         ("helper", "Beehive logs, new format - on it."),
+         ("keeper", "The neighbor's drill keeps buzzing through the wall."),
+         ("helper", "Noted the drill. Migration continues."),
+         ("keeper", "Beehive rule: hive identifiers stay stable across the migration.")]),
+    (8, [("keeper", "Back to the lighthouse dataset. Decision: detection threshold is 0.42."),
+         ("helper", "Threshold 0.42 recorded for the detector."),
+         ("keeper", "The red kettle is whistling again - same as on the first day.")]),
+    # filler days so the similarity slice can't cover the record by luck
+    (4, [("keeper", t) for t in (
+        "Repotted the tomato seedlings; the south bed drains badly.",
+        "Invoice pile again; the printer jammed twice on the tax forms.",
+        "Long walk at noon; the heron was back at the pond.",
+        "Reorganized the pantry shelves; found expired jars of lentils.",
+        "The gutter on the east side needs clearing before the storm.")]),
+    (5, [("keeper", t) for t in (
+        "Market day: tomatoes, rye bread, a bag of walnuts.",
+        "Fixed the squeaky hinge on the workshop door.",
+        "The neighbor's cat slept on the woodpile all afternoon.",
+        "Drafted a letter and kept only the second half.",
+        "Watched the storm roll in from the porch.")]),
+]
+
+
+def corpus() -> list[dict]:
+    events = []
+    for day, lines in sorted(DAYS):
+        for m, (speaker, content) in enumerate(lines):
+            ts = (T0 + timedelta(days=day - 1, minutes=m * 10)).isoformat(timespec="seconds")
+            events.append({"timestamp": ts, "speaker": speaker, "content": content})
+    return events
+
+
+def run() -> dict:
+    events = corpus()
+    with tempfile.TemporaryDirectory() as td:
+        store = Store(Path(td) / "layers")
+        counts = store.link(events)
+        # target: the day-1 lighthouse opener. cue: the red kettle (peripheral).
+        target = ref(events[0])
+        X = hash_embedder([e["content"] for e in events])
+        r = probe(store, events, X, hash_embedder,
+                  query="the red kettle whistling", target_ref=target)
+        print(f"corpus: {len(events)} events across {len(DAYS)} days · links: {counts}")
+        print(f"direct recall rank of target for the kettle-cue query: "
+              f"{r['direct_rank']}/{r['n_events']}")
+        print(f"cascade from {r['cues']} peripheral cues activated {r['activated']} moments"
+              f" → target {'REBUILT ✓' if r['hit'] else 'NOT reached ✗'}")
+        print("(the kettle never resembles the lighthouse — it was simply THERE)")
+        return r
+
+
+if __name__ == "__main__":
+    run()

copresence-0.1.0/src/copresence/recall.py

@@ -0,0 +1,154 @@
+"""copresence.recall — the embedder-facing half: discover, warm, probe.
+
+An EMBEDDER is any callable: list[str] -> sequence of same-length numeric vectors.
+Pure-stdlib fallback included (a hashing bag-of-words — honest toy: fine for demos
+and tests, replace with a real model for real corpora):
+
+    from copresence.recall import hash_embedder            # zero deps
+    from copresence.recall import st_embedder              # pip install copresence[embeddings]
+"""
+from __future__ import annotations
+
+import hashlib
+import math
+import re
+from datetime import datetime, timezone
+
+from .core import Store, ref, _ts
+
+DEEP_GAP_DAYS = 7
+DEEP_SIM = 0.60
+DEEP_SIM_CAP = 0.97    # above this = a repeat, not a chain
+WARM_INTERRUPT = 0.50
+
+
+def hash_embedder(texts: list[str], dim: int = 256) -> list[list[float]]:
+    """Deterministic hashing bag-of-words. A TOY: no semantics beyond shared words.
+    Exists so the package runs with zero dependencies; swap in a real model
+    (st_embedder or your own) for anything beyond demos."""
+    out = []
+    for t in texts:
+        v = [0.0] * dim
+        for w in re.findall(r"[a-z0-9]+", t.lower()):
+            v[int(hashlib.sha1(w.encode()).hexdigest(), 16) % dim] += 1.0
+        n = math.sqrt(sum(x * x for x in v)) or 1.0
+        out.append([x / n for x in v])
+    return out
+
+
+def st_embedder(model: str = "sentence-transformers/all-MiniLM-L6-v2"):
+    """Factory for a real embedder (requires the [embeddings] extra)."""
+    from sentence_transformers import SentenceTransformer
+    m = SentenceTransformer(model)
+
+    def embed(texts: list[str]):
+        return m.encode(texts, normalize_embeddings=True)
+    return embed
+
+
+def _dot(a, b) -> float:
+    return float(sum(x * y for x, y in zip(a, b)))
+
+
+def discover_regular(events, X, top: int = 12) -> list[dict]:
+    """Day-to-day roads: greedy centroid-free clustering by nearest-neighbor
+    chaining (stdlib-friendly); themes alive across many distinct days."""
+    n = len(events)
+    assigned = [-1] * n
+    clusters = []
+    for i in range(n):
+        if assigned[i] >= 0:
+            continue
+        members = [i]
+        assigned[i] = len(clusters)
+        for j in range(i + 1, n):
+            if assigned[j] < 0 and _dot(X[i], X[j]) >= 0.5:
+                assigned[j] = len(clusters)
+                members.append(j)
+        clusters.append(members)
+    out = []
+    for members in clusters:
+        days = sorted({events[i]["timestamp"][:10] for i in members})
+        if len(days) < 2:
+            continue
+        out.append({"days_alive": len(days), "first": days[0], "last": days[-1],
+                    "n_events": len(members),
+                    "exemplar": events[members[0]]["content"][:160]})
+    out.sort(key=lambda r: -r["days_alive"])
+    return out[:top]
+
+
+def discover_deep(events, X, top: int = 10, gap_days: int = DEEP_GAP_DAYS) -> list[dict]:
+    """Dormant chains: strong kinship across a long gap, never cross-referenced,
+    below the identity cap. CANDIDATES — whether one HITS is the member's call.
+    Same-speaker near-identity pairs are echo-shaped; the cap catches most, the
+    member's judgment catches the rest."""
+    ts = [_ts(e["timestamp"]) for e in events]
+    cands = []
+    for i in range(len(events)):
+        for j in range(i + 1, len(events)):
+            gap = (ts[j] - ts[i]).days
+            if gap < gap_days:
+                continue
+            s = _dot(X[i], X[j])
+            if s < DEEP_SIM or s > DEEP_SIM_CAP:
+                continue
+            if events[i]["timestamp"][:10] in events[j]["content"]:
+                continue
+            cands.append((s, gap, i, j))
+    cands.sort(key=lambda c: -c[0])
+    picked, used = [], set()
+    for s, gap, i, j in cands:
+        if i in used or j in used:
+            continue
+        used |= {i, j}
+        picked.append({"sim": round(s, 3), "gap_days": gap,
+                       "then": {"ts": events[i]["timestamp"], "excerpt": events[i]["content"][:200]},
+                       "now": {"ts": events[j]["timestamp"], "excerpt": events[j]["content"][:200]}})
+        if len(picked) >= top:
+            break
+    return picked
+
+
+def warm(events, X, context_vec, half_life_d: float = 14.0, top: int = 6) -> list[dict]:
+    """Which DORMANT moments are heating up under the current context? Heat =
+    kinship-to-now × dormancy. `should_interrupt` is an attention boundary — the
+    caller decides whether to speak. Context should be the record's TAIL, not a
+    query: continuity anchors in time (a law we paid for)."""
+    now = datetime.now(timezone.utc)
+    out = []
+    for i, e in enumerate(events):
+        age_d = max(0, (now - _ts(e["timestamp"])).days)
+        dormancy = 1 - (0.5 ** (age_d / half_life_d))
+        heat = _dot(X[i], context_vec) * dormancy
+        if heat > 0.15:
+            out.append({"ref": ref(e), "heat": round(heat, 3), "age_days": age_d,
+                        "should_interrupt": heat >= WARM_INTERRUPT,
+                        "excerpt": e["content"][:120]})
+    out.sort(key=lambda r: -r["heat"])
+    return out[:top]
+
+
+def probe(store: Store, events, X, embedder, query: str, target_ref: str,
+          member: str = "member", hops: int = 2) -> dict:
+    """THE run-gate: can a PERIPHERAL cue-bundle rebuild a context that content
+    similarity missed? Direct recall ranks the target; the friend-mode takes the
+    era's co-present LOW-similarity neighbors (the black t-shirts) and cascades
+    from them only."""
+    refs = [ref(e) for e in events]
+    idx = {r: i for i, r in enumerate(refs)}
+    v = embedder([query])[0]
+    sims = [_dot(x, v) for x in X]
+    order = sorted(range(len(events)), key=lambda i: -sims[i])
+    rank = next((k for k, i in enumerate(order, 1) if refs[i] == target_ref), None)
+    adj = store.graph(member)
+    cues = []
+    for i in order[:3]:
+        for t, _w, _k in adj.get(refs[i], ()):
+            j = idx.get(t)
+            if j is not None and sims[j] < 0.30 and t != target_ref:
+                cues.append(t)
+    cues = list(dict.fromkeys(cues))[:8]
+    activated = store.cascade(set(cues), adj, hops)
+    return {"direct_rank": rank, "n_events": len(events), "cues": len(cues),
+            "activated": len(activated), "hit": target_ref in activated}

copresence-0.1.0/tests/test_copresence.py

@@ -0,0 +1,87 @@
+"""Port of the organ's proven selftest checks (10/10 on the private twin,
+2026-07-05) plus the demo run-gate."""
+import json
+from datetime import datetime, timezone
+
+from copresence import Store, ref, hash_embedder, probe
+from copresence.core import DORMANT_FLOOR
+from copresence import demo
+
+T0 = datetime(2026, 7, 1, 10, 0, tzinfo=timezone.utc)
+
+
+def ev(day, minutes, speaker, content, month=7):
+    return {"timestamp": T0.replace(month=month, day=day, hour=10 + minutes // 60,
+                                    minute=minutes % 60).isoformat(timespec="seconds"),
+            "speaker": speaker, "content": content * 12}
+
+
+def make_events():
+    a0 = ev(1, 0, "illia", "old spring moment about the shore signal ", month=4)
+    a1 = ev(1, 10, "claude", "another old spring moment same scene ", month=4)
+    return [a0, a1,
+            ev(1, 0, "illia", "we made the decision tonight and sealed it "),   # gravity
+            ev(1, 10, "claude", "black t-shirt detail: ring on the finger "),   # peripheral
+            ev(1, 500, "steward", "same day much later scoreboard talk "),      # day-scale
+            ev(3, 0, "claude", "different day building talk "),                 # other day
+            ev(3, 10, "claude", "plain follow-up chatter about nothing ")]      # plain pair
+
+
+def test_linker_scales_and_presence(tmp_path):
+    events = make_events()
+    store = Store(tmp_path / "layers")
+    n = store.link(events)
+    assert n["structural"] == 3 + 7 + 3          # adjacency + day-hubs + era-hubs
+    rows = store._load(store.layer_file("_structural", auto=True))
+    w = {(r["from"], r["to"]): r["weight"] for r in rows if r["kind"] == "co-presence"}
+    gravity_pair = w[(ref(events[2]), ref(events[3]))]
+    plain_pair = w[(ref(events[5]), ref(events[6]))]
+    assert gravity_pair > plain_pair             # presence weighting
+
+
+def test_decay_dormancy_never_death(tmp_path):
+    store = Store(tmp_path / "layers")
+    events = make_events()
+    assert store.decayed(1.0, ref(events[0])) == DORMANT_FLOOR   # old → floor
+    assert store.decayed(1.0, ref(events[2])) > 0.5              # fresh → alive
+    assert store.decayed(0.4, "day:2026-07-01") == 0.4           # hubs don't decay
+
+
+def test_cascade_day_boundary_and_resurrection(tmp_path):
+    events = make_events()
+    store = Store(tmp_path / "layers")
+    store.link(events)
+    store.add_link("claude", "deep", ref(events[3]), ref(events[0]), 1.0)
+    adj = store.graph("claude")
+    reached = store.cascade({ref(events[3])}, adj, hops=2)
+    assert ref(events[2]) in reached             # peripheral → target (the scene)
+    assert ref(events[4]) in reached             # day-scale via the hub
+    assert ref(events[5]) not in reached         # other DAY not pulled
+    assert ref(events[0]) in reached and ref(events[1]) in reached  # RESURRECTION: whole scene
+
+
+def test_notice_and_sovereign_layers(tmp_path):
+    events = make_events()
+    store = Store(tmp_path / "layers")
+    store.link(events)
+    row = store.notice(ref(events[2]), "claude", "test")
+    assert row["link_id"]
+    assert store.layer_file("claude").exists()
+    assert store.layer_file("_structural", auto=True).exists()
+    field = store.resonance()
+    assert field["counts"]["private_wealth"] >= 1
+    assert "discordance" not in field            # deliberately not computed
+
+
+def test_demo_probe_rebuilds_missed_target(capsys):
+    r = demo.run()
+    assert r["hit"] is True                      # cascade rebuilds the target
+    assert r["direct_rank"] > 5                  # …which similarity ranked poorly
+
+
+def test_events_roundtrip_jsonl(tmp_path):
+    events = make_events()
+    p = tmp_path / "events.jsonl"
+    p.write_text("".join(json.dumps(e) + "\n" for e in events))
+    back = [json.loads(l) for l in p.read_text().splitlines()]
+    assert back == events