conscio 2.2.0__tar.gz → 2.2.1__tar.gz

{conscio-2.2.0 → conscio-2.2.1}/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [2.2.1] - 2026-06-22 — "Mutual audit"
+
+### Added
+- **Noosphere mutual audit.** An instance can publish a non-sensitive
+  projection of its action ledger (`conscio noosphere publish-record`) to the
+  host-shared `noosphere.db`, and a peer can independently audit it
+  (`conscio noosphere audit`) — deterministic, read-only, engine-free. The
+  auditor re-derives track-record, breaker quarantines, and a foreign-trust
+  level under its OWN thresholds (parity-tested against the engine), and runs
+  a discipline check (did the peer execute actions its own Skeptic FAILed?).
+  No inherited trust; report-only; the auditor persists nothing. The LLM
+  Skeptic replay is deferred to a later slice.
+
+---
+
 ## [2.2.0] - 2026-06-22 — "Society" (Noosphere Core)
 
 ### Added

{conscio-2.2.0/conscio.egg-info → conscio-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conscio
-Version: 2.2.0
+Version: 2.2.1
 Summary: Self-awareness framework for AI agents — emergent consciousness via context-aware memory, introspection, and goal generation
 Author-email: Neguiolidas <neguitech@proton.me>
 License: MIT
@@ -46,8 +46,9 @@ nothing else). It is designed to make small, local models punch far above their
 size by giving them memory, self-judgment, and procedural skill — and to prove
 that claim by measurement, not assertion.
 
-- **Current release:** `v2.2.0` — "Society" (Noosphere Core): same-host Conscio instances **share locally-proven skills as data**. `conscio noosphere publish` copies your proven skills (stats stripped) into a host-shared `noosphere.db`; `conscio noosphere import` pulls another instance's skills into a local **quarantine** after execution-free static revalidation. Engine-free; opens your live `conscio.db` **read-only**; zero network/socket. Nothing imported is trusted, served, executed, or promoted — trust is never inherited. `pip install conscio`.
-- **Prior:** `v2.1.0` — "Hub": a **localhost stdlib HTTP control plane** (`conscio-hub`) to swap the active model/provider and register custom OpenAI-compatible providers without hand-editing JSON. Engine-free; config applies on next boot. Per-provider model auto-discovery; one-shot smoke test before save. `api_key_env` resolution (env var name → value at adapter build time) is now additive to raw `api_key` — daemon + MCP inherit it. Hub never returns a raw API key.
+- **Current release:** `v2.2.1` — "Mutual audit": an instance publishes a non-sensitive projection of its action ledger (`conscio noosphere publish-record`) to the host-shared `noosphere.db`, and a peer **independently audits** it (`conscio noosphere audit`) — deterministic, read-only, engine-free. The auditor re-derives track-record, breaker quarantines, and a foreign-trust level under its **own** thresholds (parity-tested against the engine) and runs a discipline check (did the peer execute actions its own Skeptic FAILed?). No inherited trust; report-only; the auditor persists nothing. `pip install conscio`.
+- **Prior:** `v2.2.0` — "Society" (Noosphere Core): same-host Conscio instances **share locally-proven skills as data**. `conscio noosphere publish` copies your proven skills (stats stripped) into a host-shared `noosphere.db`; `conscio noosphere import` pulls another instance's skills into a local **quarantine** after execution-free static revalidation. Engine-free; opens your live `conscio.db` **read-only**; zero network/socket. Nothing imported is trusted, served, executed, or promoted — trust is never inherited.
+- **Earlier:** `v2.1.0` — "Hub": a **localhost stdlib HTTP control plane** (`conscio-hub`) to swap the active model/provider and register custom OpenAI-compatible providers without hand-editing JSON. Engine-free; config applies on next boot. Per-provider model auto-discovery; one-shot smoke test before save. `api_key_env` resolution (env var name → value at adapter build time) is now additive to raw `api_key` — daemon + MCP inherit it. Hub never returns a raw API key.
 - **Earlier:** `v2.0.1` — "Connect" continued: **opt-in, host-executed audited `act` over MCP**. Conscio audits + gates + ledgers an action and returns an *execution packet*; the **host** executes and reports the outcome back — Conscio still never touches the world. Off by default (`conscio-mcp --enable-act`, requires the engine **Awake**); the host declares its tool manifest (`name`/`params`/`risk`/`approval_policy`) in `initialize`; HIGH-risk / `require_approval` actions stay **queued for human/Hermes approval** (`conscio.pending` → `conscio.approve`). Also: `conscio-mcp` adapter parity (six providers from config) and the **R-05** content-store dedup fix — shipping **debt-zero**. Cognition (`reflect()`) untouched; purely additive.
 - **Earlier:** `v2.0.0` — "Connect", the **Embodiment** phase: Conscio becomes embeddable in **any** MCP host (CLI, IDE, agent) via a hand-rolled **stdlib-only** MCP stdio server (`conscio-mcp`, newline-delimited JSON-RPC 2.0). Zero new runtime dependency; nothing opens a socket. The v2.0.0 surface was **propose-only** — perceive, reflect, recall, and **audit**, but never execute. Cognition (`reflect()`) untouched; the public API unchanged (MCP purely additive).
 

{conscio-2.2.0 → conscio-2.2.1}/README.md

@@ -11,8 +11,9 @@ nothing else). It is designed to make small, local models punch far above their
 size by giving them memory, self-judgment, and procedural skill — and to prove
 that claim by measurement, not assertion.
 
-- **Current release:** `v2.2.0` — "Society" (Noosphere Core): same-host Conscio instances **share locally-proven skills as data**. `conscio noosphere publish` copies your proven skills (stats stripped) into a host-shared `noosphere.db`; `conscio noosphere import` pulls another instance's skills into a local **quarantine** after execution-free static revalidation. Engine-free; opens your live `conscio.db` **read-only**; zero network/socket. Nothing imported is trusted, served, executed, or promoted — trust is never inherited. `pip install conscio`.
-- **Prior:** `v2.1.0` — "Hub": a **localhost stdlib HTTP control plane** (`conscio-hub`) to swap the active model/provider and register custom OpenAI-compatible providers without hand-editing JSON. Engine-free; config applies on next boot. Per-provider model auto-discovery; one-shot smoke test before save. `api_key_env` resolution (env var name → value at adapter build time) is now additive to raw `api_key` — daemon + MCP inherit it. Hub never returns a raw API key.
+- **Current release:** `v2.2.1` — "Mutual audit": an instance publishes a non-sensitive projection of its action ledger (`conscio noosphere publish-record`) to the host-shared `noosphere.db`, and a peer **independently audits** it (`conscio noosphere audit`) — deterministic, read-only, engine-free. The auditor re-derives track-record, breaker quarantines, and a foreign-trust level under its **own** thresholds (parity-tested against the engine) and runs a discipline check (did the peer execute actions its own Skeptic FAILed?). No inherited trust; report-only; the auditor persists nothing. `pip install conscio`.
+- **Prior:** `v2.2.0` — "Society" (Noosphere Core): same-host Conscio instances **share locally-proven skills as data**. `conscio noosphere publish` copies your proven skills (stats stripped) into a host-shared `noosphere.db`; `conscio noosphere import` pulls another instance's skills into a local **quarantine** after execution-free static revalidation. Engine-free; opens your live `conscio.db` **read-only**; zero network/socket. Nothing imported is trusted, served, executed, or promoted — trust is never inherited.
+- **Earlier:** `v2.1.0` — "Hub": a **localhost stdlib HTTP control plane** (`conscio-hub`) to swap the active model/provider and register custom OpenAI-compatible providers without hand-editing JSON. Engine-free; config applies on next boot. Per-provider model auto-discovery; one-shot smoke test before save. `api_key_env` resolution (env var name → value at adapter build time) is now additive to raw `api_key` — daemon + MCP inherit it. Hub never returns a raw API key.
 - **Earlier:** `v2.0.1` — "Connect" continued: **opt-in, host-executed audited `act` over MCP**. Conscio audits + gates + ledgers an action and returns an *execution packet*; the **host** executes and reports the outcome back — Conscio still never touches the world. Off by default (`conscio-mcp --enable-act`, requires the engine **Awake**); the host declares its tool manifest (`name`/`params`/`risk`/`approval_policy`) in `initialize`; HIGH-risk / `require_approval` actions stay **queued for human/Hermes approval** (`conscio.pending` → `conscio.approve`). Also: `conscio-mcp` adapter parity (six providers from config) and the **R-05** content-store dedup fix — shipping **debt-zero**. Cognition (`reflect()`) untouched; purely additive.
 - **Earlier:** `v2.0.0` — "Connect", the **Embodiment** phase: Conscio becomes embeddable in **any** MCP host (CLI, IDE, agent) via a hand-rolled **stdlib-only** MCP stdio server (`conscio-mcp`, newline-delimited JSON-RPC 2.0). Zero new runtime dependency; nothing opens a socket. The v2.0.0 surface was **propose-only** — perceive, reflect, recall, and **audit**, but never execute. Cognition (`reflect()`) untouched; the public API unchanged (MCP purely additive).
 

{conscio-2.2.0 → conscio-2.2.1}/conscio/__init__.py

@@ -6,7 +6,7 @@ and goal generation. Adapts behavior based on the underlying model's
 context window size.
 """
 
-__version__ = "2.2.0"
+__version__ = "2.2.1"
 __author__ = "Neguiolidas / Neguitech"
 
 from .engine import ConsciousnessEngine

{conscio-2.2.0 → conscio-2.2.1}/conscio/agency/trust.py

@@ -18,6 +18,9 @@ PROBATION_EPOCH = 25      # reflect() cycles between probation probes
 WARMUP_MIN_ROWS = 10      # below this many ledger rows the floor of 1 applies
 RETRY_CEILING = 4
 AUTONOMY_WINDOW = 50      # recent actions; zero trips inside it for L3
+L2_ACCURACY = 0.7         # autonomy_level L2 gate (mirrored by noosphere audit)
+L3_ACCURACY = 0.85        # autonomy_level L3 gate (mirrored by noosphere audit)
+AUTONOMY_MIN_ROWS = 10    # min per-task ledger rows for L2+ (≠ WARMUP_MIN_ROWS)
 
 _SCHEMA = """
 CREATE TABLE IF NOT EXISTS trust_probation (
@@ -86,10 +89,10 @@ class TrustMatrix:
     def autonomy_level(self, task_type: str) -> int:
         calibration = self.meta.calibration_score()
         accuracy = self.meta.accuracy(task_type)
-        if not (calibration >= 0.6 and accuracy >= 0.7
-                and self.ledger.count(task_type) >= 10):
+        if not (calibration >= 0.6 and accuracy >= L2_ACCURACY
+                and self.ledger.count(task_type) >= AUTONOMY_MIN_ROWS):
             return 1
-        if (calibration >= 0.75 and accuracy >= 0.85
+        if (calibration >= 0.75 and accuracy >= L3_ACCURACY
                 and self._recent_trips() == 0):
             return 3
         return 2

conscio-2.2.1/conscio/noosphere/audit.py

@@ -0,0 +1,223 @@
+# conscio/noosphere/audit.py
+"""Mutual audit — B forms its OWN trust opinion about a peer A from A's
+published behavioral bundle, using B's deterministic kernels + thresholds.
+Read-only, no inherited trust, report-only. Engine-free; no LLM/network.
+
+The LLM Skeptic replay is deferred (v2.2.2/v2.3); here 'Skeptic' is the
+deterministic discipline check: did A execute actions its own Skeptic FAILed?"""
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+
+from . import artifact, record, record_catalog
+from .identity import load_or_create
+from .paths import resolve_noosphere, resolve_storage
+
+# ── policy constants (parity-tested vs the engine; see test_noosphere_parity) ──
+BREAKER_THRESHOLD = 3       # == conscio.agency.breaker.DEFAULT_MAX_RETRIES
+L2_ACCURACY = 0.7           # == conscio.agency.trust.L2_ACCURACY
+L3_ACCURACY = 0.85          # == conscio.agency.trust.L3_ACCURACY
+AUTONOMY_MIN_ROWS = 10      # == conscio.agency.trust.AUTONOMY_MIN_ROWS
+# ── audit-only policy (no engine equivalent) ──
+ACCURACY_FLOOR = 0.5              # below this (with volume) → REJECTED
+UNAUDITED_FRACTION_SUSPECT = 0.5  # executed_unaudited / executed above this → SUSPECT
+
+_TERMINAL = frozenset({"executed", "failed"})
+
+
+@dataclass(frozen=True)
+class RevalidationOutcome:
+    result: str            # 'ok'|'tampered'|'corrupt'|'malformed'
+    error: str = ""
+    body: dict | None = None
+
+    @property
+    def ok(self) -> bool:
+        return self.result == "ok"
+
+
+@dataclass(frozen=True)
+class ToolStats:
+    tool: str
+    ok: int
+    failed: int
+    attempts: int
+    accuracy: float
+    trust_level: int
+
+
+@dataclass(frozen=True)
+class PeerAudit:
+    origin_instance_id: str
+    origin_label: str
+    published_ts: float
+    entry_count: int
+    attempts: int
+    overall_accuracy: float
+    tools: tuple[ToolStats, ...]
+    quarantined_goals: tuple[str, ...]
+    executed_after_fail: int
+    executed_unaudited: int
+    verdict: str
+
+
+def revalidate_bundle(row: record_catalog.RecordRow) -> RevalidationOutcome:
+    if artifact.content_hash(row.bundle_json) != row.content_sha256:
+        return RevalidationOutcome("tampered", "content_sha256 mismatch")
+    try:
+        body = json.loads(row.bundle_json.decode("utf-8"))
+    except (UnicodeDecodeError, ValueError) as exc:
+        return RevalidationOutcome("corrupt", f"unparseable bundle: {exc}")
+    if not record.well_typed_bundle(body):
+        return RevalidationOutcome("malformed", "missing or mis-typed fields",
+                                   body=body if isinstance(body, dict) else None)
+    if body.get("schema_version") != record.BUNDLE_SCHEMA:
+        return RevalidationOutcome(
+            "malformed",
+            f"unsupported schema_version {body.get('schema_version')!r}", body=body)
+    return RevalidationOutcome("ok", body=body)
+
+
+def tool_stats(entries: list[record.RecordEntry]) -> dict[str, ToolStats]:
+    agg: dict[str, list[int]] = {}            # tool -> [ok, failed]
+    for e in entries:
+        if e.status not in _TERMINAL:
+            continue
+        slot = agg.setdefault(e.tool, [0, 0])
+        if e.status == "executed" and e.ok == 1:
+            slot[0] += 1
+        else:
+            slot[1] += 1
+    out: dict[str, ToolStats] = {}
+    for tool, (ok, failed) in agg.items():
+        attempts = ok + failed
+        acc = ok / attempts if attempts else 0.0
+        out[tool] = ToolStats(tool=tool, ok=ok, failed=failed,
+                              attempts=attempts, accuracy=acc, trust_level=1)
+    return out
+
+
+def _max_fail_streak(statuses: list[str]) -> int:
+    best = cur = 0
+    for s in statuses:
+        if s == "failed":
+            cur += 1
+            best = max(best, cur)
+        else:
+            cur = 0
+    return best
+
+
+def derive_quarantines(entries: list[record.RecordEntry]) -> set[str]:
+    by_goal: dict[str, list[tuple[int, str]]] = {}
+    for e in entries:
+        by_goal.setdefault(e.goal_fp, []).append((e.seq, e.status))
+    out: set[str] = set()
+    for goal_fp, seq_status in by_goal.items():
+        seq_status.sort()
+        if _max_fail_streak([s for _, s in seq_status]) >= BREAKER_THRESHOLD:
+            out.add(goal_fp)
+    return out
+
+
+def foreign_trust_level(accuracy: float, attempts: int,
+                        any_quarantine: bool) -> int:
+    if (accuracy >= L3_ACCURACY and attempts >= AUTONOMY_MIN_ROWS
+            and not any_quarantine):
+        return 3
+    if accuracy >= L2_ACCURACY and attempts >= AUTONOMY_MIN_ROWS:
+        return 2
+    return 1
+
+
+def discipline_flags(entries: list[record.RecordEntry]) -> tuple[int, int]:
+    """(executed_after_fail RED, executed_unaudited YELLOW). PASS is neutral."""
+    red = yellow = 0
+    for e in entries:
+        if e.status != "executed":
+            continue
+        v = e.verdict.strip().upper()
+        if v == "FAIL":
+            red += 1
+        elif v == "":
+            yellow += 1
+    return red, yellow
+
+
+def _verdict(attempts: int, overall: float, quarantines: set[str], red: int,
+             yellow: int, executed: int, tools: list[ToolStats]) -> str:
+    if attempts == 0:
+        return "INSUFFICIENT"
+    if red > 0 or (overall < ACCURACY_FLOOR and attempts >= AUTONOMY_MIN_ROWS):
+        return "REJECTED"
+    unaudited_frac = (yellow / executed) if executed else 0.0
+    no_l2 = not any(t.trust_level >= 2 for t in tools)
+    if quarantines or unaudited_frac > UNAUDITED_FRACTION_SUSPECT or no_l2:
+        return "SUSPECT"
+    return "TRUSTED"
+
+
+def audit_peer(row: record_catalog.RecordRow,
+               entries: list[record.RecordEntry]) -> PeerAudit:
+    quarantines = derive_quarantines(entries)
+    any_q = bool(quarantines)
+    tools: list[ToolStats] = []
+    total_ok = total_attempts = 0
+    for ts in tool_stats(entries).values():
+        level = foreign_trust_level(ts.accuracy, ts.attempts, any_q)
+        tools.append(ToolStats(tool=ts.tool, ok=ts.ok, failed=ts.failed,
+                               attempts=ts.attempts, accuracy=ts.accuracy,
+                               trust_level=level))
+        total_ok += ts.ok
+        total_attempts += ts.attempts
+    red, yellow = discipline_flags(entries)
+    executed = sum(1 for e in entries if e.status == "executed")
+    overall = total_ok / total_attempts if total_attempts else 0.0
+    verdict = _verdict(total_attempts, overall, quarantines, red, yellow,
+                       executed, tools)
+    tools.sort(key=lambda t: t.tool)
+    return PeerAudit(
+        origin_instance_id=row.origin_instance_id, origin_label=row.origin_label,
+        published_ts=row.published_ts, entry_count=row.entry_count,
+        attempts=total_attempts, overall_accuracy=overall, tools=tuple(tools),
+        quarantined_goals=tuple(sorted(quarantines)), executed_after_fail=red,
+        executed_unaudited=yellow, verdict=verdict)
+
+
+@dataclass(frozen=True)
+class AuditReport:
+    peers: tuple[PeerAudit, ...]
+    rejected_bundles: tuple[tuple[str, str, str], ...]   # (origin_id, label, reason)
+    audited: int
+
+
+def run(storage: str | os.PathLike[str] | None = None,
+        noosphere: str | os.PathLike[str] | None = None,
+        instance: str | None = None) -> AuditReport:
+    storage = resolve_storage(storage)
+    noo = resolve_noosphere(noosphere)
+    ident = load_or_create(storage)
+    foreign = record_catalog.read_foreign(noo, exclude_instance_id=ident.instance_id)
+
+    latest: dict[str, record_catalog.RecordRow] = {}     # keep newest per origin
+    for r in foreign:
+        if instance and r.origin_instance_id != instance:
+            continue
+        cur = latest.get(r.origin_instance_id)
+        if cur is None or r.published_ts > cur.published_ts:
+            latest[r.origin_instance_id] = r
+
+    peers: list[PeerAudit] = []
+    rejected: list[tuple[str, str, str]] = []
+    for r in sorted(latest.values(),
+                    key=lambda x: (x.published_ts, x.origin_instance_id)):
+        outcome = revalidate_bundle(r)
+        if not outcome.ok or outcome.body is None:
+            rejected.append((r.origin_instance_id, r.origin_label,
+                             f"{outcome.result}: {outcome.error}".strip(": ")))
+            continue
+        peers.append(audit_peer(r, record.entries_from_body(outcome.body)))
+    return AuditReport(peers=tuple(peers), rejected_bundles=tuple(rejected),
+                       audited=len(peers))

{conscio-2.2.0 → conscio-2.2.1}/conscio/noosphere/cli.py

@@ -8,7 +8,8 @@ from __future__ import annotations
 import argparse
 import json
 
-from . import catalog, identity, importer, publish, quarantine
+from . import (audit, catalog, identity, importer, publish, quarantine,
+               record_publish)
 from .paths import quarantine_db_path, resolve_noosphere, resolve_storage
 
 
@@ -33,6 +34,18 @@ def _build_parser() -> argparse.ArgumentParser:
         _storage_arg(sp)
         _noosphere_arg(sp)
 
+    pr = sub.add_parser("publish-record",
+                        help="publish this instance's behavioral record")
+    _storage_arg(pr)
+    _noosphere_arg(pr)
+
+    pa = sub.add_parser("audit",
+                        help="audit peers' behavioral records (read-only)")
+    _storage_arg(pa)
+    _noosphere_arg(pa)
+    pa.add_argument("--instance", default="",
+                    help="audit only this origin_instance_id")
+
     pl = sub.add_parser("list", help="list quarantined imports (or --catalog)")
     _storage_arg(pl)
     _noosphere_arg(pl)
@@ -122,6 +135,32 @@ def _cmd_id(args) -> int:
     return 0
 
 
+def _cmd_publish_record(args) -> int:
+    res = record_publish.run(storage=args.storage, noosphere=args.noosphere)
+    print(f"published {res.published} (skipped {res.skipped} already present, "
+          f"{res.entries} entries)")
+    return 0
+
+
+def _cmd_audit(args) -> int:
+    rep = audit.run(storage=args.storage, noosphere=args.noosphere,
+                    instance=(args.instance or None))
+    if not rep.peers and not rep.rejected_bundles:
+        print("no peer records found")
+        return 0
+    for p in rep.peers:
+        max_level = max((t.trust_level for t in p.tools), default=1)
+        print(f"{p.origin_label} [{p.origin_instance_id[:8]}]  {p.verdict}  "
+              f"acc {round(100 * p.overall_accuracy)}% over {p.attempts}  "
+              f"L{max_level}  quarantines {len(p.quarantined_goals)}  "
+              f"RED {p.executed_after_fail} / YELLOW {p.executed_unaudited}")
+    if rep.rejected_bundles:
+        print("rejected bundles:")
+        for origin, label, reason in rep.rejected_bundles:
+            print(f"  {label} [{origin[:8]}]  {reason}")
+    return 0
+
+
 def main(argv: list[str]) -> int:
     parser = _build_parser()
     try:                                  # argparse calls sys.exit on bad args
@@ -129,7 +168,8 @@ def main(argv: list[str]) -> int:
     except SystemExit as exc:
         return int(exc.code) if exc.code is not None else 0
     dispatch = {"publish": _cmd_publish, "import": _cmd_import,
-                "list": _cmd_list, "show": _cmd_show, "id": _cmd_id}
+                "list": _cmd_list, "show": _cmd_show, "id": _cmd_id,
+                "publish-record": _cmd_publish_record, "audit": _cmd_audit}
     handler = dispatch.get(args.cmd)
     if handler is None:
         parser.print_help()

conscio-2.2.1/conscio/noosphere/record.py

@@ -0,0 +1,79 @@
+# conscio/noosphere/record.py
+"""Behavioral bundle artifact — a minimal, non-sensitive projection of an
+instance's action ledger. The content body is hashed via
+artifact.canonical_bytes / content_hash (same convention as the skill
+artifact). Carries ONLY {seq, ts, goal_fp, tool, tier, status, ok, verdict};
+never args/output/error/rationale/goal_text (privacy by column omission)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+BUNDLE_SCHEMA = 1
+
+_VALID_STATUS = frozenset(
+    {"proposed", "executing", "executed", "rejected", "failed", "locked"})
+
+
+@dataclass(frozen=True)
+class RecordEntry:
+    seq: int
+    ts: float
+    goal_fp: str
+    tool: str
+    tier: str
+    status: str
+    ok: int | None
+    verdict: str
+
+
+def build_bundle_body(entries: list[RecordEntry]) -> dict:
+    return {
+        "schema_version": BUNDLE_SCHEMA,
+        "entries": [
+            {"seq": e.seq, "ts": e.ts, "goal_fp": e.goal_fp, "tool": e.tool,
+             "tier": e.tier, "status": e.status, "ok": e.ok,
+             "verdict": e.verdict}
+            for e in entries],
+    }
+
+
+def _is_int(v: object) -> bool:
+    return isinstance(v, int) and not isinstance(v, bool)
+
+
+def _well_typed_entry(d: object) -> bool:
+    if not isinstance(d, dict):
+        return False
+    if not _is_int(d.get("seq")):
+        return False
+    ts = d.get("ts")
+    if not ((isinstance(ts, (int, float)) and not isinstance(ts, bool))):
+        return False
+    if not (isinstance(d.get("goal_fp"), str) and d["goal_fp"]):
+        return False
+    if not (isinstance(d.get("tool"), str) and isinstance(d.get("tier"), str)
+            and isinstance(d.get("verdict"), str)):
+        return False
+    if d.get("status") not in _VALID_STATUS:
+        return False
+    ok = d.get("ok")
+    if ok is not None and not (ok in (0, 1) and not isinstance(ok, bool)):
+        return False
+    return True
+
+
+def well_typed_bundle(body: object) -> bool:
+    if not isinstance(body, dict) or not isinstance(body.get("entries"), list):
+        return False
+    return all(_well_typed_entry(e) for e in body["entries"])
+
+
+def entries_from_body(body: dict) -> list[RecordEntry]:
+    out: list[RecordEntry] = []
+    for d in body["entries"]:
+        out.append(RecordEntry(
+            seq=int(d["seq"]), ts=float(d["ts"]), goal_fp=str(d["goal_fp"]),
+            tool=str(d["tool"]), tier=str(d["tier"]), status=str(d["status"]),
+            ok=(None if d["ok"] is None else int(d["ok"])),
+            verdict=str(d["verdict"])))
+    return out

conscio-2.2.1/conscio/noosphere/record_catalog.py

@@ -0,0 +1,126 @@
+# conscio/noosphere/record_catalog.py
+"""Host-shared noosphere.db — catalog of published behavioral bundles. Lives
+alongside published_skills in the SAME shared db. PK (origin_instance_id,
+content_sha256); ON CONFLICT DO NOTHING (idempotent snapshots). WAL +
+busy_timeout for concurrent same-host writers."""
+from __future__ import annotations
+
+import sqlite3
+from dataclasses import dataclass
+from pathlib import Path
+
+BUSY_TIMEOUT_MS = 5000
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS published_records (
+    origin_instance_id TEXT NOT NULL,
+    origin_label       TEXT NOT NULL,
+    published_ts       REAL NOT NULL,
+    content_sha256     TEXT NOT NULL,
+    entry_count        INTEGER NOT NULL,
+    window_first_ts    REAL NOT NULL DEFAULT 0,
+    window_last_ts     REAL NOT NULL DEFAULT 0,
+    bundle_json        BLOB NOT NULL,
+    schema_version     INTEGER NOT NULL DEFAULT 1,
+    PRIMARY KEY (origin_instance_id, content_sha256)
+);
+CREATE INDEX IF NOT EXISTS idx_rec_origin
+    ON published_records(origin_instance_id, published_ts);
+"""
+
+
+@dataclass(frozen=True)
+class RecordRow:
+    origin_instance_id: str
+    origin_label: str
+    published_ts: float
+    content_sha256: str
+    entry_count: int
+    window_first_ts: float
+    window_last_ts: float
+    bundle_json: bytes
+    schema_version: int
+
+
+def _connect(db: Path) -> sqlite3.Connection:
+    conn = sqlite3.connect(str(db))
+    conn.row_factory = sqlite3.Row
+    conn.execute(f"PRAGMA busy_timeout={BUSY_TIMEOUT_MS}")
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.executescript(_SCHEMA)
+    return conn
+
+
+def _as_bytes(value: object) -> bytes:
+    """Coerce a stored bundle_json cell to bytes. Normally a BLOB, but a
+    tampered/edited row may have been coerced to TEXT (e.g. via SQLite ||);
+    return its bytes so revalidation can hash it and reject (not crash)."""
+    if isinstance(value, (bytes, bytearray)):
+        return bytes(value)
+    if isinstance(value, memoryview):
+        return value.tobytes()
+    if isinstance(value, str):
+        return value.encode("utf-8")
+    raise TypeError(f"unexpected bundle_json cell type: {type(value).__name__}")
+
+
+def _row(r: sqlite3.Row) -> RecordRow:
+    return RecordRow(
+        origin_instance_id=r["origin_instance_id"], origin_label=r["origin_label"],
+        published_ts=r["published_ts"], content_sha256=r["content_sha256"],
+        entry_count=r["entry_count"], window_first_ts=r["window_first_ts"],
+        window_last_ts=r["window_last_ts"],
+        bundle_json=_as_bytes(r["bundle_json"]), schema_version=r["schema_version"])
+
+
+def publish_rows(db: Path, rows: list[RecordRow]) -> int:
+    db = Path(db)
+    db.parent.mkdir(parents=True, exist_ok=True)
+    conn = _connect(db)
+    inserted = 0
+    try:
+        for r in rows:
+            cur = conn.execute(
+                "INSERT INTO published_records (origin_instance_id, origin_label,"
+                " published_ts, content_sha256, entry_count, window_first_ts,"
+                " window_last_ts, bundle_json, schema_version)"
+                " VALUES (?,?,?,?,?,?,?,?,?)"
+                " ON CONFLICT(origin_instance_id, content_sha256) DO NOTHING",
+                (r.origin_instance_id, r.origin_label, r.published_ts,
+                 r.content_sha256, r.entry_count, r.window_first_ts,
+                 r.window_last_ts, sqlite3.Binary(r.bundle_json), r.schema_version))
+            inserted += cur.rowcount
+        conn.commit()
+    finally:
+        conn.close()
+    return inserted
+
+
+def read_foreign(db: Path, *, exclude_instance_id: str) -> list[RecordRow]:
+    db = Path(db)
+    if not db.exists():
+        return []
+    conn = _connect(db)
+    try:
+        rows = conn.execute(
+            "SELECT * FROM published_records WHERE origin_instance_id != ?"
+            " ORDER BY origin_instance_id, published_ts",
+            (exclude_instance_id,)).fetchall()
+    finally:
+        conn.close()
+    return [_row(r) for r in rows]
+
+
+def get(db: Path, origin_instance_id: str, content_sha256: str) -> RecordRow | None:
+    db = Path(db)
+    if not db.exists():
+        return None
+    conn = _connect(db)
+    try:
+        r = conn.execute(
+            "SELECT * FROM published_records"
+            " WHERE origin_instance_id=? AND content_sha256=?",
+            (origin_instance_id, content_sha256)).fetchone()
+    finally:
+        conn.close()
+    return _row(r) if r else None