daimon-briefing 0.3.1__tar.gz → 0.3.3__tar.gz

{daimon_briefing-0.3.1 → daimon_briefing-0.3.3}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: daimon-briefing
-Version: 0.3.1
-Summary: Dream-briefing hermes plugin: cognitive checkpoint at session end, 'while you were away' briefing at session start. Slice 1 (local-file, no Honcho).
+Version: 0.3.3
+Summary: Dream-briefing for AI coding agents: writes a cognitive checkpoint at session end and shows a 'while you were away' briefing at session start. Self-contained, stdlib-only.
 Author: Daily-Nerd / Daimon
 License: Apache-2.0
 Requires-Python: >=3.10

{daimon_briefing-0.3.1 → daimon_briefing-0.3.3}/daimon_briefing/carry.py

@@ -9,6 +9,7 @@ caller injects clock and knobs (scar: a default wall-clock anywhere silently
 freezes time math under simulation)."""
 
 import copy
+from collections import Counter
 
 from . import recall, scoring, store
 
@@ -22,16 +23,41 @@ _CARRIED_KINDS = (
 
 _MIN_SHARED = 3     # shared salient terms for same-item
 _MIN_RATIO = 0.6    # or this fraction of the shorter term list
+_GENERIC_DF = 3     # a term shared by >=3 items of one kind is that kind's
+                    # vocabulary, not an item's identity. Filtering it out of
+                    # dedup stops generic overlap (data/field/validation, the
+                    # #13 live specimen) from forging a false merge. Computed
+                    # per kind per merge — no static stoplist, so carry stays
+                    # language-neutral (es i18n just shipped).
 
 
-def _same_item(a_text: str, b_text: str) -> bool:
+def _generic_terms(texts, k: int = _GENERIC_DF) -> frozenset:
+    """Salient terms appearing in >= k DISTINCT texts of one kind — that kind's
+    shared vocabulary, which dedup must ignore. Document frequency counts a term
+    once per text (set per text), so repetition inside one item can't inflate
+    it."""
+    df: Counter = Counter()
+    for t in texts:
+        df.update(set(recall.salient_terms(t)))
+    return frozenset(term for term, n in df.items() if n >= k)
+
+
+def _same_item(a_text: str, b_text: str, generic=frozenset()) -> bool:
     """Term-overlap identity: the serializer rewords constantly (run-01), so
     exact text misses twins. Shared >=3 salient terms, or >=60% of the shorter
-    list, means same item. Short texts (<2 salient terms) never fuzzy-match —
-    the exact-text guard still catches identical ones."""
-    a = set(recall.salient_terms(a_text))
-    b = set(recall.salient_terms(b_text))
-    if not a or not b:
+    list, means same item — but only AFTER subtracting `generic` (the kind's
+    document-frequent vocabulary), so overlap on common words can't merge
+    unrelated items.
+
+    Floor: if either filtered set has <2 terms, never fuzzy-match. This blocks a
+    single surviving shared term from passing the ratio path (1/1 = 1.0). The
+    bias is deliberate and asymmetric: a false merge erases a loop and forges
+    its birth stamp, while a false non-merge only costs a duplicate item — so
+    tie-break toward NOT merging. The exact-text guard still catches identical
+    items regardless."""
+    a = set(recall.salient_terms(a_text)) - generic
+    b = set(recall.salient_terms(b_text)) - generic
+    if len(a) < 2 or len(b) < 2:
         return False
     shared = len(a & b)
     return shared >= _MIN_SHARED or shared / min(len(a), len(b)) >= _MIN_RATIO
@@ -64,6 +90,12 @@ def merge(new_cp: dict, prev_cp: dict | None, now: float,
             continue
         prev_items = (prev_cp.get(section) or {}).get(key) or []
         native_texts = {i.get("text") for i in native if isinstance(i, dict)}
+        # Generic vocabulary for THIS kind, from the same universe merge iterates
+        # (native + prev): terms this common are not identity, so dedup ignores
+        # them (#13). Computed once per kind, passed to every _same_item below.
+        generic = _generic_terms(
+            [str(i.get("text") or "") for i in native if isinstance(i, dict)]
+            + [str(i.get("text") or "") for i in prev_items if isinstance(i, dict)])
         carried = []
         for item in prev_items:
             if not isinstance(item, dict) or not str(item.get("text") or "").strip():
@@ -72,7 +104,8 @@ def merge(new_cp: dict, prev_cp: dict | None, now: float,
             if text in native_texts:
                 continue  # exact twin already present (idempotency)
             twin = next((n for n in native if isinstance(n, dict)
-                         and _same_item(text, str(n.get("text") or ""))), None)
+                         and _same_item(text, str(n.get("text") or ""), generic)),
+                        None)
             if twin is not None:
                 # Session re-discussed it: the new wording wins, but the item's
                 # AGE does not reset (run-01: 8-12 resets/20 cycles killed the

{daimon_briefing-0.3.1 → daimon_briefing-0.3.3}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "daimon-briefing"
-version = "0.3.1"
-description = "Dream-briefing hermes plugin: cognitive checkpoint at session end, 'while you were away' briefing at session start. Slice 1 (local-file, no Honcho)."
+version = "0.3.3"
+description = "Dream-briefing for AI coding agents: writes a cognitive checkpoint at session end and shows a 'while you were away' briefing at session start. Self-contained, stdlib-only."
 readme = "README.md"
 requires-python = ">=3.10"
 license = { text = "Apache-2.0" }

daimon_briefing-0.3.3/skills/daimon-briefing/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: daimon-briefing
+description: Dream-briefing — surfaces a "while you were away / here's where we left off" briefing at the start of a resumed session, reconstructed from a cognitive checkpoint written at the end of the prior session. Use to recall open loops, decisions, and facts whose state may have changed outside the AI session (e.g. a PR you merged yourself).
+---
+
+# Daimon Dream-Briefing
+
+This plugin keeps continuity across sessions. At the **end** of each session it
+serializes the transcript into a cognitive checkpoint (open loops, decisions,
+beliefs, with extractively-pinned verbatim quotes). At the **start** of the next
+session it injects a skimmable briefing so you resume from a faithful prior state
+instead of a confident guess.
+
+## What it surfaces, in order
+
+1. **Verify before trusting** — items whose state may have changed *outside* this
+   session (a PR you said you'd merge, a deploy, a file edited elsewhere). These come
+   first because they are the gap that produces confident-but-wrong assertions.
+2. **Open loops** — questions left unresolved at the end of last session.
+3. **Decisions made** — explicit choices, including assistant-side fixes/diagnoses.
+4. **Active topic / beliefs / uncertainties.**
+
+Each item is marked `✓ verbatim` (pinned to an exact quote — trust it) or
+`~ inferred` (paraphrased — treat with appropriate caution).
+
+## Automatic behavior
+
+You do not need to invoke anything. The plugin wires the host's native session
+hooks: a checkpoint is written automatically when a session **ends**, and the
+briefing appears automatically at the **start** of the next session if a prior
+checkpoint exists. Between those, a lightweight **proactive recall** watches your
+prompts and surfaces a one-line "you worked on this before" pointer when the
+current prompt overlaps a prior open loop — without re-suggesting anything the
+start-of-session briefing already carried.
+
+## Manual trigger
+
+To re-read the latest briefing on demand, run the bundled CLI:
+
+```bash
+daimon brief
+```
+
+## Configuration
+
+See the plugin README. Key knobs: `DAIMON_DISABLE=1` (kill switch),
+`DAIMON_CHECKPOINT_DIR`, `DAIMON_MIN_MESSAGES`, `DAIMON_LLM_*` (falling back to
+`LITELLM_*`), `DAIMON_LLM_BACKEND=command` + `DAIMON_LLM_COMMAND` (headless-CLI fallback).
+
+## What ships today
+
+Daimon is self-contained and host-agnostic — no server, no external memory
+backend, stdlib-only at runtime. The capabilities behind the briefing:
+
+- **Checkpoint → briefing loop.** Session end serializes the transcript into a
+  per-project JSON checkpoint; session start reconstructs it into the briefing.
+- **Chunked extraction.** Long transcripts are split into overlapping chunks,
+  serialized pass-by-pass, then merged — so recall holds up on long sessions
+  instead of degrading as the transcript grows.
+- **Deterministic carry.** Unresolved open loops that still matter are carried
+  forward into the next checkpoint by exact term overlap (no LLM in the carry
+  step) and marked `[carried]` so you can see a loop survived from an earlier
+  session rather than being freshly observed.
+- **Proactive recall.** A per-prompt pointer to prior work when your current
+  prompt overlaps an open loop (see *Automatic behavior*).
+- **Trust classing.** Every item is `✓ verbatim` (pinned to an exact quote) or
+  `~ inferred` (paraphrased), so you know what to trust literally.
+- **Code-drift detection.** `daimon anchor <file> <symbol>` binds a checkpoint
+  item to a code symbol; the briefing flags it under **CODE DRIFT — verify
+  before trusting** when that symbol's body changes or disappears (offline,
+  stdlib `ast`).
+- **Scars.** An optional session-end pass harvests negative-knowledge signals
+  (abandoned approaches, landmines) into the repo's `.scars/` directory.
+- **Status & self-heal.** `daimon status` reports checkpoint/briefing health;
+  a failed capture self-heals on the next session start.

{daimon_briefing-0.3.1 → daimon_briefing-0.3.3}/tests/test_carry.py

@@ -7,6 +7,18 @@ from daimon_briefing import carry
 
 NOW = 1_760_000_000.0  # arbitrary fixed epoch
 
+# Live false-merge specimen (2026-07-02): two UNRELATED items that matched on
+# exactly the generic terms {data, field, validation}. See #13.
+_SPEC_A = ("First external user validation — the core adoption-arc objective "
+           "that unblocks _MIN_OVERLAP field data, DAIMON_TEAM validation, and "
+           "teammate-noise research questions")
+_SPEC_B = ("Q-STALE + multi-cycle degradation validation — parked on LLM "
+           "budget. Need field data: what do 20 serialize cycles do to a "
+           "long-lived open loop, and how does that inform decay tuning?")
+# Sibling native item carrying the same generic vocabulary, so {data, field,
+# validation} each reach document-frequency 3 across the kind (A, sibling, B).
+_SPEC_SIB = "extra validation of the data field mapping"
+
 
 def _iso(days_before_now):
     import datetime as dt
@@ -135,6 +147,64 @@ def test_same_item_short_texts_never_fuzzy_match():
     assert carry._same_item("ok", "ok go") is False
 
 
+def test_generic_overlap_does_not_false_merge_specimen():
+    # Live #13 specimen: fresh native A and unrelated carried B share only the
+    # generic terms {data, field, validation}. B must survive as its OWN item;
+    # A must NOT inherit B's older birth stamp.
+    new = _cp("S-new", 0, questions=[
+        _item(_SPEC_A, days=0), _item(_SPEC_SIB, days=1)])
+    prev = _cp("S-prev", 1, questions=[_item(_SPEC_B, imp=7, days=45)])
+    out = carry.merge(new, prev, NOW)
+    qs = out["working_context"]["open_questions"]
+    texts = [q["text"] for q in qs]
+    assert _SPEC_B in texts                       # B kept, not erased
+    b_item = next(q for q in qs if q["text"] == _SPEC_B)
+    assert b_item["carried_from"] == "S-prev"
+    a_item = next(q for q in qs if q["text"] == _SPEC_A)
+    assert a_item["first_seen"] == _iso(0)        # A did NOT inherit B's stamp
+    assert "carried_from" not in a_item
+    assert len(qs) == 3
+
+
+def test_same_item_generic_filter_is_the_fix_not_a_threshold():
+    generic = frozenset({"data", "field", "validation"})
+    assert carry._same_item(_SPEC_A, _SPEC_B, generic) is False
+    assert carry._same_item(_SPEC_A, _SPEC_B) is True   # unfiltered: the bug
+
+
+def test_specific_twin_still_merges_and_inherits_age():
+    # Two rewordings sharing SPECIFIC low-DF terms must still match (run-02
+    # behavior): the guard filters vocabulary, not identity.
+    old = _item("quorint-ledger reconciliation drops entries when upstream "
+                "feed pauses", days=45)
+    new_twin = _item("quorint-ledger reconciliation still dropping entries on "
+                     "feed pauses", days=0)
+    prev = _cp("S-prev", 1, questions=[
+        old, _item("unrelated gavotte pipeline flaking noise", days=3)])
+    new = _cp("S-new", 0, questions=[
+        new_twin, _item("tervane cache eviction unclear noise", days=1)])
+    out = carry.merge(new, prev, NOW)
+    qs = out["working_context"]["open_questions"]
+    twin = next(q for q in qs if "still dropping" in q["text"])
+    assert twin["first_seen"] == _iso(45)               # matched -> age inherited
+    assert not any("drops entries" in q["text"] for q in qs)  # not duplicated
+
+
+def test_post_filter_floor_blocks_single_shared_term():
+    generic = frozenset({"data", "field", "validation"})
+    a = "data field validation alpha"          # filtered -> {alpha}
+    b = "data field validation alpha bravo"    # filtered -> {alpha, bravo}
+    # ratio would be 1/1 = 1.0 >= _MIN_RATIO without the floor; floor blocks it
+    assert carry._same_item(a, b, generic) is False
+
+
+def test_generic_terms_df_boundary():
+    texts = ["zeta omega alpha", "zeta omega beta", "omega gamma delta"]
+    generic = carry._generic_terms(texts)   # k defaults to _GENERIC_DF (3)
+    assert "omega" in generic       # 3 distinct texts -> generic
+    assert "zeta" not in generic    # exactly 2 distinct texts -> not generic
+
+
 def test_in_call_duplicate_prev_items_carry_once():
     # Two prev items with IDENTICAL text: native_texts must pick up the first
     # one as it's appended, so the second (an exact twin) is skipped too.

{daimon_briefing-0.3.1 → daimon_briefing-0.3.3}/uv.lock

@@ -13,7 +13,7 @@ wheels = [
 
 [[package]]
 name = "daimon-briefing"
-version = "0.3.0"
+version = "0.3.1"
 source = { editable = "." }
 
 [package.optional-dependencies]

daimon_briefing-0.3.1/skills/daimon-briefing/SKILL.md

@@ -1,49 +0,0 @@
----
-name: daimon-briefing
-description: Dream-briefing — surfaces a "while you were away / here's where we left off" briefing at the start of a resumed session, reconstructed from a cognitive checkpoint written at the end of the prior session. Use to recall open loops, decisions, and facts whose state may have changed outside the AI session (e.g. a PR you merged yourself).
----
-
-# Daimon Dream-Briefing
-
-This plugin keeps continuity across sessions. At the **end** of each session it
-serializes the transcript into a cognitive checkpoint (open loops, decisions,
-beliefs, with extractively-pinned verbatim quotes). At the **start** of the next
-session it injects a skimmable briefing so you resume from a faithful prior state
-instead of a confident guess.
-
-## What it surfaces, in order
-
-1. **Verify before trusting** — items whose state may have changed *outside* this
-   session (a PR you said you'd merge, a deploy, a file edited elsewhere). These come
-   first because they are the gap that produces confident-but-wrong assertions.
-2. **Open loops** — questions left unresolved at the end of last session.
-3. **Decisions made** — explicit choices, including assistant-side fixes/diagnoses.
-4. **Active topic / beliefs / uncertainties.**
-
-Each item is marked `✓ verbatim` (pinned to an exact quote — trust it) or
-`~ inferred` (paraphrased — treat with appropriate caution).
-
-## Automatic behavior
-
-You do not need to invoke anything. The briefing appears automatically on the first
-turn of a new session if a prior checkpoint exists. Checkpoints are written
-automatically when a session ends.
-
-## Manual trigger
-
-To re-read the latest briefing on demand, run the bundled CLI:
-
-```bash
-daimon brief
-```
-
-## Configuration
-
-See the plugin README. Key knobs: `DAIMON_DISABLE=1` (kill switch),
-`DAIMON_CHECKPOINT_DIR`, `DAIMON_MIN_MESSAGES`, `DAIMON_LLM_*` (falling back to
-`LITELLM_*`), `DAIMON_LLM_BACKEND=command` + `DAIMON_LLM_COMMAND` (headless-CLI fallback).
-
-## Scope (Slice 1)
-
-Local-file checkpoints, single-pass serialization, no Honcho. Long-transcript recall
-(chunking) is Slice 2; Honcho-backed cross-session recall is Slice 3.