topos-node 1.5.4__tar.gz → 1.5.6__tar.gz

{topos_node-1.5.4/topos_node.egg-info → topos_node-1.5.6}/PKG-INFO

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

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

{topos_node-1.5.4 → topos_node-1.5.6}/topos/__version__.py

@@ -1,6 +1,6 @@
 """Topos Control Plane Version Information."""
 
-__version__ = "1.5.4"
-__version_info__ = (1, 5, 4)
+__version__ = "1.5.6"
+__version_info__ = (1, 5, 6)
 
 __all__ = ["__version__", "__version_info__"]

{topos_node-1.5.4 → topos_node-1.5.6}/topos/api/shell.py

@@ -6,12 +6,13 @@ stay dumb renderers: identity + version for attach-don't-double-start, the
 log file location for a "Show Logs" action, and cached update state with a
 localhost-only trigger to apply an update.
 
-Update *checking* is not done here — the runtime update monitor started in
-app startup keeps ``get_update_info()`` fresh; this router only reads it.
+Polling reads cached state. A manual check explicitly refreshes it from PyPI
+off the event loop, without waiting for the six-hour runtime monitor.
 """
 
 from __future__ import annotations
 
+import asyncio
 import os
 import threading
 from time import time
@@ -21,7 +22,10 @@ from fastapi import APIRouter, HTTPException, Request
 from ..core.logging import get_log_file_path
 from ..runtime_update import (
     DEFAULT_PACKAGE_NAME,
+    UpdateCheckError,
+    _set_update_info,
     apply_package_update,
+    check_for_update,
     get_runtime_version,
     get_update_info,
 )
@@ -96,3 +100,21 @@ async def shell_apply_update(request: Request) -> dict:
 
     threading.Thread(target=worker, daemon=True, name="topos-shell-update").start()
     return {"started": True}
+
+
+@router.post("/update/check")
+async def shell_check_update(request: Request) -> dict:
+    if not _client_is_local(request):
+        raise HTTPException(status_code=403, detail="Shell update checks can only be triggered from localhost.")
+    # Never replace the update state while an install/restart is pending.
+    with _apply_lock:
+        pending = _apply_state["applying"] or _apply_state["last_result"] == "success"
+    if not pending:
+        try:
+            info = await asyncio.to_thread(check_for_update, DEFAULT_PACKAGE_NAME, strict=True)
+        except UpdateCheckError as exc:
+            # Keep the last known update; a failed network check is not proof
+            # the running node is current.
+            raise HTTPException(status_code=503, detail=str(exc)) from exc
+        _set_update_info(info)
+    return await shell_status()

{topos_node-1.5.4 → topos_node-1.5.6}/topos/control_plane_client.py

@@ -149,6 +149,9 @@ class ControlPlaneClient:
         )
         self._inbound_semaphore = asyncio.Semaphore(self._inbound_concurrency_limit)
         self._inbound_tasks: set[asyncio.Task] = set()
+        # UI reads get a separate bounded reserve, never an unbounded bypass.
+        self._fast_inbound_tasks: set[asyncio.Task] = set()
+        self._fast_inbound_max_pending = 32
         self._inbound_lock = asyncio.Lock()
         # R-N154 M2: set at the start of a stop; new asks are refused while the ones in hand finish.
         self._draining = False
@@ -450,21 +453,30 @@ class ControlPlaneClient:
             if request_id:
                 await self._send_ws_json(ws, {"id": request_id, "status": "error", "error": STOPPING_ERROR})
             return
+        if msg_type == "ping":
+            await self._handle_message(ws, data)
+            return
         if msg_type in _FAST_INBOUND_MESSAGE_TYPES:
+            if len(self._fast_inbound_tasks) >= self._fast_inbound_max_pending:
+                if msg_type == "healthcheck":
+                    await self._send_ws_json(ws, self._healthcheck_snapshot_response(data.get("id")))
+                elif msg_type == "get_device_info" and self._device_info_snapshot_response(data.get("id")):
+                    await self._send_ws_json(ws, self._device_info_snapshot_response(data.get("id")))
+                else:
+                    await self._send_busy_response(ws, data)
+                return
             task = asyncio.create_task(self._handle_message(ws, data))
             self._inbound_tasks.add(task)
+            self._fast_inbound_tasks.add(task)
             task.add_done_callback(self._on_inbound_task_done)
             return
         async with self._inbound_lock:
-            pending_count = len(self._inbound_tasks)
+            pending_count = len(self._inbound_tasks) - len(self._fast_inbound_tasks)
             if pending_count >= self._inbound_max_pending:
                 logger.warning("Dropping inbound request due to saturation pending=%d", pending_count)
                 request_id = data.get("id")
                 if request_id:
-                    await self._send_ws_json(
-                        ws,
-                        {"id": request_id, "status": "error", "error": "Engine is busy. Retry shortly."},
-                    )
+                    await self._send_busy_response(ws, data)
                 return
             task = asyncio.create_task(self._handle_message_guarded(ws, data))
             self._inbound_tasks.add(task)
@@ -472,6 +484,15 @@ class ControlPlaneClient:
 
     def _on_inbound_task_done(self, task: asyncio.Task) -> None:
         self._inbound_tasks.discard(task)
+        self._fast_inbound_tasks.discard(task)
+
+    async def _send_busy_response(self, ws, data: Dict[str, Any]) -> None:
+        if data.get("id"):
+            await self._send_ws_json(ws, {
+                "id": data["id"], "type": data.get("type"), "status": "error",
+                "error": "Engine is busy. Retry shortly.", "error_code": "engine_busy",
+                "retry_after_seconds": 30,
+            })
 
     async def _handle_message_guarded(self, ws, data: Dict[str, Any]) -> None:
         async with self._inbound_semaphore:
@@ -591,7 +612,7 @@ class ControlPlaneClient:
             "id": request_id,
             "status": "ok",
             "type": "healthcheck",
-            "payload": {"ok": True, "db_ok": db_ok, "snapshot_stale": True},
+            "payload": {"ok": True, "db_ok": db_ok, "snapshot_stale": True, "accepting_writes": False},
         }
 
     def _echo_request_type(self, resp: Dict[str, Any], data: Dict[str, Any]) -> Dict[str, Any]:
@@ -656,6 +677,11 @@ class ControlPlaneClient:
             resp = {"id": data.get("id"), "status": "error", "error": str(exc)}
         if resp is None:
             return  # e.g. connection_info or message without id; CP has no pending request to match
+        if msg_type == "healthcheck" and resp.get("status") == "ok":
+            resp = {**resp, "payload": {
+                **(resp.get("payload") or {}),
+                "accepting_writes": not self._draining and len(self._inbound_tasks) - len(self._fast_inbound_tasks) < self._inbound_max_pending,
+            }}
         await self._send_ws_json(ws, self._echo_request_type(resp, data))
 
     async def _await_with_device_info_fallback(self, ws, data: Dict[str, Any], handler_future) -> dict[str, Any] | None:
@@ -696,7 +722,8 @@ class ControlPlaneClient:
                 if isinstance(late, dict) and late.get("status") == "ok" and isinstance(late.get("payload"), dict):
                     self.set_device_info_snapshot(late["payload"])
 
-            asyncio.create_task(_refresh_from_late_answer())
+            # Keep late work in the bounded task set until it actually finishes.
+            await _refresh_from_late_answer()
             return None
 
     async def _await_with_healthcheck_fallback(self, ws, data: Dict[str, Any], handler_future) -> dict[str, Any] | None:
@@ -724,7 +751,7 @@ class ControlPlaneClient:
                 if isinstance(late, dict) and late.get("status") == "ok" and isinstance(late.get("payload"), dict):
                     self.set_healthcheck_snapshot(late["payload"])
 
-            asyncio.create_task(_refresh_from_late_answer())
+            await _refresh_from_late_answer()
             return None
 
     async def send_message(self, message: Dict[str, Any]) -> None:

{topos_node-1.5.4 → topos_node-1.5.6}/topos/core/handlers/config.py

@@ -38,10 +38,13 @@ async def handle_migrate_browser_plugin_app_id(message: Dict[str, Any]) -> Optio
     req_id = message.get("id")
     from ..state import _migrate_legacy_browser_plugin_app_ids
 
-    conn = hub.get_db_connection()
-    if not conn:
+    def migrate():
+        conn = hub.get_db_connection()
+        return _migrate_legacy_browser_plugin_app_ids(conn) if conn else None
+
+    updated = await asyncio.to_thread(migrate)
+    if updated is None:
         return {"id": req_id, "status": "error", "error": "Database not available"}
-    updated = _migrate_legacy_browser_plugin_app_ids(conn)
     return {"id": req_id, "status": "ok", "payload": {"updated_rows": updated}}
 
 @handles("get_request_counts")
@@ -51,11 +54,15 @@ async def handle_get_request_counts(message: Dict[str, Any]) -> Optional[Dict[st
     payload = message.get("payload") or {}
     owner_user_id = (payload.get("owner_user_id") or "").strip()
     since_days = min(max(int(payload.get("since_days") or 90), 1), 365)
-    conn = hub.get_db_connection()
-    if not owner_user_id and conn:
-        owner_user_id = get_user_id(conn) or ""
-    uma = get_uma_request_counts(conn, owner_user_id, since_days) if conn else {"total_read_requests": 0, "total_write_requests": 0, "by_app": []}
-    mcp = get_mcp_request_counts(conn, since_days) if conn else {"by_source": [], "by_tool": [], "total": 0}
+    def counts():
+        # Resolve the connection on its worker thread, never pass a loop-owned handle.
+        conn = hub.get_db_connection()
+        owner = owner_user_id or (get_user_id(conn) if conn else "") or ""
+        uma = get_uma_request_counts(conn, owner, since_days) if conn else {"total_read_requests": 0, "total_write_requests": 0, "by_app": []}
+        mcp = get_mcp_request_counts(conn, since_days) if conn else {"by_source": [], "by_tool": [], "total": 0}
+        return uma, mcp
+
+    uma, mcp = await asyncio.to_thread(counts)
     return {"id": req_id, "status": "ok", "payload": {"uma": uma, "mcp": mcp}}
 
 @handles("get_ui_config")

{topos_node-1.5.4 → topos_node-1.5.6}/topos/core/handlers/permissions_v2_owner.py

@@ -198,7 +198,10 @@ async def handle_permissions_v2_share_counts(message):
         from ...permissions_v2.share_counts import count
         owner = _owner_gate(message, bound_only=True, unavailable="counts_unavailable")
         payload = _keys(owner.payload, {"binding", "request"}, {"binding", "request"})
-        request = _keys(payload["request"], {"policy"}, {"policy"})
+        request = _keys(payload["request"], {"policy", "fact_preview_offset"}, {"policy"})
+        offset = request.get("fact_preview_offset", 0)
+        if type(offset) is not int or not 0 <= offset <= 100000:
+            raise _Refused(400, "payload_invalid")
         if not isinstance(request["policy"], dict):
             raise _Refused(400, "policy_invalid")
         try:
@@ -212,7 +215,7 @@ async def handle_permissions_v2_share_counts(message):
         if any(getattr(policy.binding, field) != value for field, value in owner.identity.model_dump().items()):
             raise _Refused(409, "binding_mismatch")
         service = owner.runtime.evidence_reviews(require_existing=True)
-        return count(service.resolver, service.reviews, policy, now=int(time.time()))
+        return count(service.resolver, service.reviews, policy, now=int(time.time()), fact_preview_offset=offset)
     return await _respond(message, COUNTS, work, unavailable="counts_unavailable")
 
 

{topos_node-1.5.4 → topos_node-1.5.6}/topos/core/state.py

@@ -113,6 +113,9 @@ def _aggregate_uma_access_attribution(
 
 def _ensure_uma_access_requests_indexes(conn: sqlite3.Connection) -> None:
     try:
+        if conn.execute("SELECT 1 FROM sqlite_master WHERE type='index' AND name=?",
+                        ("idx_uma_access_requests_owner_created",)).fetchone():
+            return
         # DDL takes SQLite's write lock at execute time — gate it with the
         # commit like every other writer (write_gate lock-order inversion).
         with with_db_write():
@@ -127,6 +130,9 @@ def _ensure_uma_access_requests_indexes(conn: sqlite3.Connection) -> None:
 
 def _ensure_mcp_request_log_indexes(conn: sqlite3.Connection) -> None:
     try:
+        if conn.execute("SELECT 1 FROM sqlite_master WHERE type='index' AND name=?",
+                        ("idx_mcp_request_log_requested_at",)).fetchone():
+            return
         with with_db_write():
             conn.execute(
                 f"CREATE INDEX IF NOT EXISTS idx_mcp_request_log_requested_at "
@@ -914,6 +920,9 @@ def _ensure_uma_access_requests_table(conn: sqlite3.Connection) -> None:
 def _migrate_legacy_browser_plugin_app_ids(conn: sqlite3.Connection) -> int:
     """Rewrite engine Activity counts from browser-plugin → browser-history-plugin (idempotent)."""
     try:
+        if not conn.execute(f"SELECT 1 FROM {UMA_ACCESS_REQUESTS_TABLE} WHERE app_id=? LIMIT 1",
+                            (LEGACY_BROWSER_PLUGIN_APP_ID,)).fetchone():
+            return 0
         with with_db_write():
             cursor = conn.execute(
                 f"UPDATE {UMA_ACCESS_REQUESTS_TABLE} SET app_id = ? WHERE app_id = ?",

{topos_node-1.5.4 → topos_node-1.5.6}/topos/permissions_v2/answer_transport.py

@@ -37,10 +37,16 @@ async def dispatch_answer(ws, message):
             def work():
                 service = get_runtime().answers()
                 method = service.submit if kind == SUBMIT_TYPE else service.fetch
-                return method(envelope=payload["envelope"], payload=payload["intent"], request_id=request_id)
+                result, output = method(envelope=payload["envelope"], payload=payload["intent"], request_id=request_id)
+                selective_answer = False
+                if kind == FETCH_TYPE:
+                    from .signing import parse_envelope
+                    _authority, policy = service._current(parse_envelope(payload["envelope"]))
+                    selective_answer = getattr(policy.search, "selective_facts", None) is not None
+                return result, output, selective_answer
 
             try:
-                result, output = await asyncio.wait_for(asyncio.to_thread(work), timeout=WAIT_SECONDS)
+                result, output, selective_answer = await asyncio.wait_for(asyncio.to_thread(work), timeout=WAIT_SECONDS)
             except asyncio.TimeoutError:
                 # BL-159, counts-only: which door, never an id. The service's own line follows with its seconds.
                 _log.warning("permissions answer relay: no result within %d s (%s)", WAIT_SECONDS,
@@ -48,6 +54,9 @@ async def dispatch_answer(ws, message):
                 raise
         finally:
             reset_principal(token)
+        from .selective_facts import require_active_output
+        from . import switches
+        require_active_output(output, enabled=switches.on(switches.SELECTIVE_FACTS), selective_answer=selective_answer)
         await ws.send(canonical_bytes({"id": request_id, "type": kind, "status": "ok",
                                        "payload": {"result": result, "output": output}}).decode("ascii"))
     except AnswerBusy:

{topos_node-1.5.4 → topos_node-1.5.6}/topos/permissions_v2/entailment_grounding.py

@@ -663,6 +663,11 @@ def collecting():
         _PENDING.reset(token)
 
 
+def collecting_active() -> bool:
+    """Private owner/judge inspection is active; ordinary sharing installs no collector."""
+    return _PENDING.get() is not None
+
+
 def judge_id() -> str:
     from .shadow_labeler_local import MODEL, MODEL_REVISION
     return f"{MODEL}@{MODEL_REVISION}/{PROMPT_VERSION}/{hashlib.sha256(PROMPT.encode()).hexdigest()[:16]}"

topos_node-1.5.6/topos/permissions_v2/fact_preview.py

@@ -0,0 +1,62 @@
+"""Owner-only grant-specific candidates. Release reuses the same qualifier."""
+from .canonical import PolicyError
+from .evidence import _json, _key
+from .knowledge_projections import candidates, fact_projection
+from .predicate_classes import scalar
+from .selective_facts import ontology_of
+
+REASONS = {
+    "eligible": "Passes this grant's current protections",
+    "owner_only": "Kept private by its producer or owner",
+    "fact_ontology_unselected": "This ontology is not selected",
+    "fact_excluded_from_grant": "Excluded from this grant",
+    "fact_ontology_unknown": "Missing or conflicting ontology provenance",
+    "fact_ontology_unsupported": "Ontology or predicate is outside this release",
+    "fact_not_grounded": "No supported owner-stated source sentence",
+    "fact_lineage_unsupported": "Fact dependencies are outside this release",
+    "fact_not_owner_stated": "The owner did not state this fact",
+    "entity_protected": "Off-limits protection applies",
+    "owner_opted_out": "You held this item back globally",
+    "evidence_not_permitted": "Supporting evidence fails this grant's choices",
+    "selective_facts_disabled": "Fact sharing is disabled",
+    "could_not_check": "Could not verify every protection",
+}
+
+
+def preview(walk, identities):
+    items = []
+    for table, fid in sorted(set(candidates(walk.conn, identities, ["fact"]))):
+        rows = walk.conn.execute("SELECT * FROM signal_objects WHERE object_id=?", (fid,)).fetchmany(2)
+        if len(rows) != 1:
+            continue
+        row = dict(rows[0])
+        try:
+            payload = _json(row["payload_json"], dict)
+        except PolicyError:
+            continue
+        try:
+            oid = ontology_of(row, payload)
+        except PolicyError:
+            oid = row.get("ontology_id") or "unregistered"
+        code, sources, projected = "eligible", [], None
+        try:
+            cached = walk.projection_results.get((table, fid))
+            if cached is not None:
+                projected, refusal = cached
+                if refusal is not None:
+                    raise PolicyError(refusal)
+            else:
+                projected = fact_projection(walk.resolver, walk.conn, walk.floor, walk.frozen, None,
+                                           row, walk.policy, walk.lower_us, walk.upper_us)
+            for qualified, native in projected.sources:
+                identity = qualified.snapshot.message.identity
+                sources.append({"source_id": identity.source_id, "record_id": identity.record_id,
+                                "excerpt": native[_key(identity)]["content"][:240]})
+        except PolicyError as exc:
+            code = exc.code if exc.code in REASONS else "could_not_check"
+        value = scalar(payload.get("predicate"), payload)
+        items.append({"fact_id": fid, "ontology_id": oid, "predicate": payload.get("predicate") or "unknown",
+            "statement": projected.content if code == "eligible" else value or "Unsupported structured fact", "assertion": "inferred" if
+                payload.get("altitude") in ("inferred", "predicted") or row.get("altitude") in ("inferred", "predicted") else "owner_stated",
+            "eligible": code == "eligible", "reason": code, "reason_text": REASONS[code], "sources": sources})
+    return items

{topos_node-1.5.4 → topos_node-1.5.6}/topos/permissions_v2/knowledge_contract.py

@@ -8,6 +8,7 @@ from typing import Annotated, Literal
 from pydantic import Field, StringConstraints, field_validator, model_serializer, model_validator
 
 from .contract import Hash, Identifier, Number, StrictModel
+from .selective_facts import SelectiveFacts
 from .search_contract import (SearchPolicy, SearchDeclaration, SearchOutputForm, SearchRelease,
     SearchRule, SearchMemberDecision, SearchSetDecision, OpaqueRecordId)
 
@@ -30,7 +31,7 @@ AnswerMode = Literal["only", "with_sources", "records"]
 # encoding and a policy signed before this field keeps its bytes.
 WriterDisclosure = Literal["origin", "provider", "model", "build"]
 # The declared-or-absent fields of the declaration (the serializer leaves an absent one out of the dump).
-DECLARED_OR_ABSENT = ("answers", "writer_disclosure")
+DECLARED_OR_ABSENT = ("answers", "writer_disclosure", "selective_facts")
 
 
 class KnowledgeBinding(StrictModel):
@@ -73,6 +74,13 @@ class KnowledgeDeclaration(SearchDeclaration):
     time_semantics: Literal["underlying_evidence_time/v1"]
     answers: AnswerMode | None = None
     writer_disclosure: WriterDisclosure | None = None
+    selective_facts: SelectiveFacts | None = None
+
+    @model_validator(mode="after")
+    def selection_needs_facts(self):
+        if self.selective_facts is not None and "fact" not in self.result_types:
+            raise ValueError("fact selection without fact output")
+        return self
 
     @model_validator(mode="before")
     @classmethod
@@ -151,6 +159,16 @@ class MessageResult(KnowledgeRecord):
 class FactResult(KnowledgeRecord):
     kind: Literal["fact"]
     assertion: Literal["owner_stated", "inferred"]
+    ontology_id: Identifier | None = None
+    predicate: Identifier | None = None
+
+    @model_serializer(mode="wrap")
+    def omit_legacy_identity(self, handler):
+        encoded = handler(self)
+        for key in ("ontology_id", "predicate"):
+            if encoded.get(key) is None:
+                encoded.pop(key, None)
+        return encoded
 
 
 class GoalResult(KnowledgeRecord):

{topos_node-1.5.4 → topos_node-1.5.6}/topos/permissions_v2/knowledge_projections.py

@@ -15,10 +15,9 @@ field clears `journal_goal_field.refusal` (Lane H1; `TOPOS_PERMISSIONS_V2_JOURNA
 off unless the node is bound); every other check above still applies to it. Under a grant that releases
 that entry itself, whole (`journal_entry_released`, decided per grant where the rule is asked), the field is a
 paragraph the grant already releases, and the rule's guards on the text's form are set aside; under
-any other grant they all apply. A fact citing exactly one journal entry that
-the entry does not state releases as `assertion: "inferred"` when its value clears every guard of
-`inferred_facts.refusal` (IF-6 v1; `TOPOS_PERMISSIONS_V2_DERIVED_FACTS`, default off, inert without the
-journal family); with the flag off it is `fact_not_grounded`, exactly as before.
+any other grant they all apply. Selective facts cite only their authorized statement,
+so their evidence does not require the raw journal output option. No inferred fact
+is released through selective ontology sharing.
 """
 from __future__ import annotations
 
@@ -121,7 +120,7 @@ class Projection:
             # A journal entry is cited as a record (IF-5 §3): its own opaque id, its whole text, its one source.
             citations.append(dict(record_id=opaque_record_id(key,grant_id=grant_id,table=identity.table,
                 source_id=source_id,dataset_id=identity.dataset_id,record_id=identity.record_id),
-                source_id=source_id,content=row['content']))
+                source_id=source_id,content=self.content if self.kind == 'fact' else row['content']))
             times.append(_source_released(identity,row,precision))
         # Old support cannot gain a fresh date through recent extraction: the earliest source dates the item. A
         # source that cannot be dated at this precision (a stated day at `second`) dates nothing, so neither does it.
@@ -220,14 +219,14 @@ def _unrestricted(resolver,conn,reviews,review_db,table,record_id,row):
     return boundary
 
 
-def _journal_citation(resolver,conn,reviews,review_db,ref,identity,policy):
+def _journal_citation(resolver,conn,reviews,review_db,ref,identity,policy,*,projection_only=False):
     """What a journal citation needs before its entry is qualified (IF-5 §2, §1.2).
 
     The entry is cited as a record, so the grant must sign the "Journal entries" option. When the item names a
     same-source twin rather than the member, the named row still vetoes: its own NSFW flag, deletion, owner-only
     mark, exclusion, the owner's opt-out and an Off-limits match over every column. The member is qualified next.
     """
-    if 'journal_entry' not in policy.search.result_types:
+    if not projection_only and 'journal_entry' not in policy.search.result_types:
         raise PolicyError('journal_citation_needs_record_option')
     cited=_journal_entry_id(ref)
     if cited==identity.record_id:
@@ -275,14 +274,14 @@ def _inside(identity,row,lower_us,upper_us):
         raise PolicyError('evidence_outside_window')
 
 
-def _support(resolver,conn,floor,reviews,review_db,refs,policy,lower_us,upper_us,*,extra_domains=(),extra_sensitivity='none'):
+def _support(resolver,conn,floor,reviews,review_db,refs,policy,lower_us,upper_us,*,extra_domains=(),extra_sensitivity='none',projection_only=False):
     if not isinstance(refs,list) or not 1<=len(refs)<=MAX_SUPPORT:
         raise PolicyError('lineage_identity_incomplete')
     result,seen,common=[],set(),None
     for ref in refs:
         identity=resolve_reference(resolver,conn,ref)
         if identity.table==JOURNAL:
-            _journal_citation(resolver,conn,reviews,review_db,ref,identity,policy)
+            _journal_citation(resolver,conn,reviews,review_db,ref,identity,policy,projection_only=projection_only)
         if _key(identity) in seen: continue
         seen.add(_key(identity))
         qualified,rows=qualify_automatic_message(resolver,conn,floor,identity,reviews,review_db)
@@ -312,6 +311,11 @@ def fact_projection(resolver,conn,floor,reviews,review_db,row,policy,lower_us,up
     if row.get('object_type')!='fact' or row.get('valid_to') is not None:
         raise PolicyError('fact_not_current')
     payload=_json(row['payload_json'],dict)
+    from . import switches
+    from .selective_facts import authorize
+    if not switches.on(switches.SELECTIVE_FACTS):
+        raise PolicyError('selective_facts_disabled')
+    ontology_id = authorize(row, payload, policy)
     from .evidence import SHAREABLE_DISCLOSURES, implicit_labels
     if payload.get('disclosure') not in SHAREABLE_DISCLOSURES:
         raise PolicyError('fact_disclosure_unknown')
@@ -331,25 +335,25 @@ def fact_projection(resolver,conn,floor,reviews,review_db,row,policy,lower_us,up
         ranks={'none':0,'personal':1,'special':2,'unknown':3}
         sensitivity=max([sensitivity,*[c.sensitivity for c in checked.classifications]],key=ranks.__getitem__)
     sources,clause=_support(resolver,conn,floor,reviews,review_db,_json(row['source_refs_json'],list),policy,lower_us,upper_us,
-                            extra_domains=domains,extra_sensitivity=sensitivity)
+                            extra_domains=domains,extra_sensitivity=sensitivity,projection_only=True)
     check_lineage(payload,sources)
     assertion='owner_stated'
     if not any(explicitly_states_claim(rows[_key(q.snapshot.message.identity)]['content'],predicate,value) for q,rows in sources):
-        # OD-38, flag default off: one cited message on its own entails the claim (guards + a stored verdict).
-        from .entailment_grounding import author_of, entailed, fact_claim
-        claim=fact_claim(predicate,value)
-        attested=subject in permit_subjects(conn,contract=ATTESTED_CONTRACT)
-        if not any(entailed(resolver,claim=claim,row=row,identity=q.snapshot.message.identity,
-                            message=rows[_key(q.snapshot.message.identity)]['content'],author_is_owner=author_of(q),
-                            subject_attested=attested,boundary=boundary) for q,rows in sources):
-            # IF-6 v1 (§2 step 7), flag default off: the extractor's fact on one journal entry, as inferred.
-            from . import inferred_facts
-            if not inferred_facts.enabled():
-                raise PolicyError('fact_not_grounded')
-            _inferred(conn,reviews,review_db,policy,sources,predicate,value,boundary)
-            assertion='inferred'
+        # The selective release never enables inference or semantic grounding,
+        # even when a separate experimental switch is on.
+        # Preserve private owner inspection without admitting its verdict to sharing.
+        from .entailment_grounding import collecting_active
+        if collecting_active():
+            from .entailment_grounding import author_of, entailed, fact_claim
+            claim = fact_claim(predicate, value)
+            attested = subject in permit_subjects(conn, contract=ATTESTED_CONTRACT)
+            for qualified, native in sources:
+                entailed(resolver, claim=claim, row=row, identity=qualified.snapshot.message.identity,
+                         message=native[_key(qualified.snapshot.message.identity)]['content'],
+                         author_is_owner=author_of(qualified), subject_attested=attested, boundary=boundary)
+        raise PolicyError('fact_not_grounded')
     return Projection('signal_objects',row['object_id'],'fact',f'Owner {PREDICATE_TEXT[predicate]} {value}.',
-        {'assertion':assertion},sources,rows_revision([[row]]),clause)
+        {'assertion':assertion, 'ontology_id':ontology_id, 'predicate':predicate},sources,rows_revision([[row]]),clause)
 
 
 def _inferred(conn,reviews,review_db,policy,sources,predicate,value,boundary):

{topos_node-1.5.4 → topos_node-1.5.6}/topos/permissions_v2/ledger.py

@@ -632,6 +632,10 @@ class PolicyLedger:
         """Every released record is covered by its own member's permit rule, as p2a's shape check requires per read."""
         from .knowledge_contract import KnowledgePolicy, KnowledgeMemberBinding, VIEW_KNOWLEDGE
         if isinstance(policy, KnowledgePolicy):
+            from .selective_facts import validate_output, require_active_output
+            from . import switches
+            validate_output(policy, output)
+            require_active_output(output, enabled=switches.on(switches.SELECTIVE_FACTS))
             if decision.required_projection_id != VIEW_KNOWLEDGE:
                 raise PolicyError("rule_binding")
             members = [KnowledgeMemberBinding.parse(m if isinstance(m,dict) else m.model_dump()) for m in members]

{topos_node-1.5.4 → topos_node-1.5.6}/topos/permissions_v2/native_claim_grounding.py

@@ -12,7 +12,9 @@ _FORMS = {
     'works_at': (r'I work at {value}', r'I am employed by {value}'),
     'worked_at': (r'I worked at {value}',),
     'works_on': (r'I work on {value}', r'I am working on {value} at work',
-                 r"I['’]m working on {value} at work", r'My work project is {value}'),
+                 r"I['’]m working on {value} at work", r'My work project is {value}',
+                 r'My current work project is {value}', r'At work, I am working on {value}',
+                 r"At work, I['’]m working on {value}"),
     'role_is': (r'My role is {value}',),
     'certified_in': (r'I am certified in {value}', r"I['’]m certified in {value}"),
     'studied_at': (r'I studied at {value}',),

{topos_node-1.5.4 → topos_node-1.5.6}/topos/permissions_v2/refresh_loop.py

@@ -130,13 +130,14 @@ once for the next round, which follows that restore. ``TOPOS_PERMISSIONS_V2_INTE
 set off turns the second tries off: the refresh is then what it was without them, and its
 receipt carries none of their counts.
 
-With ``TOPOS_PERMISSIONS_V2_DERIVED_FACTS`` also on (IF-6 §10; inert without the journal family), a fact the
+With ``TOPOS_PERMISSIONS_V2_SELECTIVE_FACTS_ENABLED`` on, or the legacy
+``TOPOS_PERMISSIONS_V2_DERIVED_FACTS`` experiment on (IF-6 §10; inert without the journal family), a fact the
 extractor writes after a grant's index was built (the derivation pass lags the ingest, or a re-derivation closes
 and replaces a fact on an already-indexed entry) moves no index basis and no member row, so no drift would drop
 the index and the fact would wait for an unrelated rebuild. ``observe`` therefore keeps a cheap digest of the
 facts (:func:`fact_digest`: their count, the highest rowid, the latest ``valid_from`` and ``valid_to``), kept in
 the state file so a restart compares with the last one seen; when it moves, the active knowledge grants that could
-release an inferred fact (v1: they sign ``journal_entry`` and ``fact``) and have an index here are queued on the
+release a fact (explicit selective consent, or the legacy journal/fact experiment) and have an index here are queued on the
 restore's own queue, cause ``facts_changed`` (its debounce, interval, deferral and backoff). A grant whose rebuild
 is running when its facts move again stays queued for one more rebuild, so a fact written behind a build's
 snapshot is not dropped with the finished entry. With the flag off nothing is read or queued.
@@ -340,7 +341,7 @@ class RefreshSettings:
         if restore:
             # The projection's own reading of its flag (and of the journal family it needs), so they never disagree.
             from .inferred_facts import enabled as derived_facts_enabled
-            facts = derived_facts_enabled(env)
+            facts = derived_facts_enabled(env) or switches.on(switches.SELECTIVE_FACTS, env)
         return cls(restore=restore, catchup=catchup,
                    min_interval=float(switches.number(switches.INDEX_RESTORE_MIN_INTERVAL, env)),
                    max_assessed=switches.number(switches.ASSESSMENT_CATCHUP_MAX_PER_PASS, env), interests=interests,
@@ -752,7 +753,7 @@ class RefreshLoop:
     # -- IF-6 §10: facts the extractor wrote after a build -----------------
 
     def _observe_facts(self, service) -> None:
-        """Queue the grants that could release an inferred fact when the facts moved since the last observation
+        """Queue the grants that could release a fact when the facts moved since the last observation
         (the last one recorded in the state file across a restart). The first observation only records."""
         if not self.settings.facts:
             return
@@ -784,8 +785,7 @@ class RefreshLoop:
             return None
 
     def _fact_grants(self, now: int) -> list[str]:
-        """Active knowledge grants that could release an inferred fact (IF-6 v1: they sign `journal_entry` and
-        `fact`) and have an index here, published or owed. A grant that never had an index is still never built
+        """Active knowledge grants with selective fact consent or the legacy journal/fact experiment and have an index here, published or owed. A grant that never had an index is still never built
         here: the owner hooks build it."""
         from .search_index import index_path
         names = {path.name for path in self.root.glob("grant-*.db")}
@@ -793,7 +793,9 @@ class RefreshLoop:
             owed = set(self._pending)
         return [grant_id for grant_id, _authority, policy in self._active_grants(now)
                 if policy.versions.capability == CAPABILITY_KNOWLEDGE_SEARCH
-                and {"journal_entry", "fact"} <= set(policy.search.result_types)
+                and "fact" in policy.search.result_types
+                and ({"journal_entry", "fact"} <= set(policy.search.result_types)
+                     or getattr(policy.search, "selective_facts", None) is not None)
                 and (index_path(self.root, grant_id).name in names or grant_id in owed)]
 
     def _request_fact_rebuilds(self, now: float) -> int: