arkaos 4.16.0 → 4.18.0

package/core/agents/registry_gen.py

@@ -11,6 +11,77 @@ from datetime import datetime
 from pathlib import Path
 
 from core.agents.loader import load_agent
+from core.agents.provenance import Provenance, agent_provenance
+
+
+def _provenance_entry(prov: Provenance) -> dict:
+    """The full origin/source/licence trail for the registry — not just
+    origin, so the shipped file can answer 'what licence is this under?'."""
+    entry = {"origin": prov.origin}
+    if not prov.is_first_party:
+        entry["source"] = prov.source
+        entry["license"] = prov.license
+    return entry
+
+
+def _dna_dict(dna) -> dict:
+    """The four-framework behavioral DNA, flattened for the registry."""
+    return {
+        "disc": {
+            "primary": dna.disc.primary.value,
+            "secondary": dna.disc.secondary.value,
+            "label": dna.disc.label,
+        },
+        "enneagram": {
+            "type": dna.enneagram.type.value,
+            "wing": dna.enneagram.wing,
+            "label": dna.enneagram.label,
+        },
+        "big_five": {
+            "O": dna.big_five.openness,
+            "C": dna.big_five.conscientiousness,
+            "E": dna.big_five.extraversion,
+            "A": dna.big_five.agreeableness,
+            "N": dna.big_five.neuroticism,
+        },
+        "mbti": dna.mbti.type.value,
+    }
+
+
+def _agent_entry(agent, prov: Provenance, yaml_file: Path, root: Path) -> dict:
+    """One registry entry for a loaded agent + its provenance."""
+    return {
+        "id": agent.id,
+        "name": agent.name,
+        "role": agent.role,
+        "department": agent.department,
+        "tier": agent.tier,
+        "model": agent.get_model(),
+        "provenance": _provenance_entry(prov),
+        "parent_squad": agent.parent_squad,
+        "sub_squad_role": agent.sub_squad_role,
+        **_dna_dict(agent.behavioral_dna),
+        "authority": {
+            k: v for k, v in agent.authority.model_dump().items()
+            if v and v != [] and k not in ("delegates_to", "escalates_to")
+        },
+        "expertise_domains": agent.expertise.domains,
+        "frameworks": agent.expertise.frameworks,
+        "knowledge_sources": agent.expertise.knowledge_sources,
+        "file": str(yaml_file.relative_to(root)),
+        "memory_path": agent.memory_path,
+    }
+
+
+def _summaries(agents: list[dict]) -> dict:
+    """Tier, department, and DISC-primary counts for the registry meta."""
+    tiers, depts, disc = {}, {}, {}
+    for a in agents:
+        tiers[a["tier"]] = tiers.get(a["tier"], 0) + 1
+        depts[a["department"]] = depts.get(a["department"], 0) + 1
+        primary = a["disc"]["primary"]
+        disc[primary] = disc.get(primary, 0) + 1
+    return {"tiers": tiers, "departments": depts, "disc_distribution": disc}
 
 
 def generate_registry(departments_dir: str | Path, output_path: str | Path) -> dict:
@@ -34,72 +105,19 @@ def generate_registry(departments_dir: str | Path, output_path: str | Path) -> d
     for yaml_file in sorted(departments_dir.glob("*/agents/**/*.yaml")):
         try:
             agent = load_agent(yaml_file)
-            entry = {
-                "id": agent.id,
-                "name": agent.name,
-                "role": agent.role,
-                "department": agent.department,
-                "tier": agent.tier,
-                "model": agent.get_model(),
-                "parent_squad": agent.parent_squad,
-                "sub_squad_role": agent.sub_squad_role,
-                "disc": {
-                    "primary": agent.behavioral_dna.disc.primary.value,
-                    "secondary": agent.behavioral_dna.disc.secondary.value,
-                    "label": agent.behavioral_dna.disc.label,
-                },
-                "enneagram": {
-                    "type": agent.behavioral_dna.enneagram.type.value,
-                    "wing": agent.behavioral_dna.enneagram.wing,
-                    "label": agent.behavioral_dna.enneagram.label,
-                },
-                "big_five": {
-                    "O": agent.behavioral_dna.big_five.openness,
-                    "C": agent.behavioral_dna.big_five.conscientiousness,
-                    "E": agent.behavioral_dna.big_five.extraversion,
-                    "A": agent.behavioral_dna.big_five.agreeableness,
-                    "N": agent.behavioral_dna.big_five.neuroticism,
-                },
-                "mbti": agent.behavioral_dna.mbti.type.value,
-                "authority": {
-                    k: v for k, v in agent.authority.model_dump().items()
-                    if v and v != [] and k not in ("delegates_to", "escalates_to")
-                },
-                "expertise_domains": agent.expertise.domains,
-                "frameworks": agent.expertise.frameworks,
-                "knowledge_sources": agent.expertise.knowledge_sources,
-                "file": str(yaml_file.relative_to(departments_dir.parent)),
-                "memory_path": agent.memory_path,
-            }
-            agents.append(entry)
+            prov = agent_provenance(yaml_file)
+            agents.append(_agent_entry(
+                agent, prov, yaml_file, departments_dir.parent))
         except Exception as e:
             errors.append(f"{yaml_file.name}: {e}")
 
-    # Build tier summary
-    tier_counts = {}
-    for a in agents:
-        tier_counts[a["tier"]] = tier_counts.get(a["tier"], 0) + 1
-
-    # Build department summary
-    dept_counts = {}
-    for a in agents:
-        dept_counts[a["department"]] = dept_counts.get(a["department"], 0) + 1
-
-    # Build DISC distribution
-    disc_counts = {}
-    for a in agents:
-        p = a["disc"]["primary"]
-        disc_counts[p] = disc_counts.get(p, 0) + 1
-
     registry = {
         "_meta": {
             "version": "2.0.0",
             "generated": datetime.now().isoformat(),
             "total_agents": len(agents),
             "generator": "core/agents/registry_gen.py",
-            "tiers": tier_counts,
-            "departments": dept_counts,
-            "disc_distribution": disc_counts,
+            **_summaries(agents),
         },
         "agents": agents,
     }

package/core/cognition/insights/store.py

@@ -5,10 +5,14 @@ project filtering, presentation lifecycle, and dismissal analytics.
 """
 
 import sqlite3
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from pathlib import Path
 
-from core.cognition.memory.schemas import ActionableInsight
+from core.cognition.memory.schemas import (
+    INSTINCT_CONFIDENCE_MAX,
+    INSTINCT_CONFIDENCE_MIN,
+    ActionableInsight,
+)
 
 
 class InsightStore:
@@ -26,6 +30,27 @@ class InsightStore:
         conn.execute("PRAGMA journal_mode=WAL")
         return conn
 
+    # Instinct columns added after the original 12-column schema. An
+    # operator's existing DB has the old shape, so these are ALTER-added
+    # with defaults rather than baked into CREATE TABLE — a fresh install
+    # gets them from CREATE, an upgrade gets them from _migrate.
+    #
+    # Each entry carries the FULL, literal ALTER statement — never an
+    # f-string built from parts. SQLite cannot parameterise a DDL
+    # identifier, so the only safe construction is a constant statement,
+    # and a constant statement is also the only one a scanner can trust:
+    # there is no interpolation site to become an injection the day these
+    # names turn dynamic.
+    _INSTINCT_COLUMNS = (
+        ("confidence",
+         "ALTER TABLE insights ADD COLUMN confidence REAL NOT NULL DEFAULT 0.5"),
+        ("scope",
+         "ALTER TABLE insights ADD COLUMN scope TEXT NOT NULL DEFAULT 'project'"),
+        ("evidence_count",
+         "ALTER TABLE insights ADD COLUMN evidence_count "
+         "INTEGER NOT NULL DEFAULT 1"),
+    )
+
     def _init_db(self) -> None:
         with self._conn() as conn:
             conn.execute("""
@@ -41,9 +66,13 @@ class InsightStore:
                     recommendation TEXT NOT NULL,
                     context TEXT NOT NULL,
                     status TEXT NOT NULL DEFAULT 'pending',
-                    presented_at TEXT
+                    presented_at TEXT,
+                    confidence REAL NOT NULL DEFAULT 0.5,
+                    scope TEXT NOT NULL DEFAULT 'project',
+                    evidence_count INTEGER NOT NULL DEFAULT 1
                 )
             """)
+            self._migrate(conn)
             conn.execute(
                 "CREATE INDEX IF NOT EXISTS idx_insights_project ON insights (project)"
             )
@@ -51,6 +80,16 @@ class InsightStore:
                 "CREATE INDEX IF NOT EXISTS idx_insights_status ON insights (status)"
             )
 
+    def _migrate(self, conn: sqlite3.Connection) -> None:
+        """Add instinct columns to a pre-existing table. Idempotent."""
+        existing = {
+            row["name"]
+            for row in conn.execute("PRAGMA table_info(insights)").fetchall()
+        }
+        for name, alter_stmt in self._INSTINCT_COLUMNS:
+            if name not in existing:
+                conn.execute(alter_stmt)
+
     def _row_to_insight(self, row: sqlite3.Row) -> ActionableInsight:
         data = dict(row)
         # Map trigger_source back to trigger (SQL keyword workaround)
@@ -69,8 +108,8 @@ class InsightStore:
                 INSERT OR REPLACE INTO insights
                     (id, project, trigger_source, date_generated, category,
                      severity, title, description, recommendation, context,
-                     status, presented_at)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                     status, presented_at, confidence, scope, evidence_count)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                 """,
                 (
                     insight.id,
@@ -85,6 +124,9 @@ class InsightStore:
                     insight.context,
                     insight.status,
                     insight.presented_at.isoformat() if insight.presented_at else None,
+                    insight.confidence,
+                    insight.scope,
+                    insight.evidence_count,
                 ),
             )
 
@@ -130,11 +172,12 @@ class InsightStore:
         """Mark insights as presented and record the timestamp."""
         if not ids:
             return
-        now = datetime.now(timezone.utc).isoformat()
+        now = datetime.now(UTC).isoformat()
         placeholders = ",".join("?" * len(ids))
         with self._conn() as conn:
             conn.execute(
-                f"UPDATE insights SET status = 'presented', presented_at = ? WHERE id IN ({placeholders})",
+                "UPDATE insights SET status = 'presented', presented_at = ? "
+                f"WHERE id IN ({placeholders})",
                 [now, *ids],
             )
 
@@ -151,5 +194,69 @@ class InsightStore:
             ).fetchall()
         return {r["category"]: r["cnt"] for r in rows}
 
+    def reinforce(self, insight_id: str, step: float = 0.1) -> None:
+        """Corroboration: raise confidence (clamped) and count evidence.
+
+        The clamp lives in ``ActionableInsight``; the SQL bounds mirror it
+        so a direct UPDATE cannot push a value past the band either.
+        """
+        with self._conn() as conn:
+            conn.execute(
+                """
+                UPDATE insights
+                SET confidence = MIN(?, confidence + ?),
+                    evidence_count = evidence_count + 1
+                WHERE id = ?
+                """,
+                (INSTINCT_CONFIDENCE_MAX, step, insight_id),
+            )
+
+    def weaken(self, insight_id: str, step: float = 0.2) -> None:
+        """Contradiction: lower confidence (clamped to the band floor).
+
+        A correction cuts harder than a corroboration lifts — the default
+        step is larger — because one contradiction outweighs several
+        passive confirmations.
+        """
+        with self._conn() as conn:
+            conn.execute(
+                "UPDATE insights SET confidence = MAX(?, confidence - ?) WHERE id = ?",
+                (INSTINCT_CONFIDENCE_MIN, step, insight_id),
+            )
+
+    def promotable(
+        self, min_projects: int = 2, min_confidence: float = 0.8
+    ) -> list[str]:
+        """Titles seen as project-scoped across >= min_projects distinct
+        projects with mean confidence >= min_confidence.
+
+        The signal B7 (``/arka promote``) consumes: a pattern that has
+        proven itself in more than one project has earned global scope.
+        Grouped by title because that is the instinct's stable identity
+        across projects (the id is per-occurrence).
+        """
+        with self._conn() as conn:
+            rows = conn.execute(
+                """
+                SELECT title FROM insights
+                WHERE scope = 'project'
+                GROUP BY title
+                HAVING COUNT(DISTINCT project) >= ?
+                   AND AVG(confidence) >= ?
+                """,
+                (min_projects, min_confidence),
+            ).fetchall()
+        return [r["title"] for r in rows]
+
+    def promote_to_global(self, title: str) -> int:
+        """Flip every project-scoped insight with this title to global.
+        Returns the number of rows promoted."""
+        with self._conn() as conn:
+            cur = conn.execute(
+                "UPDATE insights SET scope = 'global' WHERE title = ? AND scope = 'project'",
+                (title,),
+            )
+            return cur.rowcount
+
     def close(self) -> None:
         """No-op — connections are opened per-operation."""

package/core/cognition/memory/schemas.py

@@ -7,12 +7,10 @@ Three core models:
 """
 
 import uuid
-from datetime import datetime, timezone
-from typing import Literal
+from datetime import UTC, datetime
 
 from pydantic import BaseModel, Field, field_validator
 
-
 # --- Allowed categories and statuses ---
 
 RAW_CAPTURE_CATEGORIES = ("decision", "solution", "pattern", "error", "config")
@@ -35,7 +33,7 @@ ACTIONABLE_INSIGHT_STATUSES = ("pending", "presented", "accepted", "dismissed")
 
 
 def _utc_now() -> datetime:
-    return datetime.now(timezone.utc)
+    return datetime.now(UTC)
 
 
 def _new_uuid() -> str:
@@ -97,8 +95,26 @@ class KnowledgeEntry(BaseModel):
         return max(0.0, min(1.0, v))
 
 
+# Instinct confidence lives in a band, never at the poles. 0.3 is a weak
+# hypothesis worth keeping; 0.9 is strong but never certainty (an agent
+# that is "certain" from a handful of observations is the failure the
+# band prevents). Mirrors the ECC continuous-learning instinct model.
+INSTINCT_CONFIDENCE_MIN = 0.3
+INSTINCT_CONFIDENCE_MAX = 0.9
+INSTINCT_SCOPES = ("project", "global")
+
+
 class ActionableInsight(BaseModel):
-    """Actionable insight — generated by agents for proactive presentation."""
+    """Actionable insight — generated by agents for proactive presentation.
+
+    Carries the ECC-style instinct fields (confidence, scope,
+    evidence_count) so an insight can strengthen on corroboration, weaken
+    on contradiction, and be promoted from project to global once the
+    same signal is seen across enough projects with high enough mean
+    confidence (see ``InsightStore.promotable``). All three default to
+    backwards-compatible values, so an insight written before this schema
+    reads as a fresh, project-scoped hypothesis.
+    """
 
     id: str = Field(default_factory=_new_uuid)
     project: str
@@ -113,6 +129,30 @@ class ActionableInsight(BaseModel):
     status: str = "pending"
     presented_at: datetime | None = None
 
+    confidence: float = 0.5
+    scope: str = "project"
+    evidence_count: int = 1
+
+    @field_validator("confidence")
+    @classmethod
+    def clamp_confidence(cls, v: float) -> float:
+        """Confidence is bounded to the instinct band, never the poles."""
+        return max(INSTINCT_CONFIDENCE_MIN, min(INSTINCT_CONFIDENCE_MAX, v))
+
+    @field_validator("scope")
+    @classmethod
+    def validate_scope(cls, v: str) -> str:
+        if v not in INSTINCT_SCOPES:
+            raise ValueError(
+                f"Invalid scope '{v}'. Must be one of: {INSTINCT_SCOPES}"
+            )
+        return v
+
+    @field_validator("evidence_count")
+    @classmethod
+    def evidence_count_is_positive(cls, v: int) -> int:
+        return max(1, v)
+
     @field_validator("category")
     @classmethod
     def validate_category(cls, v: str) -> str: