topos-node 1.3.26__tar.gz → 1.3.28__tar.gz

{topos_node-1.3.26/topos_node.egg-info → topos_node-1.3.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topos-node
-Version: 1.3.26
+Version: 1.3.28
 Summary: Topos personal AI engine (FastAPI): local data, sync, control plane WebSocket client
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://topos.dialogues.ai

{topos_node-1.3.26 → topos_node-1.3.28}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "topos-node"
-version = "1.3.26"
+version = "1.3.28"
 description = "Topos personal AI engine (FastAPI): local data, sync, control plane WebSocket client"
 readme = "README.md"
 license = "Apache-2.0"

{topos_node-1.3.26 → topos_node-1.3.28}/topos/__version__.py

@@ -1,6 +1,6 @@
 """Topos Control Plane Version Information."""
 
-__version__ = "1.3.26"
-__version_info__ = (1, 3, 26)
+__version__ = "1.3.28"
+__version_info__ = (1, 3, 28)
 
 __all__ = ["__version__", "__version_info__"]

{topos_node-1.3.26 → topos_node-1.3.28}/topos/api/signal.py

@@ -1085,3 +1085,21 @@ async def post_fact_conflict_resolution(
     if not ok:
         raise HTTPException(status_code=404, detail=f"unknown conflict {conflict_id}")
     return {"conflict_id": conflict_id, "status": status}
+
+
+@router.post("/derivation/offers/resolve")
+async def post_pack_offer_resolution(
+    offer_id: str = Body(...),
+    action: str = Body(..., description="accept | dismiss"),
+    _api_key: str = Depends(require_api_key),
+):
+    """Self-gating offers: the node offered, the owner decides (W-B)."""
+    from ..features.derivation.surfaces import resolve_pack_offer
+
+    try:
+        out = resolve_pack_offer(_entities_conn(), offer_id, action)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    if not out:
+        raise HTTPException(status_code=404, detail=f"unknown offer {offer_id}")
+    return out

{topos_node-1.3.26 → topos_node-1.3.28}/topos/core/handlers/derivation.py

@@ -77,3 +77,23 @@ async def handle_put_fact_conflict(message: Dict[str, Any]) -> Optional[Dict[str
         return {"id": req_id, "status": "error", "error": str(exc)}
     except Exception as exc:  # noqa: BLE001
         return {"id": req_id, "status": "error", "error": str(exc)}
+
+
+@handles("put_pack_offer")
+async def handle_put_pack_offer(message):
+    req_id = message.get("id")
+    conn = hub.get_db_connection()
+    if not conn:
+        return {"id": req_id, "status": "error", "error": "Database not available"}
+    payload = message.get("payload") or {}
+    try:
+        from ...features.derivation.surfaces import resolve_pack_offer
+        out = resolve_pack_offer(conn, str(payload.get("offer_id") or ""),
+                                 str(payload.get("action") or ""))
+        if not out:
+            return {"id": req_id, "status": "error", "error": "unknown offer"}
+        return {"id": req_id, "status": "ok", "payload": {"status": "ok", **out}}
+    except ValueError as exc:
+        return {"id": req_id, "status": "error", "error": str(exc)}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}

topos_node-1.3.28/topos/enrichment/jobs/canonical/derivation_job.py

@@ -0,0 +1,367 @@
+"""DerivationJob (W2.3): ontology-pack fact derivation over canonical batches.
+
+Per (record, enabled pack): lexical prefilter -> shadow-8 prompt -> extraction
+model (qwen3.5-class; recall) -> parse with A1/A2 guards -> A4 verifier
+(27B-class; precision, selection-shaped) -> DerivationWriter (A3 routing,
+revision ladder, event-identity keying).
+
+Model split is MEASURED, not aesthetic (2026-08-26 battery, 32 records):
+extractor alone recurs 19/23 junk classes; verifier-as-extractor loses half the
+gold; extract+verify hits ~1/23 junk while keeping recall. See
+derivation-packs/pilot/w1_report.md.
+
+Verification policy: TOPOS_DERIVATION_VERIFY=required (default) — if the
+verifier model is unavailable the batch DEFERS rather than writing unverified
+owner-facts; the junk gate was earned WITH the verifier in the loop. "off"
+exists for explicit opt-out (assertions then flagged verifier_status=skipped).
+
+Occurrence dates: an episodic assertion with no stated date stays UNDATED —
+defaulting to the record date is how one firing became six events (a July
+retelling minted a phantom July firing). The writer's event-identity keying
+merges undated retellings into the original.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json as _json
+import logging
+import os
+import threading
+from typing import Any, Callable, Dict, List, Optional
+
+from ..base import BaseEnrichmentJob
+from ....core.state import get_db_connection
+
+logger = logging.getLogger("topos.enrichment.jobs.derivation")
+
+
+def derivation_enabled() -> bool:
+    return os.environ.get("TOPOS_DERIVATION", "on").strip().lower() not in (
+        "0", "false", "off", "no")
+
+
+def _verify_mode() -> str:
+    return os.environ.get("TOPOS_DERIVATION_VERIFY", "required").strip().lower()
+
+
+def _row_to_record(row: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    text = str(row.get("content") or row.get("text") or row.get("title") or "")
+    if len(text.strip()) <= 15:
+        return None
+    rid = str(row.get("record_id") or row.get("message_id") or row.get("entry_id")
+              or row.get("event_id") or row.get("id") or "")
+    if not rid:
+        return None
+    table = str(row.get("_table") or row.get("canonical_table") or "")
+    role = str(row.get("actor_role") or ("authored" if "journal" in table else "observed"))
+    date = str(row.get("event_at") or row.get("entry_at") or row.get("occurred_at") or "")[:10]
+    return {"record_id": rid, "table": table or "canonical", "text": text,
+            "role": role, "date": date,
+            "source_id": str(row.get("source_id") or "")}
+
+
+def _ledger_write(conn, *, stage, pack, rec, a, model, vmodel, written_id=None):
+    """Training-data factory: EVERY judged assertion lands here, accepted or not
+    (rejects are the hard negatives; quotes+record refs recover spans)."""
+    import uuid as _uuid
+    from ....features.derivation import template as _T
+    conn.execute(
+        """INSERT INTO derivation_training_ledger
+           (ledger_id, stage, pack_id, pack_version, template_version, extract_model,
+            verifier_model, source_table, record_id, actor_role, predicate, value_json,
+            about, occurrence, quote, confidence, vstatus, vreason, written_object_id)
+           VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
+        (f"dtl_{_uuid.uuid4().hex[:16]}", stage, pack.pack, pack.version,
+         _T.TEMPLATE_VERSION, model, vmodel, rec["table"], rec["record_id"],
+         rec["role"], a.get("predicate"), _json.dumps(a.get("value"), default=str),
+         a.get("about"), a.get("occurrence"), a.get("quote"), a.get("confidence"),
+         a.get("verifier_status"), a.get("verifier_reason"), written_id))
+
+
+def _bump_yield(conn, pack_id, **cols):
+    import datetime as _dt
+    day = _dt.datetime.now(_dt.timezone.utc).strftime("%Y-%m-%d")
+    conn.execute("INSERT OR IGNORE INTO pack_yield (pack_id, day) VALUES (?, ?)", (pack_id, day))
+    for col, inc in cols.items():
+        if inc:
+            conn.execute(f"UPDATE pack_yield SET {col} = {col} + ? WHERE pack_id=? AND day=?",
+                         (int(inc), pack_id, day))
+
+
+def _yield_window(conn, pack_id, days, col):
+    row = conn.execute(
+        f"SELECT COALESCE(SUM({col}),0) FROM pack_yield WHERE pack_id=? AND day >= date('now', ?)",
+        (pack_id, f"-{int(days)} day")).fetchone()
+    return int(row[0] or 0)
+
+
+def _has_recent_offer(conn, pack_id, kind, days=30) -> bool:
+    row = conn.execute(
+        "SELECT 1 FROM pack_offers WHERE pack_id=? AND kind=? AND"
+        " (status='pending' OR updated_at >= datetime('now', ?)) LIMIT 1",
+        (pack_id, kind, f"-{int(days)} day")).fetchone()
+    return row is not None
+
+
+def _mint_offer(conn, pack_id, kind, stats):
+    import uuid as _uuid
+    conn.execute(
+        "INSERT INTO pack_offers (offer_id, pack_id, kind, stats_json) VALUES (?,?,?,?)",
+        (f"ofr_{_uuid.uuid4().hex[:12]}", pack_id, kind, _json.dumps(stats, default=str)))
+    logger.info("pack offer minted: %s %s %s", kind, pack_id, stats)
+
+
+#: self-gating knobs — deliberately conservative; the node OFFERS, the owner decides
+TRIAL_MIN_HITS_14D = 25
+TRIAL_SAMPLE_CAP = 30
+TRIAL_MIN_ACCEPTED = 3
+TRIAL_MIN_ACCEPT_RATE = 0.4
+DRYWELL_MIN_CALLS_30D = 50
+
+
+def run_derivation_batch(
+    conn,
+    rows: List[Dict[str, Any]],
+    *,
+    cancel: Optional[threading.Event] = None,
+    stats: Optional[Dict[str, Any]] = None,
+) -> int:
+    """Sync worker (runs in a thread). Returns facts written+routed."""
+    from ....features.derivation import template as _T
+    from ....features.derivation.prefilter import PackPrefilter
+    from ....features.derivation.registry import (bundled_pack_dir, enabled_packs,
+                                                  mark_pack_run, seed_pack_registry)
+    from ....features.derivation.packs import load_packs
+    from ....features.derivation.template import build_prompt, parse_output
+    from ....features.derivation.verify import (build_verify_prompt, parse_verdict,
+                                                apply_verdict, verifier_model)
+    from ....features.derivation.writer import DerivationWriter
+    from ....features.facts.llm_extract import _resolved_extraction_model
+    from ....config.settings import settings as _settings
+    from ....engine.backends.ollama import OllamaAdapter
+
+    st = stats if stats is not None else {}
+    pack_dir = bundled_pack_dir()
+    _T.set_pack_dir(pack_dir)
+    seed_pack_registry(conn, pack_dir)
+    all_packs = load_packs(pack_dir)
+    packs = enabled_packs(conn, pack_dir)
+    owner_row = conn.execute("SELECT entity_id FROM entities WHERE is_self=1").fetchone()
+    if not owner_row:
+        st["skipped"] = "no_owner_entity"
+        return 0
+    owner = owner_row[0]
+    model = _resolved_extraction_model(_settings, conn)
+    vmodel = verifier_model()
+    adapter = OllamaAdapter()
+
+    def llm(m: str, prompt: str, n: int = 900) -> str:
+        out = adapter._generate(m, prompt, num_predict=n, think=False,
+                                temperature=0.0, num_ctx=8192, timeout=180)
+        return str(out.get("text") or "") if isinstance(out, dict) else str(out or "")
+
+    verify_mode = _verify_mode()
+    if verify_mode == "required" and packs:
+        try:
+            probe = llm(vmodel, "Respond with exactly: ok", n=8)
+            if not probe.strip():
+                raise RuntimeError("empty verifier probe")
+        except Exception as exc:  # noqa: BLE001
+            st["deferred"] = f"verifier_unavailable: {exc}"[:120]
+            logger.warning("derivation deferred: verifier %s unavailable (%s)", vmodel, exc)
+            return 0
+
+    filters = {pid: PackPrefilter(pk) for pid, pk in all_packs.items()}
+    writer = DerivationWriter(conn, model=model)
+    done = {r[0] for r in conn.execute("SELECT key FROM derivation_progress")}
+
+    def judge(pack, rec, a, stage):
+        """Verify one assertion; ledger it; return the annotated assertion."""
+        if verify_mode == "off":
+            a = dict(a); a["verifier_status"] = "skipped"
+        else:
+            try:
+                verdict = parse_verdict(llm(vmodel, build_verify_prompt(
+                    rec["text"], rec["role"], rec["date"],
+                    a["predicate"], a["value"], a.get("about", "owner")), n=250))
+            except Exception:  # noqa: BLE001
+                verdict = None
+            a = apply_verdict(a, verdict)
+        return a
+
+    written = 0
+    for row in rows:
+        if cancel is not None and cancel.is_set():
+            st["cancelled"] = True
+            break
+        rec = _row_to_record(row)
+        if rec is None:
+            continue
+        for pid, pack in all_packs.items():
+            hit = rec["role"] in pack.allowed_roles() and filters[pid].passes(rec["text"])
+            if hit:
+                _bump_yield(conn, pid, prefilter_hits=1)
+            if pid not in packs:
+                continue                     # disabled: counted for self-gating, never run
+            key = f"{pid}@{pack.version}:{rec['table']}:{rec['record_id']}"
+            if key in done or not hit:
+                if hit:
+                    conn.execute("INSERT OR REPLACE INTO derivation_progress (key) VALUES (?)", (key,))
+                continue
+            try:
+                raw = llm(model, build_prompt(pack, rec["text"], rec["date"], rec["role"]))
+                _bump_yield(conn, pid, llm_calls=1)
+            except Exception as exc:  # noqa: BLE001
+                st["llm_errors"] = st.get("llm_errors", 0) + 1
+                logger.debug("derivation llm error on %s: %s", key, exc)
+                continue
+            valid, rejects = parse_output(raw, pack, record_text=rec["text"])
+            st["parse_rejects"] = st.get("parse_rejects", 0) + rejects
+            _bump_yield(conn, pid, assertions=len(valid))
+            for a in valid:
+                a = judge(pack, rec, a, "ingest")
+                st[f"v_{a.get('verifier_status')}"] = st.get(f"v_{a.get('verifier_status')}", 0) + 1
+                if a.get("verifier_status") == "rejected":
+                    _ledger_write(conn, stage="ingest", pack=pack, rec=rec, a=a,
+                                  model=model, vmodel=vmodel)
+                    continue
+                _bump_yield(conn, pid, accepted=1)
+                out = writer.assert_pack_fact(
+                    pack=pack, predicate=a["predicate"], subject_entity_id=owner,
+                    value=a["value"], actor_role=rec["role"],
+                    source_refs=[{"table": rec["table"], "record_id": rec["record_id"],
+                                  "source_id": rec["source_id"]}],
+                    confidence=a["confidence"],
+                    occurrence=a["occurrence"],   # NEVER defaulted to record date
+                    quote=a.get("quote", ""), about=a.get("about", "owner"),
+                    event_date=rec["date"] or None)
+                stored = out.get("outcome") in ("written", "corroborated", "retelling_merged",
+                                                "field_update", "corrected", "superseded")
+                if stored:
+                    written += 1
+                    _bump_yield(conn, pid, written=1)
+                _ledger_write(conn, stage="ingest", pack=pack, rec=rec, a=a,
+                              model=model, vmodel=vmodel,
+                              written_id=out.get("object_id") if stored else None)
+            conn.execute("INSERT OR REPLACE INTO derivation_progress (key) VALUES (?)", (key,))
+        conn.commit()
+
+    _self_gate(conn, all_packs=all_packs, enabled=set(packs), filters=filters,
+               llm=llm, judge=judge, model=model, vmodel=vmodel, st=st,
+               cancel=cancel)
+
+    for pid, pack in packs.items():
+        mark_pack_run(conn, pid, pack.version)
+    conn.commit()
+    st["written"] = written
+    st.update({f"w_{k}": v for k, v in writer.stats.items() if v})
+    return written
+
+
+def _self_gate(conn, *, all_packs, enabled, filters, llm, judge, model, vmodel, st, cancel):
+    """Per-node self-gating (owner design, 2026-08-26): the node OFFERS, never
+    switches. Enable offers come from a capped shadow trial on a disabled pack
+    whose prefilter keeps hitting; disable nudges come from an enabled pack
+    burning calls with zero yield. Special-class packs (health, beliefs) are
+    NEVER auto-trialed — extracting their content requires the owner's opt-in
+    first (consent precedes computation)."""
+    from ....features.derivation.template import build_prompt, parse_output
+
+    for pid, pack in all_packs.items():
+        if cancel is not None and cancel.is_set():
+            return
+        if pid in enabled:
+            calls = _yield_window(conn, pid, 30, "llm_calls")
+            wrote = _yield_window(conn, pid, 30, "written")
+            if calls >= DRYWELL_MIN_CALLS_30D and wrote == 0                     and not _has_recent_offer(conn, pid, "disable_nudge"):
+                _mint_offer(conn, pid, "disable_nudge",
+                            {"calls_30d": calls, "written_30d": 0})
+            continue
+        if getattr(pack, "sensitivity_class", "personal") == "special":
+            continue
+        hits = _yield_window(conn, pid, 14, "prefilter_hits")
+        if hits < TRIAL_MIN_HITS_14D or _has_recent_offer(conn, pid, "enable_offer"):
+            continue
+        # sample recent prefilter-hit records for the trial
+        sample = []
+        import sqlite3 as _sqlite3
+        def _rows(sql):
+            try:
+                return conn.execute(sql).fetchall()
+            except _sqlite3.OperationalError:
+                return []          # canonical table absent on this node — fine
+        recent = _rows(
+            """SELECT 'conversation_messages', message_id, content, event_at, actor_role
+               FROM conversation_messages WHERE content IS NOT NULL AND LENGTH(content)>15
+               AND event_at >= datetime('now','-14 day') ORDER BY event_at DESC LIMIT 400""")
+        recent += _rows(
+            """SELECT 'journal_entries', entry_id, content, entry_at, 'authored'
+               FROM journal_entries WHERE content IS NOT NULL AND LENGTH(content)>15
+               AND entry_at >= datetime('now','-14 day') ORDER BY entry_at DESC LIMIT 100""")
+        for tbl, rid, text, at, role in recent:
+            role = role or "observed"
+            if role in pack.allowed_roles() and filters[pid].passes(text):
+                sample.append({"table": tbl, "record_id": rid, "text": (text or "")[:6000],
+                               "date": str(at or "")[:10], "role": role, "source_id": ""})
+            if len(sample) >= TRIAL_SAMPLE_CAP:
+                break
+        if len(sample) < 5:
+            continue
+        n_assert = n_acc = 0
+        examples = []
+        for rec in sample:
+            if cancel is not None and cancel.is_set():
+                return
+            try:
+                raw = llm(model, build_prompt(pack, rec["text"], rec["date"], rec["role"]))
+            except Exception:  # noqa: BLE001
+                continue
+            valid, _rej = parse_output(raw, pack, record_text=rec["text"])
+            for a in valid:
+                a = judge(pack, rec, a, "trial")
+                n_assert += 1
+                _ledger_write(conn, stage="trial", pack=pack, rec=rec, a=a,
+                              model=model, vmodel=vmodel)
+                if a.get("verifier_status") in ("accepted", "rerouted"):
+                    n_acc += 1
+                    if len(examples) < 3:
+                        examples.append({"predicate": a["predicate"],
+                                         "value": a["value"], "quote": a.get("quote", "")})
+        conn.commit()
+        st[f"trial_{pid}"] = {"sampled": len(sample), "assertions": n_assert, "accepted": n_acc}
+        if n_acc >= TRIAL_MIN_ACCEPTED and n_assert and (n_acc / n_assert) >= TRIAL_MIN_ACCEPT_RATE:
+            _mint_offer(conn, pid, "enable_offer",
+                        {"sampled": len(sample), "assertions": n_assert,
+                         "accepted": n_acc, "examples": examples})
+
+
+class DerivationJob(BaseEnrichmentJob):
+    def get_derived_table(self) -> str:
+        return ""  # writes signal_objects via DerivationWriter
+
+    def get_job_name(self) -> str:
+        return "derivation"
+
+    def should_run(self, canonical_messages: List[Dict[str, Any]]) -> bool:
+        return bool(canonical_messages) and derivation_enabled()
+
+    async def enrich(
+        self,
+        canonical_messages: List[Dict[str, Any]],
+        progress_callback: Optional[Callable[[int, int], None]] = None,
+    ) -> List[Dict[str, Any]]:
+        conn = get_db_connection()
+        if conn is None:
+            return [{"_deferred": True, "error": "database_unavailable"}]
+        cancel = threading.Event()
+        stats: Dict[str, Any] = {}
+        try:
+            written = await asyncio.to_thread(
+                run_derivation_batch, conn, canonical_messages,
+                cancel=cancel, stats=stats)
+        except asyncio.CancelledError:
+            cancel.set()
+            raise
+        logger.info("derivation batch: %s written, stats=%s", written, stats)
+        return [{"derivation_written": written, **stats}]

{topos_node-1.3.26 → topos_node-1.3.28}/topos/features/derivation/bundled_packs/aspirations.goals.yaml

@@ -3,7 +3,7 @@
 # STRATEGIC ROLE: bridges the EXISTING goal system (user_goals table + goal extraction
 # job + goal graph nodes) into the pack registry — same move as the `core` pack in the plan.
 pack: aspirations.goals
-version: 0.2.0
+version: 0.2.4
 status: draft
 title: "Goals & aspirations"
 author: topos
@@ -36,8 +36,20 @@ predicates:
   - {name: asp.commitment, value_type: structured, cardinality: multi, temporal: interval, altitude: stated,
      value_schema: {commitment: string, to_whom: entity_ref_or_self, due: date_or_approx},
      note: "promises with a counterparty/date — feeds the EXISTING Commitment time-signal lane"}
-  - {name: asp.milestone, value_type: structured, cardinality: multi, temporal: episodic, altitude: stated,
-     value_schema: {goal_ref: string, milestone: string, kind: [progress, setback, completion]}}
+  - name: asp.milestone
+    value_type: structured
+    cardinality: multi
+    temporal: episodic
+    altitude: stated
+    value_schema:
+      goal_ref: string
+      milestone: string
+      kind: {enum: [progress, setback, completion]}
+    note: >
+      v0.2.4 — a milestone belongs to a NAMED, ENDURING goal (one the owner pursues
+      across days), and goal_ref is that goal's short name, never a copied sentence.
+      Finishing a morning's task is a day's work, not a milestone: if the goal it
+      advances wouldn't be recognizable next week, extract nothing.
   - {name: asp.focus_period, value_type: structured, cardinality: multi, temporal: interval, altitude: inferred,
      value_schema: {focus: string, evidence_kind: [stated_priority, activity_concentration]},
      note: "what the owner is ACTUALLY prioritizing right now — reconciles stated goals with observed activity; the lens-lab goal-attachment work is the direct precedent"}
@@ -60,6 +72,12 @@ guidance:
   abstention:
     - "Authored-only: an assigned OKR is work context, not a personal goal, unless the owner adopts it in their own words."
     - "Idle wishes ('would love to someday') are aspirations, never goals — the horizon field is load-bearing."
+    - "v0.2.4 A goal is STATED INTENT in the owner's own words ('Goal:', 'I want to', 'I will').
+       Wry observations, jokes and family lore ('this is the closest I can keep that pattern
+       going') are never goals — if the owner would be surprised to see it on their goal list,
+       extract nothing."
+    - "v0.2.4 goal_ref is a NAME (a few words), not a sentence — a goal_ref longer than ~8 words
+       means the goal was never really named; prefer the Goal: header's own phrasing."
     - "Never mark a goal abandoned from silence; stalled requires the owner's words or a passed deadline plus zero activity (then still status=stalled, not abandoned)."
     - "asp.focus_period must cite both the stated goal AND the activity evidence; if they disagree, record the divergence honestly (that divergence IS the insight)."
 

{topos_node-1.3.26 → topos_node-1.3.28}/topos/features/derivation/bundled_packs/health.mental.yaml

@@ -3,7 +3,7 @@
 # health_neurodivergence, health_attention_condition, health_cognitive_load_capacity)
 # + Personality: MBTI (neurotype). Split from health.physical: stricter rules, different consumers.
 pack: health.mental
-version: 0.2.0
+version: 0.2.4
 status: draft
 title: "Mental wellbeing"
 author: topos
@@ -19,8 +19,22 @@ routing:
   exemplars: ["so burned out", "my therapist", "haven't been sleeping", "anxiety's been bad", "feeling great lately", "my ADHD"]
 
 predicates:
-  - {name: mind.self_reported_state, value_type: structured, cardinality: multi, temporal: episodic, altitude: stated,
-     value_schema: {dimension: {enum: [mood, stress, energy, sleep_quality, focus]}, report: string}}
+  - name: mind.self_reported_state
+    value_type: structured
+    cardinality: multi
+    temporal: episodic
+    altitude: stated
+    value_schema:
+      dimension: {enum: [mood, stress, energy, sleep_quality, focus]}
+      report: string
+    note: >
+      v0.2.4 — a state report is a FELT-STATE statement about how the owner is/was
+      ("I am exhausted", "slept 8 hours, wild dreams", "so nervous with the talk").
+      An intention, aspiration, reflection or observation is NOT a state, whatever
+      dimension it brushes: "I need to be talking to more intelligent people" is a
+      want, not an energy report; "the talk motivated me to write" is a reflection,
+      not a focus report. If the words don't describe how the owner FEELS or FELT,
+      extract nothing.
   - {name: mind.neurodivergence, value_type: string, cardinality: multi, temporal: interval, altitude: stated,
      note: "stated-only, verbatim self-identification; NEVER inferred"}
   - {name: mind.care_practice, value_type: structured, cardinality: multi, temporal: interval, altitude: stated,
@@ -56,6 +70,10 @@ eval:
     - {text: "Third week straight of terrible sleep, I'm running on fumes", role: authored,
        expect: [{predicate: mind.self_reported_state, value: {dimension: sleep_quality}}]}
   negative_controls:
+    - {text: "I need to be talking to more intelligent people. To go out of my way to speak with people.", role: authored,
+       expect_not: [{predicate: mind.self_reported_state}], note: "v0.2.4 measured junk: a want is not an energy state"}
+    - {text: "The talk at the end motivated me to write my own thought on coordination tools.", role: authored,
+       expect_not: [{predicate: mind.self_reported_state}], note: "v0.2.4 measured junk: a reflection is not a focus state"}
     - {text: "Podcast episode about burnout culture in tech", role: ambient, expect: []}
     - {text: "My brother finally started therapy, proud of him", role: authored, expect: [], note: "third party"}
     - {text: "ugh this parser is driving me insane", role: authored, expect: [], note: "idiom, not state report"}

{topos_node-1.3.26 → topos_node-1.3.28}/topos/features/derivation/registry.py

@@ -15,8 +15,11 @@ from typing import Dict
 
 from .packs import Pack, load_packs
 
-#: Wave A (PLAN_DERIVATION_WAVE2 §W5) — the only packs seeded enabled.
+#: Packs seeded enabled by default. Wave A earned its gate 2026-08-26 (full-corpus,
+#: junk ≈4-5%, zero critical misattribution); health.mental joined the same day
+#: (Wave B first admit: 0/7 junk under the 0.2.4 felt-state contract).
 WAVE_A = ("relationships.social", "work.career", "health.physical")
+ENABLED_BY_DEFAULT = WAVE_A + ("health.mental",)
 
 
 def seed_pack_registry(conn: sqlite3.Connection, pack_dir: Path) -> None:
@@ -28,7 +31,7 @@ def seed_pack_registry(conn: sqlite3.Connection, pack_dir: Path) -> None:
             """INSERT OR IGNORE INTO pack_registry
                (pack_id, version, enabled, disclosure_default)
                VALUES (?, ?, ?, ?)""",
-            (pid, pack.version, 1 if pid in WAVE_A else 0,
+            (pid, pack.version, 1 if pid in ENABLED_BY_DEFAULT else 0,
              getattr(pack, "disclosure_default", "owner_only") or "owner_only"),
         )
         # version follows the bundled catalog (upgrades are additive; the

{topos_node-1.3.26 → topos_node-1.3.28}/topos/features/derivation/surfaces.py

@@ -22,6 +22,20 @@ def list_packs(conn: sqlite3.Connection) -> Dict[str, Any]:
     conflict_counts = dict(conn.execute(
         "SELECT predicate, COUNT(*) FROM fact_conflicts WHERE status='pending'"
         " GROUP BY predicate").fetchall())
+    def _q(sql, args=()):
+        try:
+            return conn.execute(sql, args).fetchall()
+        except sqlite3.OperationalError:
+            return []              # pre-migration-66 node
+    offers = {}
+    for oid, pid_, kind, stats_json, created in _q(
+            "SELECT offer_id, pack_id, kind, stats_json, created_at FROM pack_offers"
+            " WHERE status='pending' ORDER BY created_at DESC"):
+        offers.setdefault(pid_, {"offer_id": oid, "kind": kind, "created_at": created,
+                                 "stats": json.loads(stats_json or "{}")})
+    yield_30d = {r[0]: {"prefilter_hits": r[1], "llm_calls": r[2], "written": r[3]}
+                 for r in _q("SELECT pack_id, SUM(prefilter_hits), SUM(llm_calls), SUM(written)"
+                             " FROM pack_yield WHERE day >= date('now','-30 day') GROUP BY pack_id")}
     packs: List[Dict[str, Any]] = []
     for pid, ver, enabled, disclosure, last_run in conn.execute(
             "SELECT pack_id, version, enabled, disclosure_default, last_run_at"
@@ -38,6 +52,8 @@ def list_packs(conn: sqlite3.Connection) -> Dict[str, Any]:
             "pending_conflicts": pending,
             "last_run_at": last_run,
             "predicates": len(getattr(p, "predicates", {}) or {}) if p else 0,
+            "offer": offers.get(pid),
+            "yield_30d": yield_30d.get(pid),
         })
     return {"packs": packs, "total_conflicts": sum(conflict_counts.values())}
 
@@ -81,3 +97,27 @@ def resolve_conflict(conn: sqlite3.Connection, conflict_id: str, status: str) ->
                            (status, conflict_id))
         commit_connection(conn)
     return bool(cur.rowcount)
+
+
+def resolve_pack_offer(conn: sqlite3.Connection, offer_id: str, action: str) -> Dict[str, Any]:
+    """Owner decision on a self-gating offer. accept on an enable_offer enables
+    the pack; accept on a disable_nudge disables it; dismiss just records the
+    choice (with backoff — a dismissed offer is not re-minted for 30 days)."""
+    if action not in ("accept", "dismiss"):
+        raise ValueError("action must be accept|dismiss")
+    row = conn.execute("SELECT pack_id, kind, status FROM pack_offers WHERE offer_id=?",
+                       (offer_id,)).fetchone()
+    if not row:
+        return {}
+    pack_id, kind, status = row
+    from ...storage.db.write_gate import commit_connection, with_db_write
+    with with_db_write():
+        conn.execute("UPDATE pack_offers SET status=?, updated_at=datetime('now')"
+                     " WHERE offer_id=?",
+                     ("accepted" if action == "accept" else "dismissed", offer_id))
+        if action == "accept":
+            enable = 1 if kind == "enable_offer" else 0
+            conn.execute("UPDATE pack_registry SET enabled=?, updated_at=datetime('now')"
+                         " WHERE pack_id=?", (enable, pack_id))
+        commit_connection(conn)
+    return {"offer_id": offer_id, "pack_id": pack_id, "kind": kind, "action": action}

{topos_node-1.3.26 → topos_node-1.3.28}/topos/features/derivation/writer.py

@@ -182,6 +182,8 @@ class DerivationWriter:
         occurrence: Optional[str] = None,   # episodic anchor (event date)
         quote: str = "",
         about: str = "owner",               # A2/A3 routing: owner | other:<name> | unclear
+        event_date: Optional[str] = None,   # source-record date: a fact's time is its
+                                            # EVIDENCE time, never extraction time
     ) -> Dict[str, Any]:
         pred = pack.predicates.get(predicate)
         if pred is None:
@@ -236,6 +238,13 @@ class DerivationWriter:
                 self.stats["retelling_merged"] = self.stats.get("retelling_merged", 0) + 1
                 return {"outcome": "retelling_merged", "object_id": retold["object_id"]}
         now = _now_iso()
+        # THE FACT'S TIME IS ITS EVIDENCE TIME (owner rule, 2026-08-26): a stated
+        # fact anchors to its stated occurrence, else its source record's date;
+        # extraction time lives only in the extractor provenance stamp. A fact
+        # that emerges from accumulation anchors to the newest record that
+        # completed it (synthesis passes the newest evidence date as event_date).
+        anchor = (str(occurrence)[:10] if occurrence else None) or \
+                 (str(event_date)[:10] if event_date else None) or now
 
         if incumbent is not None:
             inc_payload = incumbent["payload"]
@@ -279,12 +288,12 @@ class DerivationWriter:
             # SUPERSESSION: new evidence, the world changed
             self._close(incumbent, reason="superseded", at=now)
             row = self._insert(pack, pred, subject_entity_id, value, actor_role, source_refs,
-                               confidence, object_entity_id, occurrence, quote, valid_from=now, key=key)
+                               confidence, object_entity_id, occurrence, quote, valid_from=anchor, key=key)
             self.stats["superseded"] += 1
             return {"outcome": "superseded", "object_id": row}
 
         row = self._insert(pack, pred, subject_entity_id, value, actor_role, source_refs,
-                           confidence, object_entity_id, occurrence, quote, valid_from=now, key=key)
+                           confidence, object_entity_id, occurrence, quote, valid_from=anchor, key=key)
         self.stats["written"] += 1
         # Tier-2 `closes`: a value transition that closes OTHER active rows of this predicate
         self._apply_closes_rules(pack, pred, subject_entity_id, value)