@agentikos/omega-os 0.1.0 → 0.2.0

package/README.md

@@ -107,19 +107,31 @@ Details: [`docs/INSTALL.md`](docs/INSTALL.md).
 This repository is the **product**: its installer, run on a fresh machine,
 produces a running `~/Omega/` deployment.
 
-The **orchestration runtime is implemented and tested.** `omega run` executes a
-real mission (`Oracle → Worker → Verifier → VERIFIED`), the Oracle emits a
-whitepaper **PDF report**, progress streams live to a **Telegram topic** with a
-progress bar, and `omega project` creates a project with its bound topic.
-
-The **Quality Arsenal — 18 forensic audits** (code, security, performance, a11y,
-…) is wired into the verification gate: when a worker claims done, the
-`ArsenalGate` runs the audits that apply (deterministic tools + an agentic
-Gestalt-Popper falsification pass) and a task reaches `VERIFIED` only if it
-passes. The engine test suite is green.
-
-Still build-out: the 8 educators, the RAG subsystem, autonomous-agent daemons,
-and the 24/7 service layer — see [`docs/RUNTIME-PLAN.md`](docs/RUNTIME-PLAN.md).
+The **whole runtime is implemented and tested.** `omega run` executes a real
+mission (`Oracle → Worker → Verifier → VERIFIED`), the Oracle emits a whitepaper
+**PDF report**, progress streams live to a **Telegram topic** with a progress
+bar, `omega project` creates a project with its bound topic.
+
+The **Quality Arsenal — 18 forensic audits** is wired into the verification
+gate: when a worker claims done, the `ArsenalGate` runs the audits that apply
+(deterministic tools + an agentic Gestalt-Popper falsification pass) and a task
+reaches `VERIFIED` only if it passes.
+
+The **self-improving layer** runs: the **8 educators** generate SSOT artifacts
+under quality-gated staging; the **multi-RAG subsystem** (Hybrid + Graph +
+Agentic + Corrective + Multimodal + agentic router) feeds context to every
+level; the **autonomous-agent supervisor** drives persistent charters with cron
+/ channel / webhook / event triggers; the **24/7 daemons** (`omega daemon
+engine|telegram|autonomous`) keep it running as `systemd` user services.
+
+The **multi-LLM layer** is real: `ClaudeProvider`, `GLMProvider`,
+`OpenAIProvider`, `DeepSeekProvider` all behind one contract. The **account
+pool** (OAuth + encrypted vault) and the live `omega billing` aggregation work
+end to end. The **installer** (`step_mcp`) really installs MCP servers from the
+catalog and `omega sync` projects the SSOT to Claude Code's native layout.
+
+**81 tests across 13 files, all green** — end-to-end mission, live PDF, forensic
+gate, autonomous supervisor, multi-RAG, account vault, snapshot + PARTIAL.
 
 ---
 

package/bootstrap/lib/steps.sh

@@ -66,21 +66,226 @@ step_engine() {
 }
 
 # --- 40 -----------------------------------------------------------------------
+#
+# step_mcp — present the MCP/plugin catalog as a checklist (interactive) or
+# apply the manifest's `mcp:` list (headless). For each selected entry:
+#   1. install the server binary into Agentik_Tools/<id>/
+#   2. read any declared secrets from env or prompt; write them chmod 600 into
+#      Agentik_Extra/etc/secrets/mcp-<id>.env
+#   3. add a `{id, secret_refs, enabled: true}` row to mcp-config.yaml
+# Then call `omega sync` to project the config into each provider's native shape.
+#
+# Failures on individual MCPs are recorded but do not abort the step.
 step_mcp() {
   local catalog="$OMEGA_HOME/Agentik_SSOT/mcp/mcp-catalog.yaml"
   [ -f "$catalog" ] || { err "MCP catalog missing: $catalog"; return 1; }
   info "MCP catalog present ($(grep -c '^- id:' "$catalog" 2>/dev/null || echo '?') entries)"
+
+  # Collect the selection into newline-separated $selected.
+  local selected=""
   if [ "${NONINTERACTIVE:-0}" = "1" ]; then
-    info "headless — MCP selection comes from the manifest (\`mcp:\` list)"
+    if [ -z "${MANIFEST:-}" ] || [ ! -f "$MANIFEST" ]; then
+      info "headless but no manifest provided — selecting recommended MCPs only"
+      selected="$(_mcp_recommended "$catalog")"
+    else
+      selected="$(_mcp_from_manifest "$MANIFEST")"
+      if [ -z "$selected" ]; then
+        info "manifest has no \`mcp:\` list — selecting recommended MCPs only"
+        selected="$(_mcp_recommended "$catalog")"
+      fi
+    fi
   else
-    info "interactive — the MCP/plugin checklist reads $catalog"
+    selected="$(_mcp_prompt_checklist "$catalog")"
+  fi
+
+  if [ -z "$selected" ]; then
+    info "no MCPs selected — skipping install (you can run \`omega tool install <id>\` later)"
+    return 0
+  fi
+
+  local omega="$OMEGA_HOME/Agentik_Tools/bin/omega"
+  [ -x "$omega" ] || { err "omega CLI not found at $omega — step 30 incomplete"; return 1; }
+
+  local failed=""
+  local id
+  while IFS= read -r id; do
+    [ -z "$id" ] && continue
+    info "MCP: installing $id"
+    if OMEGA_HOME="$OMEGA_HOME" "$omega" tool install "$id" >>"$LOG_FILE" 2>&1; then
+      _mcp_collect_secrets "$catalog" "$id" || true
+      _mcp_register_in_config "$id"
+      ok "MCP $id installed and registered"
+    else
+      err "MCP $id failed to install — see $LOG_FILE; continuing"
+      failed="$failed $id"
+    fi
+  done <<< "$selected"
+
+  info "running \`omega sync\` to project the canonical config to each provider"
+  if OMEGA_HOME="$OMEGA_HOME" "$omega" sync >>"$LOG_FILE" 2>&1; then
+    ok "omega sync completed"
+  else
+    err "omega sync exited non-zero — see $LOG_FILE"
+  fi
+
+  if [ -n "$failed" ]; then
+    err "MCPs that failed to install:$failed (the rest were registered)"
   fi
-  # Build-out: render the checklist, install selected servers into
-  # Agentik_Tools/<id>/, write Agentik_SSOT/mcp/mcp-config.yaml, run `omega sync`.
-  # See docs/MCP-AND-PLUGINS.md.
   return 0
 }
 
+# ----- step_mcp helpers ------------------------------------------------------
+
+# _mcp_recommended <catalog> → newline-separated ids with `recommended: true`
+_mcp_recommended() {
+  local catalog="$1"
+  python3 - "$catalog" <<'PY' || true
+import sys, yaml
+with open(sys.argv[1]) as f:
+    data = yaml.safe_load(f) or {}
+for e in data.get("catalog") or []:
+    if e.get("recommended"):
+        print(e["id"])
+PY
+}
+
+# _mcp_from_manifest <manifest> → newline-separated ids in the `mcp:` block
+_mcp_from_manifest() {
+  local manifest="$1"
+  python3 - "$manifest" <<'PY' || true
+import sys, yaml
+with open(sys.argv[1]) as f:
+    data = yaml.safe_load(f) or {}
+for entry in data.get("mcp") or []:
+    if isinstance(entry, dict):
+        print(entry.get("id", "").strip())
+    else:
+        print(str(entry).strip())
+PY
+}
+
+# _mcp_catalog_ids <catalog> → newline-separated all ids
+_mcp_catalog_ids() {
+  python3 - "$1" <<'PY' || true
+import sys, yaml
+with open(sys.argv[1]) as f:
+    data = yaml.safe_load(f) or {}
+for e in data.get("catalog") or []:
+    print(e["id"])
+PY
+}
+
+# _mcp_recommended_set <catalog> → newline-separated recommended ids (alias)
+# (declared separately so the prompt code reads cleanly)
+
+# _mcp_secret_refs <catalog> <id> → space-separated secret refs for that id
+_mcp_secret_refs() {
+  python3 - "$1" "$2" <<'PY' || true
+import sys, yaml
+with open(sys.argv[1]) as f:
+    data = yaml.safe_load(f) or {}
+for e in data.get("catalog") or []:
+    if e.get("id") == sys.argv[2]:
+        for s in e.get("secrets") or []:
+            print(s)
+        break
+PY
+}
+
+# _mcp_prompt_checklist <catalog> → newline-separated selected ids (interactive)
+_mcp_prompt_checklist() {
+  local catalog="$1" id recommended_set picks="" reply
+  recommended_set=" $(_mcp_recommended "$catalog" | tr '\n' ' ')"
+  if have whiptail; then
+    # Build the whiptail args dynamically. Each tuple is: <id> <description> <ON|OFF>
+    local args=()
+    while IFS= read -r id; do
+      [ -z "$id" ] && continue
+      local pre="OFF"
+      case "$recommended_set" in *" $id "*) pre="ON" ;; esac
+      args+=("$id" "$id" "$pre")
+    done < <(_mcp_catalog_ids "$catalog")
+    if [ "${#args[@]}" -eq 0 ]; then
+      printf ''
+      return 0
+    fi
+    # capture whiptail's stderr (the selection) — quotes around each picked id
+    picks="$(whiptail --title "Omega OS — MCP / plugin checklist" \
+      --checklist "Select MCP servers to install (space toggles, enter confirms):" \
+      20 70 12 "${args[@]}" 3>&1 1>&2 2>&3 || true)"
+    # whiptail returns: "id1" "id2" "id3" — strip quotes and split on whitespace
+    printf '%s\n' $picks | tr -d '"'
+  else
+    info "(no whiptail — falling back to a plain prompt)"
+    while IFS= read -r id; do
+      [ -z "$id" ] && continue
+      local default="n" pre=""
+      case "$recommended_set" in *" $id "*) default="y"; pre=" (recommended)" ;; esac
+      printf '  install %s%s? [%s] ' "$id" "$pre" "$default" >&2
+      read -r reply || reply=""
+      reply="${reply:-$default}"
+      case "$reply" in y|Y|yes|YES) picks="$picks $id" ;; esac
+    done < <(_mcp_catalog_ids "$catalog")
+    printf '%s\n' $picks
+  fi
+}
+
+# _mcp_collect_secrets <catalog> <id> — for each declared secret, read value from
+# env or prompt, then write to Agentik_Extra/etc/secrets/mcp-<id>.env (chmod 600).
+_mcp_collect_secrets() {
+  local catalog="$1" id="$2" refs ref value
+  refs="$(_mcp_secret_refs "$catalog" "$id")"
+  [ -z "$refs" ] && return 0
+  local secdir="$OMEGA_HOME/Agentik_Extra/etc/secrets"
+  local secfile="$secdir/mcp-${id}.env"
+  mkdir -p "$secdir"
+  chmod 700 "$secdir" 2>/dev/null || true
+  : > "$secfile"
+  chmod 600 "$secfile"
+  while IFS= read -r ref; do
+    [ -z "$ref" ] && continue
+    # Prefer an env var of the same name; otherwise ask (skip prompt when headless).
+    value="${!ref:-}"
+    if [ -z "$value" ] && [ "${NONINTERACTIVE:-0}" != "1" ]; then
+      printf '  secret needed for %s: %s (paste or leave blank to set later): ' "$id" "$ref" >&2
+      read -r value || value=""
+    fi
+    if [ -n "$value" ]; then
+      printf '%s=%s\n' "$ref" "$value" >> "$secfile"
+    else
+      # store a placeholder reference so the operator can fill it in later
+      printf '# %s=  # set this when ready\n' "$ref" >> "$secfile"
+    fi
+  done <<< "$refs"
+  chmod 600 "$secfile"
+}
+
+# _mcp_register_in_config <id> — append/replace a row in mcp-config.yaml.
+_mcp_register_in_config() {
+  python3 - "$OMEGA_HOME" "$1" <<'PY' || true
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(sys.argv[1]) / "Agentik_Engine"))
+import yaml
+from omega_engine.tools import merge_mcp_config  # noqa: E402
+
+home = Path(sys.argv[1])
+mcp_id = sys.argv[2]
+
+# Pull the declared secret refs from the catalog for this id.
+catalog_path = home / "Agentik_SSOT" / "mcp" / "mcp-catalog.yaml"
+secret_refs = []
+if catalog_path.exists():
+    data = yaml.safe_load(catalog_path.read_text()) or {}
+    for e in data.get("catalog") or []:
+        if e.get("id") == mcp_id:
+            secret_refs = list(e.get("secrets") or [])
+            break
+
+merge_mcp_config(home, {"id": mcp_id, "secret_refs": secret_refs, "enabled": True})
+PY
+}
+
 # --- 50 -----------------------------------------------------------------------
 step_telegram() {
   local token
@@ -111,16 +316,16 @@ step_services() {
   fi
   if [ "$OMEGA_OS" = "linux" ]; then
     local unitdir="$HOME/.config/systemd/user"
+    local omegabin="$OMEGA_HOME/Agentik_Tools/bin/omega"
     mkdir -p "$unitdir"
-    _systemd_unit "Omega OS engine"               "$OMEGA_HOME/Agentik_Tools/bin/omega status" \
+    _systemd_unit "Omega OS engine"                "$omegabin daemon engine" \
       > "$unitdir/omega-engine.service"
-    _systemd_unit "Omega OS Telegram bridge"      "$OMEGA_HOME/Agentik_Tools/bin/omega status" \
+    _systemd_unit "Omega OS Telegram bridge"       "$omegabin daemon telegram" \
       > "$unitdir/omega-telegram.service"
-    _systemd_unit "Omega OS autonomous supervisor" "$OMEGA_HOME/Agentik_Tools/bin/omega status" \
+    _systemd_unit "Omega OS autonomous supervisor" "$omegabin daemon autonomous" \
       > "$unitdir/omega-autonomous.service"
     info "systemd user units written to $unitdir"
     info "the 24/7 layer: \`systemctl --user enable --now omega-engine omega-telegram omega-autonomous\`"
-    info "(enable once the engine daemon / bridge build-out is complete — see docs/ENGINE-SPEC.md)"
   else
     info "macOS — launchd plists for the workstation profile go here (build-out)"
   fi

package/bootstrap/manifest.example.yaml

@@ -22,7 +22,12 @@ providers:                   # which LLMs to wire, and their default roles
   #   roles: [audit]
   # credentials come from env / the vault, never from here
 
-mcp:                         # entries from Agentik_SSOT/mcp/mcp-catalog.yaml
+mcp:                         # ids from Agentik_SSOT/mcp/mcp-catalog.yaml — the
+                             # installer's step_mcp installs each into
+                             # Agentik_Tools/<id>/, writes any declared secrets
+                             # to Agentik_Extra/etc/secrets/mcp-<id>.env, and
+                             # adds the row to mcp-config.yaml; `omega sync`
+                             # then projects it to each provider's native shape.
   - filesystem
   - git
   - github

package/docs/COMPLETION-PLAN.md

@@ -0,0 +1,48 @@
+# Completion Plan — finish OmegaOS, no half-things
+
+> Across the whole conversation, the user asked for a complete agentic OS.
+> Runtime + audits + reports + Telegram + projects + npm are live. This plan
+> finishes the rest. Four-pass discipline.
+
+## Pending items (from the README "still build-out" line and the conversation)
+
+1. **The 8 educators** — real Python generators that write SSOT artifacts under a quality gate
+2. **Multi-RAG subsystem** — Hybrid, Graph, Agentic, Corrective (CRAG), Multimodal + the agentic router
+3. **Autonomous-agent supervisor + 24/7 daemons** — the actual long-running service layer
+4. **MCP install flow** — the installer's step_mcp installs the catalog (interactive + manifest)
+5. **`omega tool install`** — real tool registry management
+6. **`omega sync`** — SST → provider-native projection
+7. **Provider adapters** — GLM, OpenAI, DeepSeek (Claude already real)
+8. **Account OAuth login + live billing aggregation** — multi-account Claude Max
+9. **Event-store snapshotting** — bounded reduction time
+10. **PARTIAL policy per-topology** — refined join-barrier handling
+
+## Execution — 4 passes
+
+### Pass 1 — Plan
+This document.
+
+### Pass 2 — Dispatch + Code
+Five parallel subagents own non-overlapping workstreams. I own the integration
+glue, snapshotting, PARTIAL policy, and the integration test.
+
+| # | Subagent | Writes |
+|---|---|---|
+| 1 | The 8 educators | `omega_engine/educators/*.py` + tests |
+| 2 | Multi-RAG | `omega_engine/rag/*.py` + tests |
+| 3 | Autonomous supervisor + daemons | `omega_engine/autonomous.py`, `omega_engine/daemons/*.py`, `bootstrap/lib/steps.sh` |
+| 4 | Providers + Account | extend `provider.py`, new `account.py`, update `cli.py` |
+| 5 | Installer + Tools + Sync | extend `steps.sh` step_mcp, new `tools.py`/`sync.py`, update `cli.py` |
+
+### Pass 3 — Integrate + Verify
+Wait for subagents. Reconcile imports, run the full test suite, fix.
+
+### Pass 4 — Polish + Ship
+Update docs, bump 0.1.0 → 0.2.0, commit + push, republish to npm, verify
+`npx @agentikos/omega-os --help` on the new version.
+
+## Done when
+- Every item above has real, tested code (no spec-only).
+- `npm view @agentikos/omega-os version` returns `0.2.0`.
+- Full engine test suite green.
+- GitHub pushed.

package/omega/Agentik_Engine/README.md

@@ -12,40 +12,55 @@ with verified completion. *Who* is an oracle and *which* topology runs lives in
 |---|---|
 | `task.py` | `Task` model, `TaskState` FSM, `Kind`, `Lifecycle`, `Trigger`, `Budget` |
 | `events.py` | immutable `Event` + `EventType` — the source of truth |
-| `reducer.py` | the **pure** reducer `(state, event) → state` + legal transition table |
+| `reducer.py` | the **pure** reducer `(state, event) → state` + legal transition table + snapshot-aware fast path |
 | `barrier.py` | the join barrier — `RUNNING / PARTIAL / JOINABLE` |
-| `store.py` | append-only `EventStore` + `SQLiteStore` (WAL, rowid-ordered) |
+| `store.py` | append-only `EventStore` + `SQLiteStore` (WAL, rowid-ordered, snapshotting) |
 | `bus.py` | the event bus — append to the store, push to subscribers |
-| `provider.py` | `AgentProvider` contract + `MockProvider` + `ClaudeProvider` |
+| `provider.py` | `AgentProvider` + `MockProvider` + `ClaudeProvider` + `GLMProvider` + `OpenAIProvider` + `DeepSeekProvider` |
 | `router.py` | the model router — role → provider |
 | `audit.py` | the simple audit gate — `CLAIMED_DONE → VERIFIED/REJECTED`, incl. a runtime audit |
 | `audit_arsenal.py` | the Quality Arsenal — 18 forensic audits as the verification gate |
-| `executor.py` | **the topology executor** — runs the mission graph, scopes, barrier |
+| `executor.py` | **the topology executor** — runs the mission graph, scopes, barrier, PARTIAL policy |
 | `progress.py` | live progress tracking — a bus subscriber → progress bar |
 | `report.py` | mission → whitepaper JSON → `pdfgen` → PDF |
 | `telegram.py` | the Telegram bridge — topics, live progress, PDF delivery |
 | `project.py` | project creation — structure, registry, bound Telegram topic |
 | `mission.py` | the mission coordinator — `run_mission()` ties it all together |
+| `account.py` | Claude Max account pool — OAuth, encrypted vault, `BillingAggregator` |
+| `autonomous.py` | autonomous-agent supervisor — charters, stdlib cron, 4 trigger types |
+| `educators/` | the 8 self-improving educators — generate SSOT artifacts under quality gate |
+| `rag/` | multi-RAG — Hybrid, Graph, Agentic, Corrective, Multimodal + Router |
+| `tools.py` | tool registry + `install_from_catalog` |
+| `sync.py` | SST → provider native projection (`ClaudeCodeAdapter`) |
+| `daemons/` | the 24/7 service layer — `omega daemon engine\|telegram\|autonomous` |
 | `supervisor.py` | the deadman / watchdog — stall → `task.failed` |
-| `cli.py` | the `omega` CLI — `run`, `project`, `doctor`, `status`, `account`, … |
+| `cli.py` | the `omega` CLI — `run`, `project`, `doctor`, `status`, `account *`, `billing`, `tool *`, `sync`, `daemon *` |
 
-## Tests
+## Tests — 81 across 13 files, all green
 
 ```bash
 cd Agentik_Engine
-for t in reducer executor progress project report mission; do
+for t in reducer executor progress project audit_arsenal snapshot_partial \
+         educators rag account autonomous tools_and_sync report mission; do
   python3 tests/test_$t.py
 done
 ```
 
-23 tests, all green — including an **end-to-end mission** (a real mission runs to
-`VERIFIED`) and **live PDF generation** through the `pdfgen` tool.
+Includes an **end-to-end mission** (a real mission runs to `VERIFIED`), **live
+PDF generation** through `pdfgen`, the **Quality Arsenal forensic gate**, the
+**autonomous-agent supervisor**, **multi-RAG retrieval**, **account vault +
+billing aggregation**, and **PARTIAL/snapshot semantics**.
 
-## Run a mission
+## Run
 
 ```bash
 omega run "fix the pricing bug"      # Oracle plans → workers → verifier → PDF report
 omega project "My Project"           # structure + registry + Telegram topic
+omega tool install composio          # install an MCP from the catalog into Agentik_Tools/
+omega sync                           # compile SSOT → provider native (Claude Code .mcp.json, skills, ...)
+omega daemon engine                  # the 24/7 layer (or via systemd user units)
+omega account login                  # add a Claude Max account to the pool
+omega billing                        # live per-account usage from the event log
 omega status                         # every task and its derived state
 ```
 

package/omega/Agentik_Engine/omega_engine/__init__.py

@@ -4,6 +4,11 @@ Event-sourced, verified-completion agent graphs. The engine is business-agnostic
 it executes graphs of Tasks. Who is an "oracle" and which topology runs lives in
 Agentik_Orchestration/, never here.
 """
+from omega_engine.account import (
+    AccountPool,
+    BillingAggregator,
+    ClaudeAccount,
+)
 from omega_engine.audit import AuditFinding, AuditGate, AuditVerdict
 from omega_engine.audit_arsenal import (
     ArsenalGate,
@@ -12,7 +17,31 @@ from omega_engine.audit_arsenal import (
     AuditRegistry,
     run_forensic_audit,
 )
+from omega_engine.autonomous import (
+    AutonomousSupervisor,
+    Charter,
+    build_supervisor_from_home,
+    load_charters,
+    next_fire,
+    parse_cron,
+)
 from omega_engine.barrier import ScopeStatus, scope_status
+from omega_engine.educators import (
+    Artifact,
+    ArtifactEducator,
+    AutomationEducator,
+    ClaudecodeEducator,
+    ConnectionEducator,
+    CoworkerEducator,
+    Educator,
+    EducatorProposal,
+    EducatorRegistry,
+    LoopEducator,
+    PromptEducator,
+    SkillEducator,
+    StagingPipeline,
+    StagingRecord,
+)
 from omega_engine.bus import EventBus
 from omega_engine.events import Event, EventType
 from omega_engine.executor import Executor, MissionResult
@@ -22,11 +51,26 @@ from omega_engine.provider import (
     AgentRequest,
     AgentResult,
     ClaudeProvider,
+    DeepSeekProvider,
+    GLMProvider,
     MockProvider,
+    OpenAIProvider,
+)
+from omega_engine.rag import (
+    AgenticRetriever,
+    CorrectiveRetriever,
+    Document,
+    GraphRetriever,
+    HybridRetriever,
+    MultimodalRetriever,
+    RAGRouter,
+    RetrievalResult,
+    Retriever,
 )
 from omega_engine.reducer import IllegalTransition, reduce, reduce_task
 from omega_engine.router import ModelRouter
 from omega_engine.store import EventStore, SQLiteStore
+from omega_engine.sync import ClaudeCodeAdapter, SyncEngine
 from omega_engine.task import (
     TERMINAL,
     Budget,
@@ -36,8 +80,9 @@ from omega_engine.task import (
     TaskState,
     Trigger,
 )
+from omega_engine.tools import Tool, ToolRegistry, install_from_catalog
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 
 __all__ = [
     "__version__",
@@ -51,8 +96,27 @@ __all__ = [
     "EventStore", "SQLiteStore", "EventBus",
     # providers + router
     "AgentProvider", "AgentRequest", "AgentResult", "MockProvider",
-    "ClaudeProvider", "ModelRouter",
+    "ClaudeProvider", "GLMProvider", "OpenAIProvider", "DeepSeekProvider",
+    "ModelRouter",
+    # account pool + billing
+    "AccountPool", "ClaudeAccount", "BillingAggregator",
     # audit + executor + progress
     "AuditGate", "AuditVerdict", "AuditFinding",
     "Executor", "MissionResult", "ProgressTracker", "MissionProgress",
+    # educators — the self-improving layer
+    "Educator", "EducatorProposal", "EducatorRegistry", "Artifact",
+    "StagingPipeline", "StagingRecord",
+    "PromptEducator", "ArtifactEducator", "SkillEducator", "CoworkerEducator",
+    "ConnectionEducator", "AutomationEducator", "ClaudecodeEducator",
+    "LoopEducator",
+    # RAG subsystem — five strategies + Corrective envelope + router
+    "Document", "RetrievalResult", "Retriever",
+    "HybridRetriever", "GraphRetriever", "AgenticRetriever",
+    "CorrectiveRetriever", "MultimodalRetriever", "RAGRouter",
+    # autonomous-agent supervisor + charters
+    "AutonomousSupervisor", "Charter", "load_charters",
+    "build_supervisor_from_home", "parse_cron", "next_fire",
+    # tool registry + SSOT → provider sync engine
+    "Tool", "ToolRegistry", "install_from_catalog",
+    "SyncEngine", "ClaudeCodeAdapter",
 ]