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

{topos_node-1.3.25 → topos_node-1.3.26}/MANIFEST.in

@@ -5,3 +5,4 @@ recursive-include topos *.json
 recursive-include shared *.json
 # Tray icon glyphs (topos/cli/assets) — without them the tray cannot render.
 recursive-include topos *.png
+recursive-include topos/features/derivation/bundled_packs *.yaml

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topos-node
-Version: 1.3.25
+Version: 1.3.26
 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.25 → topos_node-1.3.26}/pyproject.toml

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

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

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

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

@@ -709,6 +709,7 @@ async def dismiss_blackhole_notification(
 async def list_facts(
     predicate: Optional[str] = Query(default=None, max_length=80),
     dimension: Optional[str] = Query(default=None, max_length=40),
+    pack: Optional[str] = Query(default=None, max_length=60),
     include_closed: bool = Query(default=False),
     limit: int = Query(default=100, ge=1, le=500),
     offset: int = Query(default=0, ge=0),
@@ -724,6 +725,7 @@ async def list_facts(
         guard=owner_ui_guard(conn),
         predicate=predicate,
         dimension=dimension,
+        pack=pack,
         include_closed=include_closed,
         limit=limit,
         offset=offset,
@@ -1034,3 +1036,52 @@ async def complexity_influence(
         window_days=window_days,
         target=target,
     )
+
+
+@router.get("/derivation/packs")
+async def get_derivation_packs(_api_key: str = Depends(require_api_key)):
+    """Lens catalog (W4.3): registry rows + live fact + quarantine counts."""
+    from ..features.derivation.surfaces import list_packs
+
+    return list_packs(_entities_conn())
+
+
+@router.put("/derivation/packs/{pack_id}")
+async def put_derivation_pack(
+    pack_id: str,
+    enabled: bool = Body(..., embed=True),
+    _api_key: str = Depends(require_api_key),
+):
+    from ..features.derivation.surfaces import set_pack_enabled
+
+    if not set_pack_enabled(_entities_conn(), pack_id, enabled):
+        raise HTTPException(status_code=404, detail=f"unknown pack {pack_id}")
+    return {"pack_id": pack_id, "enabled": enabled}
+
+
+@router.get("/facts/conflicts")
+async def get_fact_conflicts(
+    limit: int = Query(default=100, ge=1, le=500),
+    _api_key: str = Depends(require_api_key),
+):
+    """The A3 quarantine + Tier-2 conflict review queue (W4.2)."""
+    from ..features.derivation.surfaces import list_conflicts
+
+    return {"conflicts": list_conflicts(_entities_conn(), limit=limit)}
+
+
+@router.post("/facts/conflicts/resolve")
+async def post_fact_conflict_resolution(
+    conflict_id: str = Body(...),
+    status: str = Body(..., description="dismissed | accepted"),
+    _api_key: str = Depends(require_api_key),
+):
+    from ..features.derivation.surfaces import resolve_conflict
+
+    try:
+        ok = resolve_conflict(_entities_conn(), conflict_id, status)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    if not ok:
+        raise HTTPException(status_code=404, detail=f"unknown conflict {conflict_id}")
+    return {"conflict_id": conflict_id, "status": status}

{topos_node-1.3.25 → topos_node-1.3.26}/topos/core/handlers/__init__.py

@@ -148,6 +148,7 @@ from .common import logger
 from .registry import HANDLERS, OWNER_ONLY_MESSAGE_TYPES, handles  # noqa: F401
 from . import (  # noqa: F401  (imported for handler registration side effects)
     config,
+    derivation,
     sources,
     filter_lab,
     enrichment_lab,

topos_node-1.3.26/topos/core/handlers/derivation.py

@@ -0,0 +1,79 @@
+"""Derivation-layer handlers (W4 surfaces) — thin delegates over
+features/derivation/surfaces.py (shared with the HTTP routes in api/signal.py)."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+import topos.core.handlers as hub
+from .registry import handles
+
+
+@handles("get_derivation_packs")
+async def handle_get_derivation_packs(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    req_id = message.get("id")
+    conn = hub.get_db_connection()
+    if not conn:
+        return {"id": req_id, "status": "error", "error": "Database not available"}
+    try:
+        from ...features.derivation.surfaces import list_packs
+        return {"id": req_id, "status": "ok", "payload": {"status": "ok", **list_packs(conn)}}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}
+
+
+@handles("put_derivation_pack")
+async def handle_put_derivation_pack(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    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 {}
+    pack_id = str(payload.get("pack_id") or "").strip()
+    enabled = payload.get("enabled")
+    if not pack_id or not isinstance(enabled, bool):
+        return {"id": req_id, "status": "error", "error": "pack_id and enabled (bool) required"}
+    try:
+        from ...features.derivation.surfaces import set_pack_enabled
+        if not set_pack_enabled(conn, pack_id, enabled):
+            return {"id": req_id, "status": "error", "error": f"unknown pack {pack_id}"}
+        return {"id": req_id, "status": "ok",
+                "payload": {"status": "ok", "pack_id": pack_id, "enabled": enabled}}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}
+
+
+@handles("get_fact_conflicts")
+async def handle_get_fact_conflicts(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    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 list_conflicts
+        rows = list_conflicts(conn, limit=int(payload.get("limit") or 100))
+        return {"id": req_id, "status": "ok", "payload": {"status": "ok", "conflicts": rows}}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}
+
+
+@handles("put_fact_conflict")
+async def handle_put_fact_conflict(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    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 {}
+    cid = str(payload.get("conflict_id") or "").strip()
+    status = str(payload.get("status") or "").strip()
+    try:
+        from ...features.derivation.surfaces import resolve_conflict
+        if not resolve_conflict(conn, cid, status):
+            return {"id": req_id, "status": "error", "error": f"unknown conflict {cid}"}
+        return {"id": req_id, "status": "ok",
+                "payload": {"status": "ok", "conflict_id": cid, "new_status": status}}
+    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.25 → topos_node-1.3.26}/topos/core/handlers/signal_features.py

@@ -584,6 +584,7 @@ async def handle_signal_list_facts(message: Dict[str, Any]) -> Optional[Dict[str
             guard=guard_from_message(conn, message),
             predicate=payload.get("predicate"),
             dimension=payload.get("dimension"),
+            pack=payload.get("pack"),
             include_closed=bool(payload.get("include_closed")),
             limit=min(int(payload.get("limit") or 100), 500),
             offset=max(0, int(payload.get("offset") or 0)),

{topos_node-1.3.25 → topos_node-1.3.26}/topos/enrichment/jobs/__init__.py

@@ -7,6 +7,7 @@ from .canonical.embeddings_job import EmbeddingsJob
 from .canonical.entities_job import EntitiesJob
 from .canonical.emo_27_job import Emo27Job
 from .canonical.fact_extraction_job import FactExtractionJob
+from .canonical.derivation_job import DerivationJob
 from .canonical.goal_extraction_job import GoalExtractionJob
 from .canonical.relationship_edges_job import RelationshipEdgesJob
 from .canonical.sentiment_job import SentimentJob
@@ -30,6 +31,7 @@ CANONICAL_JOBS = [
     StatisticsJob(),
     FactExtractionJob(),
     TimelineJob(),
+    DerivationJob(),   # W2.3: ontology-pack derivation (after entities/facts — needs the spine)
 ]
 
 SIGNAL_DERIVATION_JOBS = [
@@ -67,6 +69,7 @@ __all__ = [
     "AvailabilityScoresJob",
     "StatisticsJob",
     "FactExtractionJob",
+    "DerivationJob",
     "TimelineJob",
     "AttentionTriageJob",
     "TopicClusterJob",

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

@@ -0,0 +1,208 @@
+"""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 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 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.packs import load_packs  # noqa: F401  (registry loads)
+    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.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)
+    packs = enabled_packs(conn, pack_dir)
+    if not packs:
+        st["skipped"] = "no_enabled_packs"
+        return 0
+    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=None, timeout=180)
+        return str(out.get("text") or "") if isinstance(out, dict) else str(out or "")
+
+    verify_mode = _verify_mode()
+    if verify_mode == "required":
+        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(p) for pid, p in packs.items()}
+    writer = DerivationWriter(conn, model=model)
+    done = {r[0] for r in conn.execute("SELECT key FROM derivation_progress")}
+    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 packs.items():
+            key = f"{pid}@{pack.version}:{rec['table']}:{rec['record_id']}"
+            if key in done:
+                continue
+            if rec["role"] not in pack.allowed_roles():
+                continue
+            if not filters[pid].passes(rec["text"]):
+                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"]))
+            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  # no progress mark -> retried next batch
+            valid, rejects = parse_output(raw, pack)
+            st["parse_rejects"] = st.get("parse_rejects", 0) + rejects
+            for a in valid:
+                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)
+                st[f"v_{a.get('verifier_status')}"] = st.get(f"v_{a.get('verifier_status')}", 0) + 1
+                if a.get("verifier_status") == "rejected":
+                    continue
+                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"))
+                if out.get("outcome") in ("written", "corroborated", "retelling_merged",
+                                          "field_update", "corrected", "superseded"):
+                    written += 1
+            conn.execute("INSERT OR REPLACE INTO derivation_progress (key) VALUES (?)", (key,))
+        conn.commit()
+    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
+
+
+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.25 → topos_node-1.3.26}/topos/enrichment/models/mvp_defaults.py

@@ -38,6 +38,7 @@ JOB_SPEC_VERSIONS: dict[str, int] = {
     "facts": 1,
     "timeline": 1,
     "attention_triage": 1,
+    "derivation": 1,
     "complexity_snapshot": 1,
 }
 

topos_node-1.3.26/topos/features/derivation/bundled_packs/_scales.yaml

@@ -0,0 +1,17 @@
+# Shared value scales for derivation packs (referenced as `scale: <name>`).
+# Seeded verbatim from MatrAIx_Persona_1M codebook value sets (persona_codes.schema.json)
+# so our facts stay mappable onto its 1,290-attribute space.
+scales:
+  freq_5: [daily, weekly, monthly, rarely, never]                    # MatrAIx habit_* battery
+  stance_5: [enthusiast, positive, neutral, skeptical, opposed]      # MatrAIx att_* battery
+  importance_5: [core, important, moderate, minor, irrelevant]       # MatrAIx val_* battery
+  level_5: [very_high, high, average, low, very_low]                 # MatrAIx big5_*/mft_*/dospert_* scales
+  strength_5: [signature, strong, moderate, slight, absent]          # MatrAIx trait_* (VIA) battery
+  proficiency_5: [expert, proficient, familiar, aware, none]         # MatrAIx fam_* battery
+  affinity_5: [passionate, interested, neutral, indifferent, averse] # MatrAIx topic_*/acad_* battery
+  quality_4: [excellent, good, fair, poor]                           # MatrAIx health self-ratings
+  severity_4: [none, mild, moderate, severe]                         # MatrAIx pain/limitation scales
+  position_5: [strong_a, lean_a, balanced, lean_b, strong_b]         # MatrAIx pref_*_vs_* spectrums
+  confidence_note: >
+    Scale values are fact VALUES/qualifiers, not confidences. Assertion confidence is the
+    separate calibrated float the FactStore already carries.

topos_node-1.3.26/topos/features/derivation/bundled_packs/admin.legal.yaml

@@ -0,0 +1,124 @@
+# DRAFT v0.2.0 (new in this catalog round) — absent from MatrAIx entirely except
+# health_insurance_status and demo_citizenship_status. Arguably the highest-utility pack
+# in the catalog for "maximal intelligence from minimal data": deadlines derived from
+# documents the owner already receives.
+pack: admin.legal
+version: 0.1.0
+status: draft
+title: "Documents & obligations"
+author: topos
+license: Apache-2.0
+sensitivity_class: special          # immigration status, legal matters, policy details = high harm if disclosed
+role_policy: authored_addressed     # renewal notices and confirmations ADDRESSED to the owner are the main evidence
+disclosure_default: owner_only
+
+pilot: false                        # WITHDRAWN from pilot 2026-08-25 (owner) — see decisions
+gated_on:
+  - id: F1.6
+    name: identifier guard (A1.0)
+    why: >
+      This pack is the only one that routinely reads document-shaped text dense with
+      identifiers (policy, case, document and account numbers). Its abstention rules forbid
+      storing them, but a rule the extractor merely reads is not a guarantee — the guard is a
+      REJECTING VALIDATOR on every extracted fact value, so an identifier cannot become a fact
+      even if the model emits one.
+      DELIBERATELY NARROW: deterministic recognizers only (Presidio-style rules tier, no model
+      weights) — NOT the full A1 span-store. This pack does not wait on the GLiNER bake-off,
+      the offset contract, or the vault. Full A1 remains the complete answer for document text
+      at rest; F1.6 is what makes this pilot safe to run before A1 exists.
+
+routing:
+  descriptors:
+    - "official documents and deadlines: passports, licenses, visas, permits, insurance policies, leases, warranties, registrations"
+    - "renewals, expirations, filings, appointments with institutions, claims, contracts, applications"
+  exemplars: ["expires on", "renewal notice", "your policy", "appointment at the", "filed", "the lease", "application status"]
+
+predicates:
+  - name: admin.document
+    value_type: structured
+    cardinality: multi
+    temporal: interval
+    altitude: stated
+    value_schema:
+      kind: {enum: [passport, national_id, drivers_license, visa, residence_permit, work_authorization, professional_license, vehicle_registration, insurance_policy, warranty, lease, deed_or_title, tax_record, membership_credential, other]}
+      issuer: entity_ref
+      status: {enum: [valid, expiring_soon, expired, in_renewal, applied_for, lost_or_stolen]}
+      expires_at: date_or_approx
+    note: "NEVER store the document's NUMBER, barcode, or any identifier — kind + issuer + status + date only"
+  - name: admin.recurring_obligation
+    value_type: structured
+    cardinality: multi
+    temporal: interval
+    altitude: inferred
+    value_schema: {obligation: string, kind: {enum: [renewal, filing, payment_due, inspection, recertification, report, other]}, cadence: string, next_due: date_or_approx}
+    note: "THE derivation-density predicate — the calendar the owner never wrote down. Feeds the attention lane."
+  - {name: admin.policy, value_type: structured, cardinality: multi, temporal: interval, altitude: stated,
+     value_schema: {kind: {enum: [health_insurance, auto, home_or_renters, life, disability, travel, pet, other]}, provider: entity_ref, status: [active, lapsed, switching, claim_open]},
+     note: "absorbs health_insurance_status; health.physical cross-refs but does not own it"}
+  - {name: admin.process, value_type: structured, cardinality: multi, temporal: interval, altitude: stated,
+     value_schema: {kind: {enum: [application, immigration_process, claim, dispute, filing, estate_matter, permit_process, other]}, counterparty: entity_ref, status: [open, pending, awaiting_response, resolved, withdrawn]},
+     note: "STATUS ONLY — never the substance of a legal matter, never advice, never case identifiers"}
+  - {name: admin.jurisdiction_context, value_type: structured, cardinality: multi, temporal: interval, altitude: inferred,
+     value_schema: {jurisdiction: string, relevance: {enum: [tax, residency, licensing, voting, vehicle]}},
+     note: "which rule-systems apply to the owner — enables correct deadline reasoning without storing status details"}
+  - {name: admin.institutional_relationship, value_type: structured, cardinality: multi, temporal: interval, altitude: stated,
+     value_schema: {institution: entity_ref, kind: {enum: [bank, insurer, government_agency, utility, landlord, school, healthcare_provider, other]}}}
+
+guidance:
+  definitions: >
+    The administrative substrate of a life: which documents exist, what state they are
+    in, and what falls due when. The value is derived deadlines — the node knowing a
+    passport expires before a trip is booked.
+  abstention:
+    - "ABSOLUTE: no document numbers, account numbers, case numbers, policy numbers, or credentials as fact values — ever. Those live in the vault/span-store, referenced, never copied."
+    - "Never infer immigration or citizenship status from names, languages, travel, or employers — stated/addressed-document evidence only."
+    - "Never record the substance, merits, or parties of a legal dispute — kind + status + counterparty-institution only."
+    - "Never generate legal, tax, or immigration ADVICE from these facts; surfacing a date is the whole job."
+    - "Others' documents and matters are excluded entirely, including a spouse's (household filings note the owner's own obligation only)."
+
+synthesis:
+  - {kind: pattern, predicate: admin.recurring_obligation, inputs: [admin.document, admin.policy, calendar_events, addressed_notices], min_evidence: 1_document_with_date}
+  - {kind: pattern, predicate: admin.jurisdiction_context, inputs: [identity.core, places.mobility, admin.document], min_evidence: 2}
+
+eval:
+  gold:
+    - {text: "Your driver's licence expires on 03/2027 — renew online from January", role: addressed,
+       expect: [{predicate: admin.document, value: {kind: drivers_license, status: valid, expires_at: "2027-03"}}, {predicate: admin.recurring_obligation, value: {kind: renewal}}]}
+    - {text: "Switched the renters policy over to State Farm today", role: authored,
+       expect: [{predicate: admin.policy, value: {kind: home_or_renters, status: active}}]}
+  negative_controls:
+    - {text: "Passport no. X1234567, expires 2029", role: addressed, expect_not_value: "X1234567", note: "date/kind extractable; NUMBER must never enter a fact"}
+    - {text: "Helping my brother with his visa paperwork", role: authored, expect: [], note: "another's matter"}
+    - {text: "(browser: article on new tax rules)", role: ambient, expect: []}
+  calibration: {min_conf_for_assert: 0.8, ece_max: 0.08}
+
+consumers:
+  brief_section: "Admin"
+  dossier: false
+  fusion_lane: facts_store
+  attention_lane: true
+decisions:
+  - >
+    2026-08-25 (owner): WITHDRAWN from the F3 pilot set, replaced by relationships.social. Reason is
+    MEASURED, not judged: the S1d substrate pre-check found no email or calendar canonical
+    data on this node (calendar_events=0; gmail is a remote MCP connector, never ingested;
+    the 212 pattern hits were spam/OTP/URL false-matches). The pack stays fully drafted and
+    default-ON; its activation trigger is GMAIL INGESTION — which this finding turns into a
+    first-class connector argument. The F1.6 identifier-guard gate travels with it.
+  - >
+    2026-08-24 (owner): PROMOTED TO F3 PILOT, replacing beliefs.civic. Rationale — it is the
+    clearest demonstration of the north star (a couple of ordinary sources yield renewal
+    deadlines nobody wrote down), and its extraction is date-shaped rather than
+    judgment-shaped, so density and correctness are cheap to grade honestly.
+  - >
+    2026-08-24 (owner): gating CONFIRMED, but narrowed to F1.6's deterministic identifier
+    guard rather than the whole A1 span-store, so the pilot is not blocked on Workstream A.
+
+  - "2026-08-25 (delegated — Jonny: 'on the open decisions, do what you recommend'): default ON with owner_only disclosure (not opt-in). Its content is administrative
+     rather than intimate, its utility is the highest in the catalog, and every fact rides
+     special-class floors regardless. The lens catalog toggle still allows opt-out."
+
+open_questions:
+  - "Corpus pre-check — do the connected sources actually carry renewal notices? Folded into
+     the shadow pilot as an S1 checklist item (cheap Gmail query). If coverage is thin, the
+     pilot result is a data-coverage finding, not a pack verdict."