apsimo 1.3.0__py3-none-any.whl

apsimo/identity_bootstrap/seeders/world_model.py

@@ -0,0 +1,143 @@
+"""World Model seeder — creates self + subsystem ConceptEntities in the SQLite world model."""
+
+from __future__ import annotations
+
+import logging
+import time
+import secrets
+from datetime import datetime, timezone
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def _wm_id() -> str:
+    ts = int(time.time() * 1000)
+    rand = secrets.token_hex(4)
+    return f"we-{ts}-{rand}"
+
+
+def _wr_id() -> str:
+    ts = int(time.time() * 1000)
+    rand = secrets.token_hex(4)
+    return f"wr-{ts}-{rand}"
+
+
+def _now_dt() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+class WorldModelSeeder:
+    name = "world_model"
+
+    async def seed(self, corpus: Any) -> None:
+        """Seed self-knowledge entities into the world model."""
+        try:
+            import colony.api.routers.world as wm_mod
+            backend = getattr(wm_mod, "_wm_backend", None)
+        except ImportError:
+            logger.debug("world_model: router not importable — skipping")
+            return
+
+        if backend is None:
+            logger.debug("world_model: _wm_backend is None — skipping")
+            return
+
+        from apsimo.world_model.entities import ConceptEntity
+        from apsimo.world_model.relationships import WorldRelationship
+
+        colony_id = corpus.colony_id
+        now = _now_dt()
+
+        # Self entity
+        self_id = f"colony-self-{colony_id}"
+        self_entity = ConceptEntity(
+            id=self_id,
+            name=corpus.colony_name,
+            entity_type="concept",
+            concept_type="colony_instance",
+            aliases=[colony_id, "self", corpus.colony_name],
+            confidence=1.0,
+            properties={
+                "colony_id": colony_id,
+                "colony_version": corpus.colony_version,
+                "network_id": corpus.network_id,
+                "public_key_hex": corpus.public_key_hex,
+                "corpus_version": corpus.corpus_version,
+            },
+            first_seen=now,
+            last_seen=now,
+            created_at=now,
+            updated_at=now,
+        )
+        try:
+            await backend.upsert_entity(self_entity)
+        except Exception as exc:
+            logger.warning("world_model: failed to upsert self entity: %s", exc)
+            return
+
+        # Subsystem concept entities + WM_PART_OF relationships
+        from apsimo.identity_bootstrap.corpus import SUBSYSTEMS
+        for subsystem in SUBSYSTEMS:
+            sub_id = f"colony-subsystem-{colony_id}-{subsystem}"
+            sub_entity = ConceptEntity(
+                id=sub_id,
+                name=f"{subsystem} subsystem",
+                entity_type="concept",
+                concept_type="colony_subsystem",
+                aliases=[subsystem],
+                confidence=1.0,
+                properties={
+                    "subsystem_name": subsystem,
+                    "parent_colony_id": colony_id,
+                },
+                first_seen=now,
+                last_seen=now,
+                created_at=now,
+                updated_at=now,
+            )
+            try:
+                await backend.upsert_entity(sub_entity)
+            except Exception as exc:
+                logger.warning("world_model: failed to upsert subsystem %s: %s", subsystem, exc)
+                continue
+
+            # WM_PART_OF: subsystem → self
+            rel_part_of = WorldRelationship(
+                id=_wr_id(),
+                source_id=sub_id,
+                target_id=self_id,
+                relationship_type="WM_PART_OF",
+                confidence=1.0,
+                properties={"seeded_by": "identity_bootstrap"},
+            )
+            try:
+                await backend.upsert_relationship(rel_part_of)
+            except Exception as exc:
+                logger.warning("world_model: WM_PART_OF rel failed for %s: %s", subsystem, exc)
+
+        # WM_DEPENDS_ON: goals → task_queue, intelligence → world_model
+        dep_pairs = [
+            ("goals", "task_queue"),
+            ("intelligence", "world_model"),
+            ("briefings", "goals"),
+            ("skills", "task_queue"),
+            ("federation", "world_model"),
+        ]
+        for src_sub, tgt_sub in dep_pairs:
+            src_id = f"colony-subsystem-{colony_id}-{src_sub}"
+            tgt_id = f"colony-subsystem-{colony_id}-{tgt_sub}"
+            rel = WorldRelationship(
+                id=_wr_id(),
+                source_id=src_id,
+                target_id=tgt_id,
+                relationship_type="WM_DEPENDS_ON",
+                confidence=0.95,
+                properties={"seeded_by": "identity_bootstrap"},
+            )
+            try:
+                await backend.upsert_relationship(rel)
+            except Exception as exc:
+                logger.debug("world_model: WM_DEPENDS_ON %s→%s failed: %s", src_sub, tgt_sub, exc)
+
+        logger.info("world_model: seeded self + %d subsystems", len(SUBSYSTEMS))

apsimo/identity_bootstrap/self_query.py

@@ -0,0 +1,92 @@
+"""Colony Identity Bootstrap — self-referential query detection.
+
+Detects user messages that ask about Colony's own capabilities,
+architecture, or identity, and builds grounding context from the
+self-knowledge corpus so the agent can answer accurately.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+# Pre-compiled patterns for self-referential query detection.
+# Each pattern targets a class of question about Colony's own capabilities.
+_SELF_PATTERNS = [
+    # Capability / feature queries
+    re.compile(r"\bwhat\b.*\b(?:can you do|are your capabilities|features)\b", re.I),
+    re.compile(r"\bwhat\b.*\b(?:tools|commands|skills)\b.*\b(?:do you|you)\b", re.I),
+    re.compile(r"\bhow\b.*\bdo you work\b", re.I),
+    re.compile(r"\bwhat\b.*\b(?:endpoints?|api|routes?)\b.*\b(?:do you have|available|support)\b", re.I),
+    re.compile(r"\bwhat\b.*\bcommands?\b.*\b(?:do you|you)\b.*\bsupport\b", re.I),
+    # Architecture queries
+    re.compile(r"\bhow many\b.*\blayers?\b", re.I),
+    re.compile(r"\bwhat\b.*\b(?:is|are)\b.*\byour\b.*\barchitecture\b", re.I),
+    re.compile(r"\bwhat\b.*\bmodels?\b.*\b(?:do you use|you use)\b", re.I),
+    re.compile(r"\bwhat\b.*\b(?:inference|llm)\b.*\btiers?\b", re.I),
+    # Safety / gate queries
+    re.compile(r"\bwhat\b.*\b(?:safety|gate|security)\b.*\blayers?\b", re.I),
+    re.compile(r"\bresponse\s*gate\b", re.I),
+    # Identity queries
+    re.compile(r"\bwho\b.*\bare you\b", re.I),
+    re.compile(r"\bwhat\b.*\bare you\b", re.I),
+    re.compile(r"\btell me about yourself\b", re.I),
+    re.compile(r"\bdescribe yourself\b", re.I),
+    re.compile(r"\byour\b.*\b(?:version|colony.?id|identity)\b", re.I),
+    # Cognition pipeline queries
+    re.compile(r"\bcognition\b.*\b(?:pipeline|phases?)\b", re.I),
+    re.compile(r"\bself.?(?:improvement|learning|reflection)\b", re.I),
+    # Subsystem queries
+    re.compile(r"\bwhat\b.*\bsubsystems?\b", re.I),
+    re.compile(r"\blist\b.*\byour\b.*\b(?:systems?|components?)\b", re.I),
+]
+
+
+def query_is_self_referential(message: str) -> bool:
+    """Return True if *message* is asking about Colony's own capabilities."""
+    if not message or len(message) < 8:
+        return False
+    for pattern in _SELF_PATTERNS:
+        if pattern.search(message):
+            return True
+    return False
+
+
+def build_self_context_from_corpus() -> Optional[str]:
+    """Build a grounding context block from the live SelfKnowledgeCorpus.
+
+    Returns a formatted string suitable for injection into the agent's
+    prompt, or None if the corpus cannot be loaded.
+    """
+    try:
+        from apsimo.identity_bootstrap.builder import IdentityBootstrapBuilder
+
+        builder = IdentityBootstrapBuilder()
+        corpus = builder.build()
+    except Exception:
+        return None
+
+    lines = [
+        "# Colony Self-Knowledge (auto-injected)",
+        "",
+        f"**Identity:** {corpus.colony_name} (ID: {corpus.colony_id}, "
+        f"v{corpus.colony_version}, network: {corpus.network_id})",
+        "",
+        f"**Architecture:** {len(corpus.layers)} layers — "
+        + ", ".join(l.name for l in corpus.layers),
+        "",
+        f"**API Endpoints:** {len(corpus.api_endpoints)} across "
+        f"{len(set(e.router for e in corpus.api_endpoints))} routers: "
+        + ", ".join(sorted(set(e.router for e in corpus.api_endpoints))),
+        "",
+        f"**Cognition Pipeline:** {len(corpus.cognition_phases)} phases — "
+        + ", ".join(p.name for p in corpus.cognition_phases),
+        "",
+        f"**ResponseGate:** {len(corpus.gate_layers)} safety layers — "
+        + ", ".join(g.name for g in corpus.gate_layers),
+        "",
+        f"**Inference Tiers:** {len(corpus.inference_tiers)} — "
+        + ", ".join(f"{t.name} ({t.complexity_range})" for t in corpus.inference_tiers),
+        "",
+    ]
+    return "\n".join(lines)

apsimo/identity_bootstrap/self_reflection.py

@@ -0,0 +1,155 @@
+"""Colony Identity Bootstrap — SelfReflectionComponent.
+
+Provides a lightweight self-reflection entry point for the CIB system.
+A full self-reflection run analyses the bootstrap report anomalies
+and produces an improvement proposal.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Any, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class SelfReflectionResult:
+    """Output of one self-reflection cycle."""
+    colony_id: str
+    health_score: float          # 0.0–1.0; 1.0 = all checks passed
+    critical_anomaly_count: int
+    warning_anomaly_count: int
+    improvement_proposals: List[str] = field(default_factory=list)
+    raw_notes: str = ""
+
+    @property
+    def healthy(self) -> bool:
+        return self.critical_anomaly_count == 0 and self.health_score >= 0.8
+
+
+class SelfReflectionComponent:
+    """Analyses bootstrap anomalies and proposes improvements.
+
+    This is a lightweight reflection component — it does not call an LLM.
+    It uses rule-based heuristics over the anomaly list to generate proposals.
+    """
+
+    def __init__(self, metrics_collector: Optional[Any] = None) -> None:
+        self._metrics = metrics_collector
+
+    async def reflect(
+        self,
+        corpus: Any,
+        anomalies: List[Any],
+    ) -> SelfReflectionResult:
+        """Reflect on the given anomaly list and return a result."""
+        colony_id = corpus.colony_id
+        critical = [a for a in anomalies if a.severity == "CRITICAL"]
+        warnings = [a for a in anomalies if a.severity == "WARNING"]
+
+        total_checks = 18
+        passed = total_checks - len(anomalies)
+        health_score = max(0.0, passed / total_checks)
+
+        proposals = self._generate_proposals(critical, warnings)
+
+        notes = self._build_notes(colony_id, corpus, critical, warnings, health_score)
+
+        result = SelfReflectionResult(
+            colony_id=colony_id,
+            health_score=health_score,
+            critical_anomaly_count=len(critical),
+            warning_anomaly_count=len(warnings),
+            improvement_proposals=proposals,
+            raw_notes=notes,
+        )
+
+        # Record metric if available
+        if self._metrics is not None:
+            try:
+                await self._metrics.record(
+                    metric_type="bootstrap_health_score",
+                    value=health_score,
+                    domain="identity",
+                    context={"colony_id": colony_id},
+                )
+            except Exception as exc:
+                logger.debug("self_reflection: metrics record failed: %s", exc)
+
+        logger.info(
+            "self_reflection: colony=%s health=%.2f critical=%d warnings=%d",
+            colony_id,
+            health_score,
+            len(critical),
+            len(warnings),
+        )
+        return result
+
+    def _generate_proposals(self, critical: List[Any], warnings: List[Any]) -> List[str]:
+        proposals: List[str] = []
+
+        systems_with_issues = {a.system for a in critical + warnings}
+
+        if "world_model" in systems_with_issues:
+            proposals.append(
+                "Re-run WorldModelSeeder: world model entity or relationship is missing."
+            )
+        if "contacts" in systems_with_issues:
+            proposals.append(
+                "Re-run RelationshipSeeder: self-contact not found in contacts store."
+            )
+        if "memory" in systems_with_issues:
+            proposals.append(
+                "Re-run MemorySeeder: foundational memory entries are missing."
+            )
+        if "goals" in systems_with_issues:
+            proposals.append(
+                "Re-run GoalsSeeder: system goals not found — GoalStore may have been reset."
+            )
+        if "briefings" in systems_with_issues:
+            proposals.append(
+                "Re-run BriefingsSeeder: welcome briefing not found."
+            )
+        if "sessions" in systems_with_issues:
+            proposals.append(
+                "Re-run SessionsSeeder: bootstrap session record not found."
+            )
+        if "corpus" in systems_with_issues:
+            proposals.append(
+                "Update the identity_bootstrap corpus to match the current Colony version."
+            )
+        if any(a.check == "colony_id_set" for a in critical):
+            proposals.append(
+                "Set COLONY_ID env var or ensure ChainManager is initialized before bootstrap."
+            )
+
+        if not proposals and not critical and not warnings:
+            proposals.append("All checks passed — no improvements required.")
+
+        return proposals
+
+    def _build_notes(
+        self,
+        colony_id: str,
+        corpus: Any,
+        critical: List[Any],
+        warnings: List[Any],
+        health_score: float,
+    ) -> str:
+        lines = [
+            f"Colony: {corpus.colony_name} ({colony_id})",
+            f"Version: {corpus.colony_version}",
+            f"Health: {health_score:.0%}",
+            f"Critical: {len(critical)}  Warnings: {len(warnings)}",
+        ]
+        if critical:
+            lines.append("--- CRITICAL ---")
+            for a in critical:
+                lines.append(f"  [{a.system}] {a.check}: expected={a.expected!r} actual={a.actual!r}")
+        if warnings:
+            lines.append("--- WARNINGS ---")
+            for a in warnings:
+                lines.append(f"  [{a.system}] {a.check}: expected={a.expected!r} actual={a.actual!r}")
+        return "\n".join(lines)

apsimo/identity_bootstrap/skill.py

@@ -0,0 +1,37 @@
+"""bootstrap_self_check skill entry point.
+
+Registered in the Colony skill registry as 'bootstrap-self-check'.
+Runs the 16-point self-check matrix and returns a verification report.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+
+async def run(colony_id: Optional[str] = None, mode: str = "full") -> dict:
+    """Run the Colony Identity Bootstrap self-check.
+
+    Args:
+        colony_id: Override colony_id (default: read from running instance).
+        mode: "full" to run all checks, "quick" to skip slow subsystem checks.
+
+    Returns:
+        Dict with verified_systems, failed_systems, anomalies, success.
+    """
+    from apsimo.identity_bootstrap.runner import IdentityBootstrap
+
+    bootstrap = IdentityBootstrap()
+    report = await bootstrap.verify_only()
+
+    return {
+        "colony_id": report.colony_id,
+        "mode": report.mode,
+        "verified_systems": report.verified_systems,
+        "failed_systems": report.failed_systems,
+        "anomalies": [a.to_dict() for a in report.anomalies],
+        "success": report.success,
+        "corpus_version": report.corpus_version,
+        "started_at": report.started_at,
+        "completed_at": report.completed_at,
+    }