conscio 2.2.2__tar.gz → 2.3.0__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conscio
-Version: 2.2.2
+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,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.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.
+- **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.

{conscio-2.2.2 → conscio-2.3.0}/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.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.
+- **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.

{conscio-2.2.2 → 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.2"
+__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.2 → 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.2.2 → conscio-2.3.0}/conscio/cli.py

@@ -80,6 +80,18 @@ def _build_parser() -> argparse.ArgumentParser:
         "--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)")
@@ -292,6 +304,36 @@ def _cmd_trial(model: str, storage: str, quarantine_id: int,
     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)
 
@@ -330,6 +372,9 @@ def main(argv: list[str] | None = None) -> int:
     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.2 → conscio-2.3.0}/conscio/engine.py

@@ -1064,6 +1064,79 @@ class ConsciousnessEngine:
                                 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:

{conscio-2.2.2 → conscio-2.3.0}/conscio/noosphere/quarantine.py

@@ -33,6 +33,8 @@ CREATE TABLE IF NOT EXISTS quarantine (
     last_trial_ts        REAL NOT NULL DEFAULT 0,
     last_trial_result    TEXT NOT NULL DEFAULT '',
     last_trial_error     TEXT NOT NULL DEFAULT '',
+    promoted_ts          REAL NOT NULL DEFAULT 0,
+    promoted_skill_id    INTEGER NOT NULL DEFAULT 0,
     UNIQUE(origin_instance_id, content_sha256)
 );
 """
@@ -46,12 +48,18 @@ _TRIAL_COLS = {
     "last_trial_error": "TEXT NOT NULL DEFAULT ''",
 }
 
+# v2.3: promotion-stats columns added to pre-existing DBs via _migrate.
+_PROMOTE_COLS = {
+    "promoted_ts": "REAL NOT NULL DEFAULT 0",
+    "promoted_skill_id": "INTEGER NOT NULL DEFAULT 0",
+}
+
 
 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."""
+    """Idempotent ADD COLUMN for pre-v2.2.2/v2.3 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():
+    for col, decl in {**_TRIAL_COLS, **_PROMOTE_COLS}.items():
         if col not in have:
             conn.execute(f"ALTER TABLE quarantine ADD COLUMN {col} {decl}")
 
@@ -78,6 +86,8 @@ class QuarantineRow:
     last_trial_ts: float = 0.0
     last_trial_result: str = ""
     last_trial_error: str = ""
+    promoted_ts: float = 0.0
+    promoted_skill_id: int = 0
     id: int | None = None
 
 
@@ -116,7 +126,8 @@ def _row(r: sqlite3.Row) -> QuarantineRow:
         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"])
+        last_trial_error=r["last_trial_error"],
+        promoted_ts=r["promoted_ts"], promoted_skill_id=r["promoted_skill_id"])
 
 
 def insert(db: Path, row: QuarantineRow) -> bool:
@@ -196,3 +207,18 @@ def note_trial(db: Path, rowid: int, *, result: str, error: str,
         return cur.rowcount > 0
     finally:
         conn.close()
+
+
+def mark_promoted(db: Path, rowid: int, *, ts: float, skill_id: int) -> bool:
+    """Stamp promoted_ts / promoted_skill_id after a successful graft into the
+    live library. Returns True iff a row was updated. Never touches the trial
+    counters or import_status."""
+    conn = _connect(db)
+    try:
+        cur = conn.execute(
+            "UPDATE quarantine SET promoted_ts = ?, promoted_skill_id = ?"
+            " WHERE id = ?", (ts, skill_id, rowid))
+        conn.commit()
+        return cur.rowcount > 0
+    finally:
+        conn.close()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conscio
-Version: 2.2.2
+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,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.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.
+- **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.

{conscio-2.2.2 → conscio-2.3.0}/conscio.egg-info/SOURCES.txt

@@ -63,6 +63,7 @@ conscio/agency/host_act.py
 conscio/agency/ledger.py
 conscio/agency/loop.py
 conscio/agency/profiles.py
+conscio/agency/promote.py
 conscio/agency/skeptic.py
 conscio/agency/skills.py
 conscio/agency/tools.py
@@ -121,6 +122,7 @@ tests/test_agency_ledger_v201.py
 tests/test_agency_loop.py
 tests/test_agency_no_network.py
 tests/test_agency_profiles.py
+tests/test_agency_promote.py
 tests/test_agency_skeptic.py
 tests/test_agency_skills.py
 tests/test_agency_skills_wiring.py
@@ -136,6 +138,7 @@ tests/test_awake.py
 tests/test_axis_pack.py
 tests/test_axis_pack_battery.py
 tests/test_cli.py
+tests/test_cli_promote.py
 tests/test_cli_trial.py
 tests/test_coherence.py
 tests/test_coherence_engine_integration.py
@@ -163,6 +166,7 @@ tests/test_engine_advisory.py
 tests/test_engine_host_act.py
 tests/test_engine_init.py
 tests/test_engine_meta_reflect.py
+tests/test_engine_promote.py
 tests/test_engine_propose.py
 tests/test_engine_recall.py
 tests/test_engine_trial.py
@@ -216,6 +220,7 @@ tests/test_packaging.py
 tests/test_perception.py
 tests/test_perf_reflection.py
 tests/test_plugins.py
+tests/test_quarantine_promote.py
 tests/test_quarantine_trial.py
 tests/test_recursive_loop_integration.py
 tests/test_risk.py
@@ -229,6 +234,7 @@ tests/test_session_lifecycle_battery.py
 tests/test_session_lifecycle_dream.py
 tests/test_session_rag.py
 tests/test_shard_engine.py
+tests/test_skills_graft.py
 tests/test_state_loaders_battery.py
 tests/test_state_persistence_battery.py
 tests/test_structural.py

conscio-2.3.0/tests/test_agency_promote.py

@@ -0,0 +1,56 @@
+# tests/test_agency_promote.py
+import json
+
+from conscio.agency.promote import (MIN_PROMOTE_PASSES, PromoteDecision,
+                                     evaluate_promotion)
+
+
+class _Reg:
+    """Minimal registry stub: a tool exists iff its name is in `known`."""
+    def __init__(self, known):
+        self.known = set(known)
+
+    def get(self, name):
+        return object() if name in self.known else None
+
+
+def _seq(*tools):
+    return json.dumps(list(tools))
+
+
+def test_enough_clean_passes_ok():
+    d = evaluate_promotion(trial_successes=3, trial_failures=0,
+                           tool_seq=_seq("fs_read"), registry=_Reg(["fs_read"]))
+    assert d == PromoteDecision(True, "")
+
+
+def test_boundary_three_passes_ok():
+    assert MIN_PROMOTE_PASSES == 3
+    d = evaluate_promotion(trial_successes=3, trial_failures=0,
+                           tool_seq=_seq("fs_read"), registry=_Reg(["fs_read"]))
+    assert d.ok
+
+
+def test_insufficient_passes_refused():
+    d = evaluate_promotion(trial_successes=2, trial_failures=0,
+                           tool_seq=_seq("fs_read"), registry=_Reg(["fs_read"]))
+    assert not d.ok and "insufficient" in d.reason
+
+
+def test_any_failure_refused():
+    d = evaluate_promotion(trial_successes=9, trial_failures=1,
+                           tool_seq=_seq("fs_read"), registry=_Reg(["fs_read"]))
+    assert not d.ok and "failed" in d.reason
+
+
+def test_unknown_tool_refused():
+    d = evaluate_promotion(trial_successes=5, trial_failures=0,
+                           tool_seq=_seq("fs_read", "rm_rf"),
+                           registry=_Reg(["fs_read"]))
+    assert not d.ok and "rm_rf" in d.reason
+
+
+def test_corrupt_tool_seq_refused():
+    d = evaluate_promotion(trial_successes=5, trial_failures=0,
+                           tool_seq='{"not":"a list"}', registry=_Reg([]))
+    assert not d.ok and "corrupt tool_seq" in d.reason

conscio-2.3.0/tests/test_cli_promote.py

@@ -0,0 +1,45 @@
+# tests/test_cli_promote.py
+import pytest
+
+from conscio import cli
+from conscio.agency.promote import PromoteRefusal, PromoteResult
+
+
+def test_promote_rc0_on_result(monkeypatch, capsys):
+    monkeypatch.setattr(cli, "_run_promote",
+                        lambda **kw: PromoteResult(7, 3, 0))
+    rc = cli.main(["promote", "--quarantine", "1", "--enable-promote"])
+    assert rc == 0
+    assert "PROMOTED skill #7" in capsys.readouterr().out
+
+
+def test_promote_rc1_on_refusal(monkeypatch, capsys):
+    monkeypatch.setattr(cli, "_run_promote",
+                        lambda **kw: PromoteRefusal("nope"))
+    rc = cli.main(["promote", "--quarantine", "1", "--enable-promote"])
+    assert rc == 1
+    assert "PROMOTE REFUSED: nope" in capsys.readouterr().out
+
+
+def test_promote_rc1_on_exception(monkeypatch, capsys):
+    def boom(**kw):
+        raise RuntimeError("wiring failed")
+    monkeypatch.setattr(cli, "_run_promote", boom)
+    rc = cli.main(["promote", "--quarantine", "1", "--enable-promote"])
+    assert rc == 1
+    assert "error: wiring failed" in capsys.readouterr().out
+
+
+def test_promote_requires_quarantine():
+    with pytest.raises(SystemExit):
+        cli.main(["promote", "--enable-promote"])
+
+
+def test_promote_disabled_by_default(monkeypatch):
+    seen = {}
+    monkeypatch.setattr(
+        cli, "_run_promote",
+        lambda **kw: seen.update(kw) or PromoteRefusal("x"))
+    cli.main(["promote", "--quarantine", "5"])
+    assert seen["enable_promote"] is False
+    assert seen["quarantine_id"] == 5