conscio 2.2.2__tar.gz → 2.4.0__tar.gz

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

@@ -7,6 +7,55 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [2.4.0] - 2026-06-23 — "Observatory"
+
+### Added
+- **Read-only Observatory.** `conscio-observatory --storage DIR [--token TOK]`
+  serves a **loopback-only** HTTP viewer of one instance's persisted state —
+  logs (events), goals, actions (ledger), skills, and the last state snapshot.
+  It is **engine-free** and **read-only**: a new `conscio/observatory/projection.py`
+  opens `conscio.db` with `mode=ro` (no `PRAGMA`, `SELECT` only) and parses
+  `goals.json` / `state_summary.json`. The server serves **GET only** — every
+  mutation verb returns **405**. It reads even a **cold** instance (no engine).
+- **MCP read-only state tools.** `conscio.state`, `conscio.events`,
+  `conscio.handoff` are now exposed as MCP `tools/call` entries (for hosts that
+  speak tools, not resources), delegating to the **same** helpers the
+  `conscio://` resources use. Always on, propose-only grade, independent of
+  `--enable-act`.
+- **No `--enable-observatory` flag.** The Observatory has no write/execute/
+  autonomy surface, so launching the command *is* the opt-in; it is independent
+  of `--enable-act` and `--awake`.
+
+### Notes
+- **Two freshness contracts:** the MCP tools read the **live** engine; the
+  viewer reads the **last-persisted** snapshot (may lag — the UI says so).
+- **Debt-zero:** the Hub (`conscio/hub/`) is untouched; the Observatory is a
+  separate, self-contained package. The shared **noosphere** view is deferred to
+  v2.5 (the projection is built source-pluggable for it).
+- **Multi-user hosts:** on a shared machine, pass `--token` — loopback blocks
+  remote access but not other local users.
+
+## [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.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conscio
-Version: 2.2.2
+Version: 2.4.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.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.4.0` — "Observatory": a **read-only** window into one instance's mind. `conscio-observatory --storage DIR [--token TOK]` serves a **loopback-only** HTTP viewer of the persisted logs, goals, actions, skills, and state — over an **engine-free** projection that opens `conscio.db` with `mode=ro` (no `PRAGMA`, `SELECT` only) and parses `goals.json`/`state_summary.json`. It serves **GET only** (every mutation verb → 405) and reads even a **cold** instance with no engine running. The MCP server also gains read-only `conscio.state`/`conscio.events`/`conscio.handoff` **tools** that delegate to the same helpers its resources use. **No `--enable-observatory` flag** — it has no write/execute surface, so launching it is the opt-in. `pip install conscio`.
+- **Prior:** `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`.
+- **Earlier:** `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.4.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.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.4.0` — "Observatory": a **read-only** window into one instance's mind. `conscio-observatory --storage DIR [--token TOK]` serves a **loopback-only** HTTP viewer of the persisted logs, goals, actions, skills, and state — over an **engine-free** projection that opens `conscio.db` with `mode=ro` (no `PRAGMA`, `SELECT` only) and parses `goals.json`/`state_summary.json`. It serves **GET only** (every mutation verb → 405) and reads even a **cold** instance with no engine running. The MCP server also gains read-only `conscio.state`/`conscio.events`/`conscio.handoff` **tools** that delegate to the same helpers its resources use. **No `--enable-observatory` flag** — it has no write/execute surface, so launching it is the opt-in. `pip install conscio`.
+- **Prior:** `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`.
+- **Earlier:** `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.4.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.4.0"
 __author__ = "Neguiolidas / Neguitech"
 
 from .engine import ConsciousnessEngine

conscio-2.4.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.4.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.4.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.4.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.4.0}/conscio/mcp/schemas.py

@@ -86,6 +86,19 @@ BASE_TOOL_DEFS: list[dict] = [
                      "properties": {"goal": {"type": "string"},
                                     "tools": {"type": "array"}},
                      "required": ["goal", "tools"]}},
+    {"name": "conscio.state",
+     "description": "ConsciousnessState snapshot (pure read).",
+     "inputSchema": {"type": "object", "properties": {}}},
+    {"name": "conscio.events",
+     "description": "Recent events (pure read; type/category/since/limit).",
+     "inputSchema": {"type": "object",
+                     "properties": {"type": {"type": "string"},
+                                    "category": {"type": "string"},
+                                    "since": {"type": "string"},
+                                    "limit": {"type": "integer"}}}},
+    {"name": "conscio.handoff",
+     "description": "Latest session handoff (pure read, markdown).",
+     "inputSchema": {"type": "object", "properties": {}}},
 ]
 
 RESOURCE_DEFS: list[dict] = [

{conscio-2.2.2 → conscio-2.4.0}/conscio/mcp/server.py

@@ -94,6 +94,9 @@ class Bindings:
                 self._require(a, "intent")),
             "conscio.propose_plan": lambda a: self.engine.propose_plan(
                 self._require(a, "goal"), a.get("tools")),
+            "conscio.state": lambda a: self._state_payload(),
+            "conscio.events": lambda a: self._events_payload(a),
+            "conscio.handoff": lambda a: self._handoff_payload(),
         }
         if self._act_enabled():
             tools.update({
@@ -187,6 +190,25 @@ class Bindings:
             self.seen.mark(skey, json.dumps(result), time.time())
         return result
 
+    # ── read-only state payloads (shared by resources + tools, v2.4) ──
+    def _state_payload(self) -> dict:
+        return self.engine.advisory().get("state", {})
+
+    def _events_payload(self, params: dict) -> list[dict]:
+        def s(key: str) -> str | None:
+            v = params.get(key)
+            return str(v) if v not in (None, "") else None
+        try:
+            limit = int(params.get("limit", 50))
+        except (TypeError, ValueError):
+            limit = 50
+        rows = self.engine.event_bus.query(
+            type=s("type"), category=s("category"), since=s("since"), limit=limit)
+        return [e.to_dict() for e in rows]
+
+    def _handoff_payload(self) -> str:
+        return self._handoff_text()
+
     # ── resources ──
     def read_resource(self, uri: str) -> dict:
         parsed = urlparse(uri)
@@ -194,24 +216,14 @@ class Bindings:
         if base == "conscio://advisory":
             return self._json_resource(uri, self.engine.advisory())
         if base == "conscio://state":
-            return self._json_resource(uri,
-                                       self.engine.advisory().get("state", {}))
+            return self._json_resource(uri, self._state_payload())
         if base == "conscio://events":
             q = parse_qs(parsed.query)
-
-            def first(key: str) -> str | None:
-                vals = q.get(key)
-                return vals[0] if vals else None
-
-            rows = self.engine.event_bus.query(
-                type=first("type"),
-                category=first("category"),
-                since=first("since"),
-                limit=int(first("limit") or "50"))
-            return self._json_resource(uri, [e.to_dict() for e in rows])
+            params = {k: (v[0] if v else None) for k, v in q.items()}
+            return self._json_resource(uri, self._events_payload(params))
         if base == "conscio://handoff":
             return {"contents": [{"uri": uri, "mimeType": "text/markdown",
-                                 "text": self._handoff_text()}]}
+                                 "text": self._handoff_payload()}]}
         raise j.InvalidParams(f"unknown resource '{uri}'")
 
     @staticmethod

{conscio-2.2.2 → conscio-2.4.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.4.0/conscio/observatory/__init__.py

@@ -0,0 +1,2 @@
+"""Conscio Observatory — engine-free, read-only view of one instance's
+persisted state (v2.4). See conscio/observatory/projection.py."""

conscio-2.4.0/conscio/observatory/projection.py

@@ -0,0 +1,97 @@
+"""Engine-free read-only projection of one instance's persisted state.
+
+Opens conscio.db with mode=ro (NO PRAGMA, SELECT only) for events/actions/skills
+and parses two JSON state files (goals.json is a LIST; state_summary.json is an
+OBJECT). Never writes. Source-pluggable: a v2.5 noosphere source adds its own
+method group + path without touching the conscio.db / JSON paths here."""
+from __future__ import annotations
+
+import json
+import sqlite3
+from pathlib import Path
+from typing import Any
+
+from ..guards import clamp_int, safe_read_json   # leaf utils; not conscio.engine
+
+
+def _read_json_list(path: Path) -> list[dict]:
+    """safe_read_json is dict-only; goals.json is a list. Read a JSON list
+    safely: any problem (missing, OSError, malformed, not-a-list) -> []."""
+    try:
+        data = json.loads(path.read_text())
+    except (OSError, ValueError):
+        return []
+    return data if isinstance(data, list) else []
+
+
+class Projection:
+    def __init__(self, storage: Path) -> None:
+        self.storage = Path(storage)
+        self._db = self.storage / "conscio.db"
+
+    # ── conscio.db (read-only) ──
+    def _ro(self) -> sqlite3.Connection:
+        conn = sqlite3.connect(f"file:{self._db}?mode=ro", uri=True)
+        conn.row_factory = sqlite3.Row
+        return conn                               # NO PRAGMA — mode=ro blocks writes
+
+    def _select(self, sql: str, params: list[Any]) -> list[dict]:
+        if not self._db.exists():
+            return []
+        try:
+            conn = self._ro()
+        except sqlite3.OperationalError:
+            return []
+        try:
+            return [dict(r) for r in conn.execute(sql, params).fetchall()]
+        except sqlite3.OperationalError:
+            return []                             # table absent on a partial db
+        finally:
+            conn.close()
+
+    def events(self, *, type: str | None = None, category: str | None = None,
+               since: str | None = None, limit: int = 50) -> list[dict]:
+        conds, params = [], []
+        if type:
+            conds.append("type = ?")
+            params.append(type)
+        if category:
+            conds.append("category = ?")
+            params.append(category)
+        if since:
+            conds.append("timestamp >= ?")        # shares fate w/ event_bus.query
+            params.append(since)
+        where = " AND ".join(conds) if conds else "1=1"
+        rows = self._select(
+            "SELECT id, type, category, data, priority, data_hash, project_dir,"
+            " attribution_confidence, timestamp, is_duplicate FROM events"
+            f" WHERE {where} ORDER BY timestamp DESC LIMIT ?",
+            params + [clamp_int(limit, 1, 500)])
+        for r in rows:
+            try:
+                r["data"] = json.loads(r.get("data") or "{}")
+            except (ValueError, TypeError):
+                r["data"] = {}
+            r["is_duplicate"] = bool(r.get("is_duplicate"))
+        return rows
+
+    def actions(self, *, status: str | None = None, limit: int = 50) -> list[dict]:
+        if status:
+            return self._select(
+                "SELECT * FROM actions WHERE status = ? ORDER BY id DESC LIMIT ?",
+                [status, clamp_int(limit, 1, 500)])
+        return self._select(
+            "SELECT * FROM actions ORDER BY id DESC LIMIT ?",
+            [clamp_int(limit, 1, 500)])
+
+    def skills(self, *, limit: int = 100) -> list[dict]:
+        return self._select(
+            "SELECT * FROM skills ORDER BY id DESC LIMIT ?",
+            [clamp_int(limit, 1, 500)])
+
+    # ── JSON state files ──
+    def goals(self) -> list[dict]:
+        return _read_json_list(self.storage / "goals.json")  # NOT safe_read_json
+
+    def state(self) -> dict:
+        return safe_read_json(self.storage / "state_summary.json") or {}