conscio 2.2.0__tar.gz → 2.2.2__tar.gz

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

@@ -7,6 +7,46 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [2.2.2] - 2026-06-22 — "Trial / execution path"
+
+### Added
+- **Sandboxed trial of a quarantined skill.** A quarantined imported skill can
+  now be replayed in a **throwaway, fs-only sandbox** to earn local,
+  execution-grade pass/fail stats — `conscio trial --storage DIR --quarantine
+  ROWID --model NAME --enable-trial`. The foreign plan's fixed steps run through
+  the full safety stack (`validate → precheck → HIGH-block → Skeptic → dispatch`)
+  against a `make_default_registry` confined to a `mkdtemp` dir (`fs_read`/
+  `fs_write` only), stopping at the first failure. Binary outcome
+  (`trial_successes`/`trial_failures` + `last_trial_*`) is recorded on the
+  quarantine row; v2.3 promotion will read it.
+- **Trial isolation.** A trial never writes the agent's `ActionLedger`, `skills`
+  table, `TrustMatrix`, or trips the breaker — a foreign skill's failure cannot
+  dent the local agent. The sandbox dir is always removed; tamper / corrupt-plan
+  refuse **without** bumping any counter.
+- **Opt-in, default off.** `--enable-trial` is required to dispatch and is
+  independent of `--enable-act` (trial uses the local sandboxed registry, never
+  `host_act`). Skeptic always audits foreign content (no LOW-risk fast path).
+- New engine method `ConsciousnessEngine.trial_quarantined(rowid, *,
+  enable_trial=False)`; new `conscio/agency/trial.py` (engine-side mechanic,
+  imports nothing from `noosphere`); `noosphere/quarantine.py` gains 5 trial
+  columns + an idempotent `PRAGMA table_info` migration + `record_trial` /
+  `note_trial` (still engine-free). Purely additive; cognition untouched.
+
+## [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.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conscio
-Version: 2.2.0
+Version: 2.2.2
 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,10 @@ 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.2` — "Trial / execution path": a quarantined imported skill can now **prove itself locally** before any promotion. `conscio trial --quarantine ROWID --enable-trial` replays the foreign plan's fixed steps in a **throwaway, fs-only sandbox** through the full safety stack (`validate → precheck → HIGH-block → Skeptic → dispatch`), recording a binary pass/fail on the quarantine row. Fully **isolated** — never writes the live agent's ledger/skills/trust/breaker; tamper refuses without counting. Off by default; independent of `--enable-act`. `pip install conscio`.
+- **Prior:** `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.
+- **Earlier:** `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.2}/README.md

@@ -11,8 +11,10 @@ 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.2` — "Trial / execution path": a quarantined imported skill can now **prove itself locally** before any promotion. `conscio trial --quarantine ROWID --enable-trial` replays the foreign plan's fixed steps in a **throwaway, fs-only sandbox** through the full safety stack (`validate → precheck → HIGH-block → Skeptic → dispatch`), recording a binary pass/fail on the quarantine row. Fully **isolated** — never writes the live agent's ledger/skills/trust/breaker; tamper refuses without counting. Off by default; independent of `--enable-act`. `pip install conscio`.
+- **Prior:** `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.
+- **Earlier:** `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.2}/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.2"
 __author__ = "Neguiolidas / Neguitech"
 
 from .engine import ConsciousnessEngine

conscio-2.2.2/conscio/agency/trial.py

@@ -0,0 +1,97 @@
+# conscio/agency/trial.py
+"""Trial replay of a quarantined foreign skill (v2.2.2).
+
+A pure mechanic: replay fixed foreign plan steps through the existing safety
+stack (validate -> precheck -> HIGH-block -> Skeptic -> dispatch) against an
+INJECTED sandboxed registry, stopping at the first failure. Records nothing,
+imports nothing from conscio.noosphere or conscio.engine. The caller (the
+engine) owns the sandbox lifecycle, the tamper guard, and persistence, and
+guarantees trial isolation (no agent ledger/skills/trust/breaker writes)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from .contracts import ActionProposal, validate
+from .tools import Risk
+
+# stage -> the word used in TrialOutcome.result
+_RESULT_WORD = {
+    "unknown_tool": "unknown_tool",
+    "invalid_args": "invalid_args",
+    "precheck": "precheck",
+    "high_risk": "high_risk_blocked",
+    "skeptic": "skeptic_reject",
+    "exec": "exec_fail",
+}
+
+
+@dataclass(frozen=True)
+class StepResult:
+    tool: str
+    ok: bool
+    stage: str        # unknown_tool|invalid_args|precheck|high_risk|skeptic|exec|ok
+    error: str = ""
+
+
+@dataclass(frozen=True)
+class TrialOutcome:
+    passed: bool
+    result: str           # "passed" or "<word>:<tool>"
+    error: str
+    steps: list[StepResult]   # always supplied explicitly by run_trial
+
+
+@dataclass(frozen=True)
+class TrialRefusal:
+    reason: str
+
+
+def run_trial(steps: list[dict], *, goal_text: str, skeptic: Any,
+              registry: Any) -> TrialOutcome:
+    done: list[StepResult] = []
+    for step in steps:
+        tool = str(step.get("tool", ""))
+        args = step.get("args", {})
+        rationale = str(step.get("rationale", ""))
+        # Foreign steps carry no expected_outcome; the Skeptic tolerates "".
+        proposal = ActionProposal(tool=tool, args=args, rationale=rationale,
+                                  expected_outcome="")
+        spec = registry.get(tool)
+        if spec is None:
+            done.append(StepResult(tool, False, "unknown_tool",
+                                   f"tool '{tool}' not registered"))
+            break
+        errs = (validate(args, spec.params) if isinstance(args, dict)
+                else ["args must be a dict"])
+        if errs:
+            done.append(StepResult(tool, False, "invalid_args",
+                                   "; ".join(errs)))
+            break
+        if spec.precheck is not None:
+            pre = spec.precheck(args)
+            if pre:
+                done.append(StepResult(tool, False, "precheck", str(pre)))
+                break
+        if spec.risk is Risk.HIGH:
+            done.append(StepResult(tool, False, "high_risk",
+                                   "HIGH-risk tool blocked in trial"))
+            break
+        verdict = skeptic.audit(proposal, goal_text=goal_text)   # forced audit
+        if not verdict.passed:
+            done.append(StepResult(tool, False, "skeptic",
+                                   "; ".join(verdict.reasons)))
+            break
+        res = registry.dispatch(tool, args)
+        if not res.ok:
+            done.append(StepResult(tool, False, "exec", res.error))
+            break
+        done.append(StepResult(tool, True, "ok"))
+
+    passed = bool(done) and len(done) == len(steps) and all(s.ok for s in done)
+    if passed:
+        return TrialOutcome(True, "passed", "", done)
+    last = done[-1] if done else StepResult("", False, "empty", "no steps")
+    word = _RESULT_WORD.get(last.stage, last.stage)
+    result = f"{word}:{last.tool}" if last.tool else word
+    return TrialOutcome(False, result, last.error, done)

{conscio-2.2.0 → conscio-2.2.2}/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.0 → conscio-2.2.2}/conscio/cli.py

@@ -68,6 +68,18 @@ def _build_parser() -> argparse.ArgumentParser:
     p_sleep.add_argument("--model", default=DEFAULT_MODEL)
     p_sleep.add_argument("--storage", default="", help="storage dir (default: temp)")
 
+    p_trial = sub.add_parser(
+        "trial",
+        help="trial a quarantined imported skill in a throwaway sandbox")
+    p_trial.add_argument("--storage", default="",
+                         help="instance storage dir (default: ~/.hermes)")
+    p_trial.add_argument("--quarantine", type=int, required=True,
+                         metavar="ROWID", help="quarantine row id to trial")
+    p_trial.add_argument("--model", default=DEFAULT_MODEL)
+    p_trial.add_argument(
+        "--enable-trial", action="store_true",
+        help="required: actually run the sandboxed trial (off by default)")
+
     # Listed for discoverability; routed to conscio.{bench,daemon} before argparse.
     sub.add_parser("bench", add_help=False,
                    help="measure an inference backend (see: conscio bench --help)")
@@ -231,6 +243,55 @@ def _cmd_structure(storage: str) -> int:
     return 0
 
 
+def _run_trial(*, model: str, storage: str, quarantine_id: int,
+               enable_trial: bool):
+    """Build an engine with an adapter and run one trial. The single seam the
+    CLI tests monkeypatch (so they never build a real adapter)."""
+    from .adapter_config import build_adapter_from_config, load_config
+    from .engine import ConsciousnessEngine
+    eng = ConsciousnessEngine(model_name=model, storage_path=_storage(storage))
+    try:
+        adapter, _ = build_adapter_from_config(load_config(),
+                                               fallback_model=model)
+        eng.attach_adapter(adapter)
+        return eng.trial_quarantined(quarantine_id, enable_trial=enable_trial)
+    finally:
+        eng.close()
+
+
+def _cmd_trial(model: str, storage: str, quarantine_id: int,
+               enable_trial: bool) -> int:
+    from .agency.trial import TrialRefusal
+    try:
+        outcome = _run_trial(model=model, storage=storage,
+                             quarantine_id=quarantine_id,
+                             enable_trial=enable_trial)
+    except Exception as exc:               # adapter build / engine wiring failure
+        print(f"error: {exc}")
+        return 1
+    if isinstance(outcome, TrialRefusal):
+        print(f"error: {outcome.reason}")
+        return 1
+    if outcome.passed:
+        print(f"TRIAL PASSED (#{quarantine_id})")
+    else:
+        print(f"TRIAL FAILED (#{quarantine_id}): {outcome.result}")
+        if outcome.error:
+            print(f"  {outcome.error}")
+    # best-effort: show the running counts (skipped if the row can't be read)
+    try:
+        from .noosphere import quarantine
+        from .noosphere.paths import quarantine_db_path
+        row = quarantine.get(quarantine_db_path(Path(_storage(storage))),
+                             quarantine_id)
+        if row is not None:
+            print(f"  trials: {row.trial_successes} passed / "
+                  f"{row.trial_failures} failed")
+    except Exception:
+        pass
+    return 0
+
+
 def main(argv: list[str] | None = None) -> int:
     argv = list(sys.argv[1:] if argv is None else argv)
 
@@ -266,6 +327,9 @@ def main(argv: list[str] | None = None) -> int:
         return _cmd_set_awake(args.model, args.storage, awake=True)
     if args.command == "sleep":
         return _cmd_set_awake(args.model, args.storage, awake=False)
+    if args.command == "trial":
+        return _cmd_trial(args.model, args.storage, args.quarantine,
+                          args.enable_trial)
 
     parser.print_help()
     return 2

{conscio-2.2.0 → conscio-2.2.2}/conscio/engine.py

@@ -1001,6 +1001,69 @@ class ConsciousnessEngine:
             return []
         return self._act_pipeline.ledger.pending(limit)
 
+    # --- v2.2.2 "Trial": sandboxed replay of a quarantined foreign skill ---
+
+    def trial_quarantined(self, rowid: int, *, enable_trial: bool = False):
+        """Replay a quarantined foreign skill in a throwaway fs-only sandbox
+        and record a binary pass/fail on its quarantine row. Fully isolated —
+        never writes the agent's ledger/skills/trust/breaker. Default off.
+
+        Returns a trial.TrialOutcome (ran) or trial.TrialRefusal (refused)."""
+        import json
+        import shutil
+        import tempfile
+        import time
+        from pathlib import Path
+
+        from .agency import trial as trial_mod
+        from .agency.tools import make_default_registry
+        from .noosphere import artifact, quarantine
+        from .noosphere.paths import quarantine_db_path
+
+        if not enable_trial:
+            return trial_mod.TrialRefusal("trial disabled; pass --enable-trial")
+        pipe = getattr(self, "_act_pipeline", None)
+        if pipe is None or getattr(pipe, "skeptic", None) is None:
+            return trial_mod.TrialRefusal("trial requires an adapter")
+
+        qdb = quarantine_db_path(self.storage)
+        row = quarantine.get(qdb, rowid)
+        if row is None:
+            return trial_mod.TrialRefusal(f"no quarantine row #{rowid}")
+        if row.import_status != "quarantined":
+            return trial_mod.TrialRefusal(
+                f"row #{rowid} is not quarantined (status={row.import_status})")
+        if artifact.content_hash(row.artifact_json) != row.content_sha256:
+            quarantine.note_trial(qdb, rowid, result="tampered",
+                                  error="content_sha256 mismatch",
+                                  ts=time.time())
+            return trial_mod.TrialRefusal(
+                f"row #{rowid} tampered (content_sha256 mismatch)")
+        try:
+            steps = json.loads(row.plan_template)
+            if not isinstance(steps, list):
+                raise ValueError("plan_template is not a list")
+        except (ValueError, TypeError) as exc:
+            quarantine.note_trial(qdb, rowid, result="corrupt_plan",
+                                  error=str(exc), ts=time.time())
+            return trial_mod.TrialRefusal(f"row #{rowid} has a corrupt plan")
+
+        tmp = tempfile.mkdtemp(prefix="conscio-trial-")
+        try:
+            reg = make_default_registry(
+                sandbox_root=Path(tmp), content_store=None, event_bus=None,
+                goal_generator=None)
+            outcome = trial_mod.run_trial(
+                steps, goal_text=row.goal_text, skeptic=pipe.skeptic,
+                registry=reg)
+        finally:
+            shutil.rmtree(tmp, ignore_errors=True)
+
+        quarantine.record_trial(qdb, rowid, passed=outcome.passed,
+                                result=outcome.result, error=outcome.error,
+                                ts=time.time())
+        return outcome
+
     # --- v2.0 "Connect": propose-only cognition (never executes) ---
 
     def propose_action(self, intent: dict) -> dict:

conscio-2.2.2/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))