conscio 2.2.1__tar.gz → 2.2.2__tar.gz

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

@@ -7,6 +7,31 @@ 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conscio
-Version: 2.2.1
+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,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.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.
+- **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.1 → conscio-2.2.2}/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.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.
+- **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.1 → 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.1"
+__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.1 → 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.1 → 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.1 → conscio-2.2.2}/conscio/noosphere/quarantine.py

@@ -28,10 +28,33 @@ CREATE TABLE IF NOT EXISTS quarantine (
     revalidation_result  TEXT NOT NULL,
     revalidation_error   TEXT NOT NULL DEFAULT '',
     schema_version       INTEGER NOT NULL DEFAULT 1,
+    trial_successes      INTEGER NOT NULL DEFAULT 0,
+    trial_failures       INTEGER NOT NULL DEFAULT 0,
+    last_trial_ts        REAL NOT NULL DEFAULT 0,
+    last_trial_result    TEXT NOT NULL DEFAULT '',
+    last_trial_error     TEXT NOT NULL DEFAULT '',
     UNIQUE(origin_instance_id, content_sha256)
 );
 """
 
+# v2.2.2: trial-stats columns added to pre-existing DBs via _migrate.
+_TRIAL_COLS = {
+    "trial_successes": "INTEGER NOT NULL DEFAULT 0",
+    "trial_failures": "INTEGER NOT NULL DEFAULT 0",
+    "last_trial_ts": "REAL NOT NULL DEFAULT 0",
+    "last_trial_result": "TEXT NOT NULL DEFAULT ''",
+    "last_trial_error": "TEXT NOT NULL DEFAULT ''",
+}
+
+
+def _migrate(conn: sqlite3.Connection) -> None:
+    """Idempotent ADD COLUMN for pre-v2.2.2 DBs. SQLite has no ADD COLUMN IF
+    NOT EXISTS, so guard with PRAGMA table_info."""
+    have = {r["name"] for r in conn.execute("PRAGMA table_info(quarantine)")}
+    for col, decl in _TRIAL_COLS.items():
+        if col not in have:
+            conn.execute(f"ALTER TABLE quarantine ADD COLUMN {col} {decl}")
+
 
 @dataclass(frozen=True)
 class QuarantineRow:
@@ -50,6 +73,11 @@ class QuarantineRow:
     revalidation_result: str
     revalidation_error: str
     schema_version: int
+    trial_successes: int = 0
+    trial_failures: int = 0
+    last_trial_ts: float = 0.0
+    last_trial_result: str = ""
+    last_trial_error: str = ""
     id: int | None = None
 
 
@@ -61,6 +89,7 @@ def _connect(db: Path) -> sqlite3.Connection:
     conn.execute(f"PRAGMA busy_timeout={BUSY_TIMEOUT_MS}")
     conn.execute("PRAGMA journal_mode=WAL")
     conn.executescript(_SCHEMA)
+    _migrate(conn)
     return conn
 
 
@@ -84,7 +113,10 @@ def _row(r: sqlite3.Row) -> QuarantineRow:
         tool_seq=r["tool_seq"], plan_template=r["plan_template"],
         artifact_json=_as_bytes(r["artifact_json"]), import_status=r["import_status"],
         revalidation_result=r["revalidation_result"],
-        revalidation_error=r["revalidation_error"], schema_version=r["schema_version"])
+        revalidation_error=r["revalidation_error"], schema_version=r["schema_version"],
+        trial_successes=r["trial_successes"], trial_failures=r["trial_failures"],
+        last_trial_ts=r["last_trial_ts"], last_trial_result=r["last_trial_result"],
+        last_trial_error=r["last_trial_error"])
 
 
 def insert(db: Path, row: QuarantineRow) -> bool:
@@ -130,3 +162,37 @@ def get(db: Path, rowid: int) -> QuarantineRow | None:
     finally:
         conn.close()
     return _row(r) if r else None
+
+
+def record_trial(db: Path, rowid: int, *, passed: bool, result: str,
+                 error: str, ts: float) -> bool:
+    """Bump one trial counter and set the last_trial_* fields. Returns True
+    iff a row was updated. `col` is from a fixed internal set — never user
+    input — so the f-string carries no injection surface."""
+    col = "trial_successes" if passed else "trial_failures"
+    conn = _connect(db)
+    try:
+        cur = conn.execute(
+            f"UPDATE quarantine SET {col} = {col} + 1, last_trial_ts = ?,"
+            " last_trial_result = ?, last_trial_error = ? WHERE id = ?",
+            (ts, result, error, rowid))
+        conn.commit()
+        return cur.rowcount > 0
+    finally:
+        conn.close()
+
+
+def note_trial(db: Path, rowid: int, *, result: str, error: str,
+               ts: float) -> bool:
+    """Record a non-counting trial note (refusal / tamper). Returns True iff a
+    row was updated. Never touches the success/failure counters."""
+    conn = _connect(db)
+    try:
+        cur = conn.execute(
+            "UPDATE quarantine SET last_trial_ts = ?, last_trial_result = ?,"
+            " last_trial_error = ? WHERE id = ?",
+            (ts, result, error, rowid))
+        conn.commit()
+        return cur.rowcount > 0
+    finally:
+        conn.close()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conscio
-Version: 2.2.1
+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,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.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.
+- **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.1 → conscio-2.2.2}/conscio.egg-info/SOURCES.txt

@@ -66,6 +66,7 @@ conscio/agency/profiles.py
 conscio/agency/skeptic.py
 conscio/agency/skills.py
 conscio/agency/tools.py
+conscio/agency/trial.py
 conscio/agency/trust.py
 conscio/hub/__init__.py
 conscio/hub/config.py
@@ -126,6 +127,7 @@ tests/test_agency_skills_wiring.py
 tests/test_agency_state.py
 tests/test_agency_tools.py
 tests/test_agency_tools_manifest.py
+tests/test_agency_trial.py
 tests/test_agency_trust.py
 tests/test_agency_volition.py
 tests/test_agent_sensor.py
@@ -134,6 +136,7 @@ tests/test_awake.py
 tests/test_axis_pack.py
 tests/test_axis_pack_battery.py
 tests/test_cli.py
+tests/test_cli_trial.py
 tests/test_coherence.py
 tests/test_coherence_engine_integration.py
 tests/test_coherence_state.py
@@ -162,6 +165,7 @@ tests/test_engine_init.py
 tests/test_engine_meta_reflect.py
 tests/test_engine_propose.py
 tests/test_engine_recall.py
+tests/test_engine_trial.py
 tests/test_event_bus.py
 tests/test_event_bus_act_result.py
 tests/test_event_bus_purge.py
@@ -212,6 +216,7 @@ tests/test_packaging.py
 tests/test_perception.py
 tests/test_perf_reflection.py
 tests/test_plugins.py
+tests/test_quarantine_trial.py
 tests/test_recursive_loop_integration.py
 tests/test_risk.py
 tests/test_self_prompt.py

conscio-2.2.2/tests/test_agency_trial.py

@@ -0,0 +1,107 @@
+# tests/test_agency_trial.py
+from pathlib import Path
+
+from conscio.agency import trial
+from conscio.agency.contracts import AuditVerdict
+from conscio.agency.tools import Risk, make_default_registry
+
+
+class _Skeptic:
+    """Stub: PASS unless told to FAIL; records every audited tool."""
+    def __init__(self, ok=True):
+        self.ok = ok
+        self.seen = []
+
+    def audit(self, proposal, *, goal_text):
+        self.seen.append(proposal.tool)
+        return AuditVerdict(verdict="PASS" if self.ok else "FAIL",
+                            reasons=[] if self.ok else ["nope"])
+
+
+def _fs_registry(tmp):
+    return make_default_registry(sandbox_root=tmp, content_store=None,
+                                 event_bus=None, goal_generator=None)
+
+
+def test_self_contained_plan_passes(tmp_path):
+    reg = _fs_registry(tmp_path)
+    steps = [
+        {"tool": "fs_write", "args": {"path": "t.txt", "content": "hi"},
+         "rationale": "write"},
+        {"tool": "fs_read", "args": {"path": "t.txt"}, "rationale": "read"},
+    ]
+    out = trial.run_trial(steps, goal_text="demo",
+                          skeptic=_Skeptic(ok=True), registry=reg)
+    assert out.passed is True and out.result == "passed"
+    assert [s.stage for s in out.steps] == ["ok", "ok"]
+
+
+def test_unknown_tool_fails_and_stops(tmp_path):
+    reg = _fs_registry(tmp_path)
+    spy = _Skeptic(ok=True)
+    steps = [{"tool": "nope", "args": {}, "rationale": ""},
+             {"tool": "fs_write", "args": {"path": "x", "content": "y"},
+              "rationale": ""}]
+    out = trial.run_trial(steps, goal_text="g", skeptic=spy, registry=reg)
+    assert out.passed is False and out.result == "unknown_tool:nope"
+    assert len(out.steps) == 1                # stopped at step 1
+    assert spy.seen == []                     # skeptic never reached
+
+
+def test_invalid_args_fails(tmp_path):
+    reg = _fs_registry(tmp_path)
+    steps = [{"tool": "fs_write", "args": {"path": "x"}, "rationale": ""}]
+    out = trial.run_trial(steps, goal_text="g", skeptic=_Skeptic(),
+                          registry=reg)
+    assert out.passed is False and out.result == "invalid_args:fs_write"
+
+
+def test_precheck_sandbox_escape_fails(tmp_path):
+    reg = _fs_registry(tmp_path)
+    steps = [{"tool": "fs_write",
+              "args": {"path": "../escape.txt", "content": "x"},
+              "rationale": ""}]
+    out = trial.run_trial(steps, goal_text="g", skeptic=_Skeptic(),
+                          registry=reg)
+    assert out.passed is False and out.result == "precheck:fs_write"
+
+
+def test_skeptic_reject_fails_without_dispatch(tmp_path):
+    reg = _fs_registry(tmp_path)
+    steps = [{"tool": "fs_write", "args": {"path": "t.txt", "content": "x"},
+              "rationale": ""}]
+    out = trial.run_trial(steps, goal_text="g", skeptic=_Skeptic(ok=False),
+                          registry=reg)
+    assert out.passed is False and out.result == "skeptic_reject:fs_write"
+    # dispatch never ran -> the sandbox file must not exist
+    assert not (Path(tmp_path) / "t.txt").exists()
+
+
+def test_exec_fail_on_missing_read(tmp_path):
+    reg = _fs_registry(tmp_path)
+    steps = [{"tool": "fs_read", "args": {"path": "absent.txt"},
+              "rationale": ""}]
+    out = trial.run_trial(steps, goal_text="g", skeptic=_Skeptic(),
+                          registry=reg)
+    assert out.passed is False and out.result == "exec_fail:fs_read"
+
+
+def test_high_risk_blocked_without_dispatch():
+    # Inject a registry whose tool is HIGH risk; the rule must block it
+    # before dispatch regardless of registry contents.
+    from conscio.agency.tools import ToolRegistry
+    reg = ToolRegistry()
+    dispatched = []
+    reg.register("danger", lambda **kw: dispatched.append(kw) or "x",
+                 params={}, risk=Risk.HIGH, description="d")
+    out = trial.run_trial([{"tool": "danger", "args": {}, "rationale": ""}],
+                          goal_text="g", skeptic=_Skeptic(), registry=reg)
+    assert out.passed is False and out.result == "high_risk_blocked:danger"
+    assert dispatched == []                    # never executed
+
+
+def test_empty_plan_fails():
+    from conscio.agency.tools import ToolRegistry
+    out = trial.run_trial([], goal_text="g", skeptic=_Skeptic(),
+                          registry=ToolRegistry())
+    assert out.passed is False