conscio 2.6.2__tar.gz → 2.7.0__tar.gz

{conscio-2.6.2 → conscio-2.7.0}/CHANGELOG.md

@@ -7,6 +7,45 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [2.7.0] - 2026-06-25 — "Phase 2: General Relay Auto-Respond"
+
+### Added
+- **Awake relay auto-respond (daemon).** A new `--auto-respond` flag lets an
+  awake daemon auto-reply to unread free-form relay messages from trusted peers,
+  generating one reply each via its LLM adapter and sending it back. OFF by
+  default; inert without the `relay` sensor + an adapter + `--awake` +
+  `--relay-peer`. `--respond-limit` (default 10) caps adapter calls per cycle.
+- Pure responder `conscio/agency/relay_respond.py` (engine-free; raw adapter
+  call, no engine memory). Replies carry `auto_reply: true` + `in_reply_to`.
+
+### Notes
+- **1-turn bounded.** A peer's auto-reply (`auto_reply: true`) is consumed but
+  never re-answered, so two auto-responders cannot ping-pong. Multi-turn is a
+  later phase.
+- **Daemon owns consumption in this mode.** The responder marks handled peer
+  rows read (per-row, after each send); the host's `relay_inbox` no longer sees
+  them. `RelaySensor` stays read-only.
+- Debt-zero: `conscio/liaison/`, `mcp/server.py`, `mcp/protocol.py`,
+  `agency/review_apply.py` unchanged. `relay_send` is a pure mailbox write, not
+  `host_act` — the server is untouched.
+
+---
+
+## [2.6.3] - 2026-06-25 — "Ressalvas"
+
+Post-ship hardening of v2.6.2, addressing reviewer ressalvas.
+
+### Changed
+- **Auto-review SQL is throttled.** `--auto-review` previously opened a liaison `SELECT` on every tool call; it now polls at most once per `AUTO_APPLY_THROTTLE_S` (5 s) per `Bindings`. The `host_act` gate remains the authority — this only paces the opportunistic poll.
+- **`RelaySensor` id prefix widened** 8 → 12 chars in observations, to reduce visual id collision in perception/logs.
+
+### Added
+- End-to-end integration test wiring a real liaison mailbox + real `HostActChannel`/ledger + the daemon `RelaySensor` + the server `--auto-review` apply, proving the perceive → verdict → `host_act.approve` loop (previously a manual smoke).
+
+### Notes
+- **Known limitation (verdict consumption).** `review_apply.apply_verdicts` marks every polled `review_verdict` row read as bound work — including corrupt-payload, non-allowlisted, and stale-fingerprint rows. This cannot affect the normal flow (a `review_request` is published only after the act parks pending, so a peer cannot verdict before the act exists), and a corrected resend is a new mailbox row that polls fresh. A malformed verdict's original row is not re-inspectable.
+- Inbox-flood backoff/stress signaling is deferred — `limit=50` already bounds per-cycle perception work.
+
 ## [2.6.2] - 2026-06-24 — "Awake Relay Sensor"
 
 ### Added

{conscio-2.6.2/conscio.egg-info → conscio-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conscio
-Version: 2.6.2
+Version: 2.7.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.6.2` — "Awake Relay Sensor": an **Awake** instance reacts to peers instead of polling by hand. The daemon gains a read-only `RelaySensor` (`--sensors host,relay --relay-peer <id>`) that reports unread peer messages as a `PerceptionFrame` (`relay_unread`/`review_pending`) each heartbeat and **never marks them read**. The MCP server gains `--auto-review` (off by default): when the proposer is awake and `--enable-act` + `--enable-hermes-review` are on, inbound allowlisted review verdicts are auto-applied to local pending acts on the next tool call — no explicit `conscio.poll_reviews`. The local `host_act` gate stays the authority. **Daemon perceives, server acts**; the shared apply core lives in `conscio/agency/review_apply.py` and `conscio/liaison/*.py` stays engine-free. `pip install conscio`.
-- **Prior:** `v2.6.1` — "Relay": **general cross-agent messaging** over the same Liaison mailbox. Behind `--enable-relay` (independent of act / hermes-review), `conscio.relay_send`/`relay_inbox`/`relay_read` carry **free-form directed messages** between agents — Claude ↔ Hermes ↔ Antigravity ↔ OpenClaw. `--relay-peer` gates **both** send and receive; the two review types stay **reserved** (the channels never bleed); payloads are capped at 64 KB; read messages are purged after 7 days (unread never deleted). A **dumb pipe** — engine-free, never touches an act; no crypto (shared-filesystem trust domain). Debt-zero: no DB schema change, the review path byte-identical. `pip install conscio`.
+- **Current release:** `v2.7.0` — "Phase 2: General Relay Auto-Respond": an **Awake** daemon can now **auto-reply** to unread free-form relay messages from trusted peers — generating one reply each via its LLM adapter and sending it back, no human in the loop. Behind `--auto-respond` (OFF by default; inert without the `relay` sensor + an adapter + `--awake` + `--relay-peer`), with `--respond-limit` (default 10) capping adapter calls per cycle. The loop is **1-turn bounded**: a peer's auto-reply is consumed but never re-answered, so two auto-responders cannot ping-pong. Replies carry `auto_reply: true` + `in_reply_to`. The new pure responder `conscio/agency/relay_respond.py` is **engine-free** (a thin adapter call, no engine memory) and the MCP server is **untouched** — `relay_send` is a pure mailbox write, not `host_act`. `pip install conscio`.
+- **Prior:** `v2.6.3` — "Ressalvas": post-ship hardening of the Awake Relay loop. `--auto-review` no longer opens a liaison `SELECT` per tool call — the poll is **throttled to once per 5 s** per server (the `host_act` gate stays the authority). The `RelaySensor` id prefix in observations widens 8 → 12 chars to avoid visual collision, and an **end-to-end integration test** now wires a real mailbox + `HostActChannel` + daemon sensor + server auto-apply, proving the perceive → verdict → approve loop in-suite. `pip install conscio`.
+- **Earlier:** `v2.6.2` — "Awake Relay Sensor": an **Awake** instance reacts to peers instead of polling by hand. The daemon gains a read-only `RelaySensor` (`--sensors host,relay --relay-peer <id>`) that reports unread peer messages as a `PerceptionFrame` (`relay_unread`/`review_pending`) each heartbeat and **never marks them read**. The MCP server gains `--auto-review` (off by default): when the proposer is awake and `--enable-act` + `--enable-hermes-review` are on, inbound allowlisted review verdicts are auto-applied to local pending acts on the next tool call — no explicit `conscio.poll_reviews`. The local `host_act` gate stays the authority. **Daemon perceives, server acts**; the shared apply core lives in `conscio/agency/review_apply.py` and `conscio/liaison/*.py` stays engine-free. `pip install conscio`.
+- **Earlier:** `v2.6.1` — "Relay": **general cross-agent messaging** over the same Liaison mailbox. Behind `--enable-relay` (independent of act / hermes-review), `conscio.relay_send`/`relay_inbox`/`relay_read` carry **free-form directed messages** between agents — Claude ↔ Hermes ↔ Antigravity ↔ OpenClaw. `--relay-peer` gates **both** send and receive; the two review types stay **reserved** (the channels never bleed); payloads are capped at 64 KB; read messages are purged after 7 days (unread never deleted). A **dumb pipe** — engine-free, never touches an act; no crypto (shared-filesystem trust domain). Debt-zero: no DB schema change, the review path byte-identical. `pip install conscio`.
 - **Earlier:** `v2.6.0` — "Liaison": cross-agent `hermes_review`. A `hermes_review`-gated act proposed by one agent can be **approved or rejected by a different agent** over a file-mediated shared mailbox (`$HERMES_HOME/liaison.db`, separate from `noosphere.db`). New **engine-free** `conscio/liaison/` (mailbox + pure review protocol); MCP tools behind `--enable-hermes-review` — `conscio.reviews`/`review_approve`/`review_reject` (reviewer role) and `conscio.poll_reviews` (proposer role). A verdict is applied **only** from an allowlisted `--reviewer` and **only** through the unchanged local `host_act` gate; `fp` binds each verdict to one exact proposal (proposer id + ledger id), so cross-instance confusion and replay are impossible. No crypto (shared-filesystem trust domain); directed-only; off by default. `pip install conscio`.
 - **Earlier:** `v2.5.0` — "Society view": the Observatory now also projects the **host-shared noosphere** — the "society" of instances that have published into `noosphere.db`. `conscio-observatory` gains read-only `/api/society/{members,skills,records}` (the census plus published skills/records, **metadata only** — artifact/bundle BLOBs omitted) and Society tabs in the viewer, over the same **engine-free** projection that opens `noosphere.db` with `mode=ro` (no `PRAGMA`, `SELECT` only). `mode=ro` reads the latest committed WAL rows even under a concurrent peer writer (`immutable=1` deliberately rejected). GET-only (mutation → 405); **no `--enable` flag** — launching it is the opt-in. `pip install conscio`.
 - **Earlier:** `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`.

{conscio-2.6.2 → conscio-2.7.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.6.2` — "Awake Relay Sensor": an **Awake** instance reacts to peers instead of polling by hand. The daemon gains a read-only `RelaySensor` (`--sensors host,relay --relay-peer <id>`) that reports unread peer messages as a `PerceptionFrame` (`relay_unread`/`review_pending`) each heartbeat and **never marks them read**. The MCP server gains `--auto-review` (off by default): when the proposer is awake and `--enable-act` + `--enable-hermes-review` are on, inbound allowlisted review verdicts are auto-applied to local pending acts on the next tool call — no explicit `conscio.poll_reviews`. The local `host_act` gate stays the authority. **Daemon perceives, server acts**; the shared apply core lives in `conscio/agency/review_apply.py` and `conscio/liaison/*.py` stays engine-free. `pip install conscio`.
-- **Prior:** `v2.6.1` — "Relay": **general cross-agent messaging** over the same Liaison mailbox. Behind `--enable-relay` (independent of act / hermes-review), `conscio.relay_send`/`relay_inbox`/`relay_read` carry **free-form directed messages** between agents — Claude ↔ Hermes ↔ Antigravity ↔ OpenClaw. `--relay-peer` gates **both** send and receive; the two review types stay **reserved** (the channels never bleed); payloads are capped at 64 KB; read messages are purged after 7 days (unread never deleted). A **dumb pipe** — engine-free, never touches an act; no crypto (shared-filesystem trust domain). Debt-zero: no DB schema change, the review path byte-identical. `pip install conscio`.
+- **Current release:** `v2.7.0` — "Phase 2: General Relay Auto-Respond": an **Awake** daemon can now **auto-reply** to unread free-form relay messages from trusted peers — generating one reply each via its LLM adapter and sending it back, no human in the loop. Behind `--auto-respond` (OFF by default; inert without the `relay` sensor + an adapter + `--awake` + `--relay-peer`), with `--respond-limit` (default 10) capping adapter calls per cycle. The loop is **1-turn bounded**: a peer's auto-reply is consumed but never re-answered, so two auto-responders cannot ping-pong. Replies carry `auto_reply: true` + `in_reply_to`. The new pure responder `conscio/agency/relay_respond.py` is **engine-free** (a thin adapter call, no engine memory) and the MCP server is **untouched** — `relay_send` is a pure mailbox write, not `host_act`. `pip install conscio`.
+- **Prior:** `v2.6.3` — "Ressalvas": post-ship hardening of the Awake Relay loop. `--auto-review` no longer opens a liaison `SELECT` per tool call — the poll is **throttled to once per 5 s** per server (the `host_act` gate stays the authority). The `RelaySensor` id prefix in observations widens 8 → 12 chars to avoid visual collision, and an **end-to-end integration test** now wires a real mailbox + `HostActChannel` + daemon sensor + server auto-apply, proving the perceive → verdict → approve loop in-suite. `pip install conscio`.
+- **Earlier:** `v2.6.2` — "Awake Relay Sensor": an **Awake** instance reacts to peers instead of polling by hand. The daemon gains a read-only `RelaySensor` (`--sensors host,relay --relay-peer <id>`) that reports unread peer messages as a `PerceptionFrame` (`relay_unread`/`review_pending`) each heartbeat and **never marks them read**. The MCP server gains `--auto-review` (off by default): when the proposer is awake and `--enable-act` + `--enable-hermes-review` are on, inbound allowlisted review verdicts are auto-applied to local pending acts on the next tool call — no explicit `conscio.poll_reviews`. The local `host_act` gate stays the authority. **Daemon perceives, server acts**; the shared apply core lives in `conscio/agency/review_apply.py` and `conscio/liaison/*.py` stays engine-free. `pip install conscio`.
+- **Earlier:** `v2.6.1` — "Relay": **general cross-agent messaging** over the same Liaison mailbox. Behind `--enable-relay` (independent of act / hermes-review), `conscio.relay_send`/`relay_inbox`/`relay_read` carry **free-form directed messages** between agents — Claude ↔ Hermes ↔ Antigravity ↔ OpenClaw. `--relay-peer` gates **both** send and receive; the two review types stay **reserved** (the channels never bleed); payloads are capped at 64 KB; read messages are purged after 7 days (unread never deleted). A **dumb pipe** — engine-free, never touches an act; no crypto (shared-filesystem trust domain). Debt-zero: no DB schema change, the review path byte-identical. `pip install conscio`.
 - **Earlier:** `v2.6.0` — "Liaison": cross-agent `hermes_review`. A `hermes_review`-gated act proposed by one agent can be **approved or rejected by a different agent** over a file-mediated shared mailbox (`$HERMES_HOME/liaison.db`, separate from `noosphere.db`). New **engine-free** `conscio/liaison/` (mailbox + pure review protocol); MCP tools behind `--enable-hermes-review` — `conscio.reviews`/`review_approve`/`review_reject` (reviewer role) and `conscio.poll_reviews` (proposer role). A verdict is applied **only** from an allowlisted `--reviewer` and **only** through the unchanged local `host_act` gate; `fp` binds each verdict to one exact proposal (proposer id + ledger id), so cross-instance confusion and replay are impossible. No crypto (shared-filesystem trust domain); directed-only; off by default. `pip install conscio`.
 - **Earlier:** `v2.5.0` — "Society view": the Observatory now also projects the **host-shared noosphere** — the "society" of instances that have published into `noosphere.db`. `conscio-observatory` gains read-only `/api/society/{members,skills,records}` (the census plus published skills/records, **metadata only** — artifact/bundle BLOBs omitted) and Society tabs in the viewer, over the same **engine-free** projection that opens `noosphere.db` with `mode=ro` (no `PRAGMA`, `SELECT` only). `mode=ro` reads the latest committed WAL rows even under a concurrent peer writer (`immutable=1` deliberately rejected). GET-only (mutation → 405); **no `--enable` flag** — launching it is the opt-in. `pip install conscio`.
 - **Earlier:** `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`.

{conscio-2.6.2 → conscio-2.7.0}/conscio/__init__.py

@@ -6,7 +6,7 @@ and goal generation. Adapts behavior based on the underlying model's
 context window size.
 """
 
-__version__ = "2.6.2"
+__version__ = "2.7.0"
 __author__ = "Neguiolidas / Neguitech"
 
 from .engine import ConsciousnessEngine

conscio-2.7.0/conscio/agency/relay_respond.py

@@ -0,0 +1,81 @@
+# conscio/agency/relay_respond.py
+"""Pure relay auto-responder — the daemon's awake auto-reply path (v2.7.0
+"Phase 2"). Reads unread free-form relay messages from allowlisted peers,
+generates one reply each via a raw InferenceAdapter, and sends it back over the
+mailbox. An agency->liaison bridge: imports nothing from conscio.engine, so the
+reply is a thin adapter call (no engine memory/advisory). Loop-bounded: own
+replies carry payload.auto_reply=True and such inbound is consumed, never
+re-answered. mark_read is per-row, immediately after a successful send / skip."""
+from __future__ import annotations
+
+import json
+
+from ..liaison import mailbox, relay
+
+DEFAULT_SYSTEM = (
+    "You are an autonomous agent replying to a peer agent over a relay "
+    "channel. Read the peer's message and reply concisely and helpfully. "
+    "Reply with prose only.")
+
+
+def _msg_text(payload) -> str:
+    """Best-effort human text from a relay payload; falls back to compact JSON."""
+    if isinstance(payload, dict):
+        for k in ("text", "body", "message"):
+            v = payload.get(k)
+            if isinstance(v, str) and v:
+                return v
+    return json.dumps(payload, separators=(",", ":"))
+
+
+def _fit(reply: dict) -> dict:
+    """Shrink reply['text'] until the compact-JSON payload fits the relay cap.
+    UTF-8-safe (slices code points, re-encodes via payload_size)."""
+    if relay.payload_size(reply) <= relay.MAX_PAYLOAD_BYTES:
+        return reply
+    text = reply["text"]
+    lo, hi = 0, len(text)
+    while lo < hi:                                   # largest prefix that fits
+        mid = (lo + hi + 1) // 2
+        if relay.payload_size(dict(reply, text=text[:mid])) <= \
+                relay.MAX_PAYLOAD_BYTES:
+            lo = mid
+        else:
+            hi = mid - 1
+    return dict(reply, text=text[:lo])
+
+
+def auto_respond(adapter, liaison_db, self_id, peers, *, limit: int = 10,
+                 max_reply_tokens: int = 512, system: str = DEFAULT_SYSTEM
+                 ) -> list[dict]:
+    """Auto-reply to unread peer relay messages. Returns sent packets.
+    No-op ([]) when adapter is None, liaison_db/self_id falsy, or peers empty."""
+    if adapter is None or not liaison_db or not self_id or not peers:
+        return []
+    peers = set(peers)
+    rows = mailbox.inbox(liaison_db, self_id, types=None,
+                         unread_only=True, limit=limit)   # newest-first, capped
+    sent: list[dict] = []
+    for m in rows:
+        typ = m.get("type", "")
+        frm = m.get("from_instance", "")
+        payload = m.get("payload")
+        if typ in relay.RESERVED_TYPES:
+            continue                                 # review channel owns it
+        if not relay.is_relay_message(m, peers):
+            continue                                 # non-peer/oversized: not ours
+        if isinstance(payload, dict) and payload.get("auto_reply") is True:
+            mailbox.mark_read(liaison_db, [m["id"]])  # R2: consume, don't answer
+            continue
+        prompt = system + "\n\nPeer message:\n" + _msg_text(payload)
+        try:
+            text = adapter.generate(prompt, max_tokens=max_reply_tokens).text
+        except Exception:                            # fork 4: leave UNREAD, retry
+            continue
+        reply = _fit({"text": text, "auto_reply": True,
+                      "in_reply_to": m["id"]})
+        rid = mailbox.send(liaison_db, from_instance=self_id, to_instance=frm,
+                           type=typ, payload=reply)   # type echoed
+        mailbox.mark_read(liaison_db, [m["id"]])      # R2: per-row, post-send
+        sent.append({"to": frm, "in_reply_to": m["id"], "reply_id": rid})
+    return sent

{conscio-2.6.2 → conscio-2.7.0}/conscio/daemon.py

@@ -56,6 +56,7 @@ class Daemon:
     def __init__(self, engine: Any, sensors: Sequence[SensorAdapter], *,
                  interval: float = 5.0, budget: Optional[ActBudget] = None,
                  on_cycle: Optional[Callable[[list, RunReport], Any]] = None,
+                 responder: Optional[Callable[[], list]] = None,
                  workspace: Any = None,
                  consent: Any = None,
                  pidfile: Optional[str | Path] = None,
@@ -66,6 +67,7 @@ class Daemon:
         self.interval = interval
         self.budget = budget
         self.on_cycle = on_cycle or (lambda frames, result: None)
+        self.responder = responder                      # v2.7.0: relay auto-reply
         self.workspace = workspace
         self.consent = consent                          # v1.7.2: structural consent
         self._synced_ws_id: Optional[str] = None        # re-sync only on ws change
@@ -104,6 +106,11 @@ class Daemon:
         result = self.engine.run(self.budget, world_state=world_state)
         self.cycles += 1
         self._last_report = result
+        if self.responder is not None:                  # v2.7.0: awake auto-reply
+            try:
+                self.responder()
+            except Exception as exc:        # a bad responder never kills the loop
+                log.warning("relay responder failed: %s", exc)
         # Write heartbeat every cycle (not just on shutdown)
         self._write_heartbeat()
         try:
@@ -248,6 +255,14 @@ def _build_sensors(spec: str, *, agent_source: Optional[str],
     return sensors
 
 
+def _responder_armed(*, auto_respond: bool, relay_peer, has_adapter: bool,
+                     awake: bool, sensors_spec: str) -> bool:
+    """True iff --auto-respond should arm: needs a relay sensor + an adapter +
+    --awake + at least one --relay-peer (v2.7.0)."""
+    return bool(auto_respond and relay_peer and has_adapter and awake
+                and "relay" in [s.strip() for s in sensors_spec.split(",")])
+
+
 # ── config loader + adapter builder live in conscio/adapter_config.py now
 # (shared by the daemon and the MCP server; v2.0.1, no behavior change) ──
 
@@ -312,6 +327,12 @@ def _arg_parser() -> argparse.ArgumentParser:
     parser.add_argument("--relay-peer", action="append", default=[],
                         metavar="INSTANCE_ID",
                         help="trusted relay peer for the relay sensor (repeatable)")
+    parser.add_argument("--auto-respond", action="store_true",
+                        help="daemon auto-replies to unread relay peer messages "
+                             "via the adapter (OFF default; needs relay sensor + "
+                             "adapter + --awake + --relay-peer)")
+    parser.add_argument("--respond-limit", type=int, default=10,
+                        help="max relay auto-replies per cycle (token-burn cap)")
     return parser
 
 
@@ -370,8 +391,25 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
               if args.budget_cycles else None)
     workspace = WorkspaceContext(emit=engine.event_bus.emit)
     consent = StructuralConsent(consent_path(engine.storage))   # v1.7.2
+    responder = None                                            # v2.7.0
+    if args.auto_respond:
+        if _responder_armed(auto_respond=True, relay_peer=args.relay_peer,
+                            has_adapter=adapter is not None, awake=awake,
+                            sensors_spec=sensors_spec):
+            from .agency import relay_respond
+            _adapter = adapter                          # R1: bind LOCAL adapter
+            _peers = tuple(args.relay_peer)
+            responder = lambda: relay_respond.auto_respond(   # noqa: E731
+                _adapter, liaison_db, self_id, _peers,
+                limit=args.respond_limit)
+            log.info("relay auto-respond armed (peers=%d, limit=%d)",
+                     len(_peers), args.respond_limit)
+        else:
+            log.warning("--auto-respond inert: needs relay sensor + adapter + "
+                        "--awake + --relay-peer; skipping")
     daemon = Daemon(engine, sensors=sensors, interval=interval,
-                    budget=budget, workspace=workspace, consent=consent)
+                    budget=budget, workspace=workspace, consent=consent,
+                    responder=responder)
     daemon.run(once=args.once)
     return 0
 

{conscio-2.6.2 → conscio-2.7.0}/conscio/mcp/server.py

@@ -24,6 +24,11 @@ from .seen import SeenStore
 from ..agency import review_apply
 from ..liaison import mailbox, relay, review
 
+# v2.6.3 #2: floor between auto-review SQL polls so --auto-review does not open a
+# liaison SELECT on every single tool call in a chatty session. host_act.approve
+# remains the authority; this only paces the opportunistic poll.
+AUTO_APPLY_THROTTLE_S = 5.0
+
 
 class Bindings:
     def __init__(self, engine: ConsciousnessEngine, seen: SeenStore, *,
@@ -50,6 +55,7 @@ class Bindings:
         self.relay = relay                   # v2.6.1: --enable-relay
         self.relay_peers = tuple(relay_peers)
         self.auto_review = auto_review        # v2.6.2: --auto-review
+        self.last_auto_apply_ts = 0.0         # v2.6.3 #2: throttle clock
 
     # ── discovery ──
     def version(self) -> str:
@@ -262,6 +268,10 @@ class Bindings:
             return
         if self.engine.host_act is None or not self.reviewers:
             return
+        now = time.monotonic()               # v2.6.3 #2: pace the SQL poll
+        if now - self.last_auto_apply_ts < AUTO_APPLY_THROTTLE_S:
+            return
+        self.last_auto_apply_ts = now
         try:
             review_apply.apply_verdicts(self.engine.host_act, self.liaison_db,
                                         self.self_instance_id, self.reviewers)

{conscio-2.6.2 → conscio-2.7.0}/conscio/perception/relay_sensor.py

@@ -13,6 +13,8 @@ from ..liaison.relay import RESERVED_TYPES
 from ..risk import Risk
 from .sensor import PerceptionFrame, SensorAdapter
 
+_ID_DISPLAY = 12        # v2.6.3 #4: wider id prefix; 8 risked visual collision
+
 
 class RelaySensor(SensorAdapter):
     """Unread liaison inbox as a `PerceptionFrame` (source ``"relay"``)."""
@@ -46,9 +48,9 @@ class RelaySensor(SensorAdapter):
             else:
                 other_n += 1                   # non-peer: counted, not detailed
         for frm, n in sorted(relay_from.items()):
-            obs.append(f"relay: {n} unread from {frm[:8]}")
+            obs.append(f"relay: {n} unread from {frm[:_ID_DISPLAY]}")
         for frm, n in sorted(review_from.items()):
-            obs.append(f"review: {n} verdict(s) pending from {frm[:8]}")
+            obs.append(f"review: {n} verdict(s) pending from {frm[:_ID_DISPLAY]}")
         if other_n:
             obs.append(f"relay: {other_n} unread from non-peers (ignored)")
         if not obs:

{conscio-2.6.2 → conscio-2.7.0/conscio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conscio
-Version: 2.6.2
+Version: 2.7.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.6.2` — "Awake Relay Sensor": an **Awake** instance reacts to peers instead of polling by hand. The daemon gains a read-only `RelaySensor` (`--sensors host,relay --relay-peer <id>`) that reports unread peer messages as a `PerceptionFrame` (`relay_unread`/`review_pending`) each heartbeat and **never marks them read**. The MCP server gains `--auto-review` (off by default): when the proposer is awake and `--enable-act` + `--enable-hermes-review` are on, inbound allowlisted review verdicts are auto-applied to local pending acts on the next tool call — no explicit `conscio.poll_reviews`. The local `host_act` gate stays the authority. **Daemon perceives, server acts**; the shared apply core lives in `conscio/agency/review_apply.py` and `conscio/liaison/*.py` stays engine-free. `pip install conscio`.
-- **Prior:** `v2.6.1` — "Relay": **general cross-agent messaging** over the same Liaison mailbox. Behind `--enable-relay` (independent of act / hermes-review), `conscio.relay_send`/`relay_inbox`/`relay_read` carry **free-form directed messages** between agents — Claude ↔ Hermes ↔ Antigravity ↔ OpenClaw. `--relay-peer` gates **both** send and receive; the two review types stay **reserved** (the channels never bleed); payloads are capped at 64 KB; read messages are purged after 7 days (unread never deleted). A **dumb pipe** — engine-free, never touches an act; no crypto (shared-filesystem trust domain). Debt-zero: no DB schema change, the review path byte-identical. `pip install conscio`.
+- **Current release:** `v2.7.0` — "Phase 2: General Relay Auto-Respond": an **Awake** daemon can now **auto-reply** to unread free-form relay messages from trusted peers — generating one reply each via its LLM adapter and sending it back, no human in the loop. Behind `--auto-respond` (OFF by default; inert without the `relay` sensor + an adapter + `--awake` + `--relay-peer`), with `--respond-limit` (default 10) capping adapter calls per cycle. The loop is **1-turn bounded**: a peer's auto-reply is consumed but never re-answered, so two auto-responders cannot ping-pong. Replies carry `auto_reply: true` + `in_reply_to`. The new pure responder `conscio/agency/relay_respond.py` is **engine-free** (a thin adapter call, no engine memory) and the MCP server is **untouched** — `relay_send` is a pure mailbox write, not `host_act`. `pip install conscio`.
+- **Prior:** `v2.6.3` — "Ressalvas": post-ship hardening of the Awake Relay loop. `--auto-review` no longer opens a liaison `SELECT` per tool call — the poll is **throttled to once per 5 s** per server (the `host_act` gate stays the authority). The `RelaySensor` id prefix in observations widens 8 → 12 chars to avoid visual collision, and an **end-to-end integration test** now wires a real mailbox + `HostActChannel` + daemon sensor + server auto-apply, proving the perceive → verdict → approve loop in-suite. `pip install conscio`.
+- **Earlier:** `v2.6.2` — "Awake Relay Sensor": an **Awake** instance reacts to peers instead of polling by hand. The daemon gains a read-only `RelaySensor` (`--sensors host,relay --relay-peer <id>`) that reports unread peer messages as a `PerceptionFrame` (`relay_unread`/`review_pending`) each heartbeat and **never marks them read**. The MCP server gains `--auto-review` (off by default): when the proposer is awake and `--enable-act` + `--enable-hermes-review` are on, inbound allowlisted review verdicts are auto-applied to local pending acts on the next tool call — no explicit `conscio.poll_reviews`. The local `host_act` gate stays the authority. **Daemon perceives, server acts**; the shared apply core lives in `conscio/agency/review_apply.py` and `conscio/liaison/*.py` stays engine-free. `pip install conscio`.
+- **Earlier:** `v2.6.1` — "Relay": **general cross-agent messaging** over the same Liaison mailbox. Behind `--enable-relay` (independent of act / hermes-review), `conscio.relay_send`/`relay_inbox`/`relay_read` carry **free-form directed messages** between agents — Claude ↔ Hermes ↔ Antigravity ↔ OpenClaw. `--relay-peer` gates **both** send and receive; the two review types stay **reserved** (the channels never bleed); payloads are capped at 64 KB; read messages are purged after 7 days (unread never deleted). A **dumb pipe** — engine-free, never touches an act; no crypto (shared-filesystem trust domain). Debt-zero: no DB schema change, the review path byte-identical. `pip install conscio`.
 - **Earlier:** `v2.6.0` — "Liaison": cross-agent `hermes_review`. A `hermes_review`-gated act proposed by one agent can be **approved or rejected by a different agent** over a file-mediated shared mailbox (`$HERMES_HOME/liaison.db`, separate from `noosphere.db`). New **engine-free** `conscio/liaison/` (mailbox + pure review protocol); MCP tools behind `--enable-hermes-review` — `conscio.reviews`/`review_approve`/`review_reject` (reviewer role) and `conscio.poll_reviews` (proposer role). A verdict is applied **only** from an allowlisted `--reviewer` and **only** through the unchanged local `host_act` gate; `fp` binds each verdict to one exact proposal (proposer id + ledger id), so cross-instance confusion and replay are impossible. No crypto (shared-filesystem trust domain); directed-only; off by default. `pip install conscio`.
 - **Earlier:** `v2.5.0` — "Society view": the Observatory now also projects the **host-shared noosphere** — the "society" of instances that have published into `noosphere.db`. `conscio-observatory` gains read-only `/api/society/{members,skills,records}` (the census plus published skills/records, **metadata only** — artifact/bundle BLOBs omitted) and Society tabs in the viewer, over the same **engine-free** projection that opens `noosphere.db` with `mode=ro` (no `PRAGMA`, `SELECT` only). `mode=ro` reads the latest committed WAL rows even under a concurrent peer writer (`immutable=1` deliberately rejected). GET-only (mutation → 405); **no `--enable` flag** — launching it is the opt-in. `pip install conscio`.
 - **Earlier:** `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`.

{conscio-2.6.2 → conscio-2.7.0}/conscio.egg-info/SOURCES.txt

@@ -64,6 +64,7 @@ conscio/agency/ledger.py
 conscio/agency/loop.py
 conscio/agency/profiles.py
 conscio/agency/promote.py
+conscio/agency/relay_respond.py
 conscio/agency/review_apply.py
 conscio/agency/skeptic.py
 conscio/agency/skills.py
@@ -168,6 +169,7 @@ tests/test_daemon_battery.py
 tests/test_daemon_config.py
 tests/test_daemon_heartbeat.py
 tests/test_daemon_relay.py
+tests/test_daemon_responder.py
 tests/test_daemon_structure_sync.py
 tests/test_dream_coherence.py
 tests/test_dream_distill.py
@@ -249,6 +251,8 @@ tests/test_plugins.py
 tests/test_quarantine_promote.py
 tests/test_quarantine_trial.py
 tests/test_recursive_loop_integration.py
+tests/test_relay_e2e.py
+tests/test_relay_respond.py
 tests/test_relay_sensor.py
 tests/test_review_apply.py
 tests/test_risk.py

conscio-2.7.0/tests/test_daemon_responder.py

@@ -0,0 +1,58 @@
+# tests/test_daemon_responder.py
+"""v2.7.0 Phase 2 — daemon responder hook + arm gate."""
+from conscio.daemon import Daemon, _responder_armed
+from conscio.engine import ConsciousnessEngine
+from conscio.perception import MockSensor, PerceptionFrame
+
+
+def _engine(tmp_path):
+    return ConsciousnessEngine("glm-5.1", storage_path=tmp_path / "s")
+
+
+def _frame():
+    return PerceptionFrame(source="mock", observations=["o"], signals={"x": 1.0})
+
+
+def test_responder_called_after_run(tmp_path):
+    eng = _engine(tmp_path)
+    calls = {"n": 0}
+    d = Daemon(eng, sensors=[MockSensor([_frame()])],
+               responder=lambda: calls.__setitem__("n", calls["n"] + 1))
+    try:
+        d.cycle()
+        assert calls["n"] == 1
+    finally:
+        eng.close()
+
+
+def test_responder_raise_survives_cycle(tmp_path):
+    eng = _engine(tmp_path)
+
+    def boom():
+        raise RuntimeError("responder down")
+
+    d = Daemon(eng, sensors=[MockSensor([_frame()])], responder=boom)
+    try:
+        d.cycle()                                    # must not raise
+    finally:
+        eng.close()
+
+
+def test_responder_none_is_noop(tmp_path):
+    eng = _engine(tmp_path)
+    d = Daemon(eng, sensors=[MockSensor([_frame()])])   # no responder
+    try:
+        d.cycle()                                    # no raise
+    finally:
+        eng.close()
+
+
+def test_arm_gate_predicate():
+    base = dict(auto_respond=True, relay_peer=["p"], has_adapter=True,
+                awake=True, sensors_spec="host,relay")
+    assert _responder_armed(**base) is True
+    assert _responder_armed(**{**base, "auto_respond": False}) is False
+    assert _responder_armed(**{**base, "relay_peer": []}) is False
+    assert _responder_armed(**{**base, "has_adapter": False}) is False
+    assert _responder_armed(**{**base, "awake": False}) is False
+    assert _responder_armed(**{**base, "sensors_spec": "host"}) is False

{conscio-2.6.2 → conscio-2.7.0}/tests/test_mcp_auto_review.py

@@ -88,3 +88,28 @@ def test_call_tool_triggers_apply():
     b = _bind(awake=True, host_act=ha, reviewers=("r",), auto_review=True)
     b.call_tool("conscio.advisory", {})       # any tool; advisory needs no host
     assert ha.calls == 1
+
+
+# ── v2.6.3 #2: timestamp throttle (no SQL on every request) ──
+
+def test_throttle_skips_within_window(monkeypatch):
+    import conscio.mcp.server as srv
+    clock = [1000.0]
+    monkeypatch.setattr(srv.time, "monotonic", lambda: clock[0])
+    ha = _HA()
+    b = _bind(awake=True, host_act=ha, reviewers=("r",), auto_review=True)
+    b._maybe_auto_apply()
+    b._maybe_auto_apply()                      # same instant -> throttled, no SQL
+    assert ha.calls == 1
+
+
+def test_throttle_allows_after_window(monkeypatch):
+    import conscio.mcp.server as srv
+    clock = [1000.0]
+    monkeypatch.setattr(srv.time, "monotonic", lambda: clock[0])
+    ha = _HA()
+    b = _bind(awake=True, host_act=ha, reviewers=("r",), auto_review=True)
+    b._maybe_auto_apply()
+    clock[0] += srv.AUTO_APPLY_THROTTLE_S + 0.1
+    b._maybe_auto_apply()                      # window elapsed -> applies again
+    assert ha.calls == 2

conscio-2.7.0/tests/test_relay_e2e.py

@@ -0,0 +1,124 @@
+# tests/test_relay_e2e.py
+"""v2.6.3 #5: end-to-end integration of the v2.6.2 Awake Relay loop wired
+against REAL parts simultaneously — real liaison mailbox, real HostActChannel +
+ledger, the daemon-side RelaySensor (perception, read-only), and the
+server-side Bindings auto-apply (--auto-review). Only the Skeptic/Breaker/Trust
+and the engine shell are faked; the perceive -> verdict -> approve path is real.
+Converts the previously-manual "full loop" claim into a regression guard."""
+import json
+
+from conscio.agency.contracts import AuditVerdict
+from conscio.agency.host_act import HostActChannel
+from conscio.agency.ledger import ActionLedger
+from conscio.agency.tools import registry_from_manifest
+from conscio.liaison import mailbox, review
+from conscio.mcp.server import Bindings
+from conscio.perception.relay_sensor import RelaySensor
+
+SELF = "me-instance-0001"
+REVIEWER = "hermet-instance-0002"
+
+
+class _PassSkeptic:
+    def audit(self, proposal, *, goal_text=""):
+        return AuditVerdict(verdict="PASS", reasons=[], risk_flags=[],
+                            confidence=0.9)
+
+
+class _NoBreaker:
+    def global_lockdown_due(self): return False
+    def should_trip(self, goal_fp, *, task_type=""): return False
+    def trip(self, goal_fp, *, detail="", goal_text=""): pass
+
+
+class _Trust:
+    def on_success(self, tool): pass
+
+
+class _Seen:
+    pass
+
+
+class _Engine:
+    """Minimal engine carrier: real host_act behind the surface Bindings reads."""
+    def __init__(self, host_act):
+        self.awake = True
+        self.host_act = host_act
+
+    def advisory(self):
+        return {"ok": True}
+
+
+def _host_act(tmp_path):
+    led = ActionLedger(tmp_path / "conscio.db")
+    manifest = [{"name": "deploy",
+                 "params": {"env": {"type": "str", "required": True}},
+                 "risk": "low", "approval_policy": "require_approval"}]
+    chan = HostActChannel(
+        ledger=led, skeptic=_PassSkeptic(), breaker=_NoBreaker(), trust=_Trust(),
+        registry=registry_from_manifest(manifest),
+        emit_fn=lambda **kw: None, awake_fn=lambda: True)
+    return chan, led
+
+
+def _bindings(engine, db):
+    return Bindings(engine, _Seen(), auto_review=True, hermes_review=True,
+                    reviewers=(REVIEWER,), self_instance_id=SELF, liaison_db=db)
+
+
+def test_full_loop_perceive_then_auto_apply(tmp_path):
+    db = tmp_path / "liaison.db"
+    chan, led = _host_act(tmp_path)
+
+    # 1. propose a require_approval act -> parks pending in the real ledger.
+    out = chan.propose({"tool": "deploy", "args": {"env": "prod"},
+                        "rationale": "ship", "expected_outcome": "live"})
+    assert out["status"] == "pending_approval"
+    rid = out["ledger_id"]
+    assert led.get(rid)["status"] == "proposed"
+
+    # 2. an allowlisted reviewer sends an approve verdict for THIS act's fp.
+    row = chan.pending(10)[0]
+    fp = review.fingerprint(SELF, row["goal_fp"], row["tool"],
+                            json.loads(row["args_json"]), row["id"])
+    mailbox.send(db, from_instance=REVIEWER, to_instance=SELF,
+                 type="review_verdict",
+                 payload=review.build_verdict(fp=fp, decision="approve",
+                                              reason=""))
+
+    # 3. DAEMON side: RelaySensor perceives the pending verdict, read-only.
+    frame = RelaySensor(db, SELF, [REVIEWER]).perceive()
+    assert frame.signals["review_pending"] == 1.0
+    assert mailbox.inbox(db, SELF, types=["review_verdict"],
+                         unread_only=True)            # sensor did NOT consume
+
+    # 4. SERVER side: a plain tool call (NOT poll_reviews) auto-applies it.
+    eng = _Engine(chan)
+    b = _bindings(eng, db)
+    b.call_tool("conscio.advisory", {})
+
+    # 5. the act is approved by the host_act gate, the verdict is consumed.
+    assert led.get(rid)["status"] == "executing"
+    assert mailbox.inbox(db, SELF, types=["review_verdict"],
+                         unread_only=True) == []
+    led.close()
+
+
+def test_non_peer_verdict_does_not_apply(tmp_path):
+    """A verdict from a non-allowlisted sender never moves the act."""
+    db = tmp_path / "liaison.db"
+    chan, led = _host_act(tmp_path)
+    out = chan.propose({"tool": "deploy", "args": {"env": "prod"},
+                        "rationale": "ship", "expected_outcome": "live"})
+    rid = out["ledger_id"]
+    row = chan.pending(10)[0]
+    fp = review.fingerprint(SELF, row["goal_fp"], row["tool"],
+                            json.loads(row["args_json"]), row["id"])
+    mailbox.send(db, from_instance="stranger-9999", to_instance=SELF,
+                 type="review_verdict",
+                 payload=review.build_verdict(fp=fp, decision="approve",
+                                              reason=""))
+    b = _bindings(_Engine(chan), db)
+    b.call_tool("conscio.advisory", {})
+    assert led.get(rid)["status"] == "proposed"       # untouched
+    led.close()