conscio 2.2.1__tar.gz → 2.3.0__tar.gz

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

@@ -7,6 +7,52 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [2.3.0] - 2026-06-23 — "Promotion"
+
+### Added
+- **Promotion-to-live.** `conscio promote --storage DIR --quarantine ROWID
+  --enable-promote` graduates a quarantined foreign skill that has earned
+  **≥ 3 clean local trials** (v2.2.2) into the live `SkillLibrary`, seeded with
+  the counters it earned **locally** in the sandbox — never the origin's
+  (stripped) stats, so no trust is inherited. Engine-side
+  (`engine.promote_quarantined`); the noosphere package stays engine-free and
+  read-only on `conscio.db`.
+- **Tool-existence check** (deferred from v2.2). Promotion refuses a skill
+  whose plan names a tool this instance's live registry does not have.
+- `SkillLibrary.graft` — the single foreign-skill write seam
+  (`ON CONFLICT(goal_fp, tool_seq) DO NOTHING`; never overwrites a local skill).
+- Quarantine rows gain `promoted_ts` / `promoted_skill_id` (idempotency +
+  audit). Promotion re-checks the content hash (tamper → refuse, no write) and
+  is idempotent. `--enable-promote` is required, default off, and **independent
+  of** `--enable-trial` / `--enable-act`.
+
+---
+
+## [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.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conscio
-Version: 2.2.1
+Version: 2.3.0
 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.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.3.0` — "Promotion": a quarantined skill that has earned **≥ 3 clean local trials** can now be **graduated into the live skill library**. `conscio promote --quarantine ROWID --enable-promote` re-checks the content hash, verifies every tool in the plan exists locally (**tool-existence check**), and grafts the skill seeded with the counters it earned in the sandbox — **never the origin's stats**, so no trust is inherited. Engine-side write; the noosphere stays engine-free and read-only on `conscio.db`. Never overwrites a local skill; idempotent; off by default and independent of `--enable-trial`/`--enable-act`. `pip install conscio`.
+- **Prior:** `v2.2.2` — "Trial / execution path": a quarantined imported skill can **prove itself locally** before promotion — `conscio trial --quarantine ROWID --enable-trial` replays the fixed foreign plan 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`.
+- **Earlier:** `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.3.0}/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.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.3.0` — "Promotion": a quarantined skill that has earned **≥ 3 clean local trials** can now be **graduated into the live skill library**. `conscio promote --quarantine ROWID --enable-promote` re-checks the content hash, verifies every tool in the plan exists locally (**tool-existence check**), and grafts the skill seeded with the counters it earned in the sandbox — **never the origin's stats**, so no trust is inherited. Engine-side write; the noosphere stays engine-free and read-only on `conscio.db`. Never overwrites a local skill; idempotent; off by default and independent of `--enable-trial`/`--enable-act`. `pip install conscio`.
+- **Prior:** `v2.2.2` — "Trial / execution path": a quarantined imported skill can **prove itself locally** before promotion — `conscio trial --quarantine ROWID --enable-trial` replays the fixed foreign plan 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`.
+- **Earlier:** `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.3.0}/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.3.0"
 __author__ = "Neguiolidas / Neguitech"
 
 from .engine import ConsciousnessEngine

conscio-2.3.0/conscio/agency/promote.py

@@ -0,0 +1,55 @@
+# conscio/agency/promote.py
+"""Promotion gate for a quarantined foreign skill (v2.3.0).
+
+A pure mechanic: given a quarantined row's trial counters and tool sequence,
+decide whether it has earned graduation into the live SkillLibrary. Imports
+nothing from conscio.noosphere or conscio.engine. The caller (the engine) owns
+the read of the quarantine row, the graft into the library, and the
+promoted-stamp; this module only judges."""
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any
+
+MIN_PROMOTE_PASSES = 3   # clean local trials required before graduation
+
+
+@dataclass(frozen=True)
+class PromoteResult:
+    skill_id: int
+    successes: int
+    failures: int
+
+
+@dataclass(frozen=True)
+class PromoteRefusal:
+    reason: str
+
+
+@dataclass(frozen=True)
+class PromoteDecision:
+    ok: bool
+    reason: str            # "" when ok
+
+
+def evaluate_promotion(*, trial_successes: int, trial_failures: int,
+                       tool_seq: str, registry: Any) -> PromoteDecision:
+    """Gate a quarantined row for promotion. Order: enough clean passes, zero
+    failures, decodable tool_seq, every tool present in the live registry."""
+    if trial_successes < MIN_PROMOTE_PASSES:
+        return PromoteDecision(
+            False,
+            f"insufficient trials ({trial_successes}/{MIN_PROMOTE_PASSES})")
+    if trial_failures != 0:
+        return PromoteDecision(False, f"failed {trial_failures} trial(s)")
+    try:
+        tools = json.loads(tool_seq)
+        if not isinstance(tools, list):
+            raise ValueError("tool_seq is not a list")
+    except (ValueError, TypeError) as exc:
+        return PromoteDecision(False, f"corrupt tool_seq: {exc}")
+    for tool in tools:
+        if registry.get(str(tool)) is None:
+            return PromoteDecision(False, f"unknown tool '{tool}'")
+    return PromoteDecision(True, "")

{conscio-2.2.1 → conscio-2.3.0}/conscio/agency/skills.py

@@ -166,6 +166,26 @@ class SkillLibrary:
             [(skill_id,) for skill_id in served])
         self._conn.commit()
 
+    # ── promotion (v2.3) ────────────────────────────────────────────────
+
+    def graft(self, goal_fp: str, goal_text: str, tool_seq: str,
+              plan_template: str, *, successes: int,
+              failures: int) -> int | None:
+        """Insert a promoted foreign skill as data, seeded with the trial
+        counters it earned locally. The single write seam for foreign skills.
+        Never overwrites a local skill sharing (goal_fp, tool_seq): a collision
+        returns None."""
+        cur = self._conn.execute(
+            "INSERT INTO skills (created_ts, goal_fp, goal_text, tool_seq,"
+            " plan_template, successes, failures) VALUES (?, ?, ?, ?, ?, ?, ?)"
+            " ON CONFLICT(goal_fp, tool_seq) DO NOTHING",
+            (time.time(), goal_fp, goal_text, tool_seq, plan_template,
+             successes, failures))
+        self._conn.commit()
+        if cur.rowcount == 0 or cur.lastrowid is None:
+            return None
+        return int(cur.lastrowid)
+
     # ── rendering ──────────────────────────────────────────────────────
 
     @staticmethod

conscio-2.3.0/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.3.0}/conscio/cli.py

@@ -68,6 +68,30 @@ 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)")
+
+    p_promote = sub.add_parser(
+        "promote",
+        help="promote a trialed quarantined skill into the live library")
+    p_promote.add_argument("--storage", default="",
+                           help="instance storage dir (default: ~/.hermes)")
+    p_promote.add_argument("--quarantine", type=int, required=True,
+                           metavar="ROWID",
+                           help="quarantine row id to promote")
+    p_promote.add_argument(
+        "--enable-promote", action="store_true",
+        help="required: actually write to the live library (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 +255,85 @@ 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 _run_promote(*, storage: str, quarantine_id: int, enable_promote: bool):
+    """Build a bare engine (no adapter — promotion never decodes) and promote
+    one quarantined skill. The single seam the CLI tests monkeypatch."""
+    from .engine import ConsciousnessEngine
+    eng = ConsciousnessEngine(model_name=DEFAULT_MODEL,
+                              storage_path=_storage(storage))
+    try:
+        return eng.promote_quarantined(quarantine_id,
+                                       enable_promote=enable_promote)
+    finally:
+        eng.close()
+
+
+def _cmd_promote(storage: str, quarantine_id: int,
+                 enable_promote: bool) -> int:
+    from .agency.promote import PromoteResult
+    try:
+        outcome = _run_promote(storage=storage, quarantine_id=quarantine_id,
+                               enable_promote=enable_promote)
+    except Exception as exc:               # engine wiring failure
+        print(f"error: {exc}")
+        return 1
+    if isinstance(outcome, PromoteResult):
+        print(f"PROMOTED skill #{outcome.skill_id} "
+              f"(seeded {outcome.successes}/{outcome.failures})")
+        return 0
+    print(f"PROMOTE REFUSED: {outcome.reason}")
+    return 1
+
+
 def main(argv: list[str] | None = None) -> int:
     argv = list(sys.argv[1:] if argv is None else argv)
 
@@ -266,6 +369,12 @@ 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)
+    if args.command == "promote":
+        return _cmd_promote(args.storage, args.quarantine,
+                            args.enable_promote)
 
     parser.print_help()
     return 2

{conscio-2.2.1 → conscio-2.3.0}/conscio/engine.py

@@ -1001,6 +1001,142 @@ 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.3 "Promotion": graduate a quarantined skill into the library ---
+
+    def promote_quarantined(self, rowid: int, *, enable_promote: bool = False):
+        """Graduate a quarantined foreign skill that has earned >= 3 clean
+        local trials into the live SkillLibrary, seeded with its trial
+        counters. No adapter, no sandbox, no execution: a data gate that reads
+        the trial evidence and writes one row. Default off.
+
+        Unlike trial (which records a tamper via note_trial), promotion refuses
+        a tampered/already-promoted/gate-failed row WITHOUT writing anything —
+        it only ever writes on a successful graft (the skills row + the
+        promoted-stamp). A refusal leaves the quarantine row untouched.
+
+        Returns a promote.PromoteResult (promoted) or promote.PromoteRefusal."""
+        import time
+
+        from .agency import promote as promote_mod
+        from .agency.skills import SkillLibrary
+        from .agency.tools import make_default_registry
+        from .noosphere import artifact, quarantine
+        from .noosphere.paths import quarantine_db_path
+
+        if not enable_promote:
+            return promote_mod.PromoteRefusal(
+                "promotion disabled; pass --enable-promote")
+
+        qdb = quarantine_db_path(self.storage)
+        row = quarantine.get(qdb, rowid)
+        if row is None:
+            return promote_mod.PromoteRefusal(f"no quarantine row #{rowid}")
+        if row.import_status != "quarantined":
+            return promote_mod.PromoteRefusal(
+                f"row #{rowid} is not quarantined "
+                f"(status={row.import_status})")
+        if row.promoted_ts > 0:
+            return promote_mod.PromoteRefusal(
+                f"row #{rowid} already promoted "
+                f"(skill #{row.promoted_skill_id})")
+        if artifact.content_hash(row.artifact_json) != row.content_sha256:
+            return promote_mod.PromoteRefusal(
+                f"row #{rowid} tampered (content_sha256 mismatch)")
+
+        # Live tool registry, real backends. Used ONLY for registry.get(tool)
+        # existence checks — nothing is dispatched, so no tmpdir is needed (the
+        # one structural difference from trial). make_default_registry mkdirs
+        # sandbox_root, so it points inside the instance storage (never real
+        # home), keeping promotion and its tests side-effect-clean.
+        reg = make_default_registry(
+            sandbox_root=self.storage / "sandbox",
+            content_store=self.content_store, event_bus=self.event_bus,
+            goal_generator=self.goals)
+        decision = promote_mod.evaluate_promotion(
+            trial_successes=row.trial_successes,
+            trial_failures=row.trial_failures,
+            tool_seq=row.tool_seq, registry=reg)
+        if not decision.ok:
+            return promote_mod.PromoteRefusal(decision.reason)
+
+        lib = SkillLibrary(self.storage / "conscio.db")
+        try:
+            sid = lib.graft(row.goal_fp, row.goal_text, row.tool_seq,
+                            row.plan_template, successes=row.trial_successes,
+                            failures=row.trial_failures)
+        finally:
+            lib.close()
+        if sid is None:
+            return promote_mod.PromoteRefusal(
+                "skill already present (goal_fp, tool_seq collision)")
+
+        quarantine.mark_promoted(qdb, rowid, ts=time.time(), skill_id=sid)
+        return promote_mod.PromoteResult(sid, row.trial_successes,
+                                         row.trial_failures)
+
     # --- v2.0 "Connect": propose-only cognition (never executes) ---
 
     def propose_action(self, intent: dict) -> dict: