dAppCore · Snider · Jun 2, 2026 · Jun 13, 2026 · Jun 19, 2026 · Jun 19, 2026
diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json
@@ -10,7 +10,7 @@
       "name": "core",
       "source": "./provider/claude/core",
       "description": "CoreAgent platform — dispatch, review, messaging, OpenBrain",
-      "version": "0.14.0"
+      "version": "0.18.0"
     },
     {
       "name": "core-research",

diff --git a/.core/agents.yaml b/.core/agents.yaml
@@ -7,8 +7,8 @@ dispatch:
   # Default prompt template
   default_template: coding
   # Workspace root. Absolute paths used as-is.
-  # Relative paths resolve against $HOME/Code (e.g. ".core/workspace" → "$HOME/Code/.core/workspace").
-  workspace_root: .core/workspace
+  # Relative paths resolve against ~/Lethean (e.g. "workspace" → "~/Lethean/workspace").
+  workspace_root: workspace
   # Container runtime — auto | apple | docker | podman.
   # auto picks the first available runtime in preference order:
   # Apple Container (macOS 26+) → Docker → Podman.
@@ -23,11 +23,20 @@ dispatch:
   gpu: false
 
 # Per-agent concurrency limits (0 = unlimited)
+# NB: the limit keys on the agent BASE (before the first ":"), so all opencode
+# models share the `opencode` budget. Use per-model sub-limits to separate the
+# paid Go tier from the free Zen tier (modelVariant is everything after ":",
+# e.g. "opencode-go/deepseek-v4-pro"). Without an entry an agent is UNLIMITED —
+# it never enqueues, so a batch dispatches all at once instead of working through.
 concurrency:
   claude: 5
   gemini: 1
   codex: 1
   local: 1
+  opencode:
+    # total + inline per-model sub-limits (model = everything after the first ":")
+    total: 3
+    opencode-go/deepseek-v4-pro: 1   # paid Pro — one at a time
 
 # Rate limiting / quota management
 # Controls pacing between task dispatches to stay within daily quotas.
@@ -71,6 +80,16 @@ rates:
     sustained_delay: 300
     burst_window: 0
     burst_delay: 60
+  opencode:
+    # OpenCode Zen (free) + Go (authed balance) tiers. Set daily_limit/min_delay
+    # to pace within the actual tier quota when running a large batch; these are
+    # light defaults — tune to your OpenCode Zen/Go limits.
+    reset_utc: "00:00"
+    daily_limit: 0
+    min_delay: 5
+    sustained_delay: 20
+    burst_window: 0
+    burst_delay: 5
 
 # Agent identities (which agents can dispatch)
 agents:

diff --git a/.gitignore b/.gitignore
@@ -35,3 +35,20 @@ build/
 *.test
 coverage.out
 *.coverprofile
+.lintdeps/
+.scannerwork/
+node_modules.bak/
+coverage/
+htmlcov/
+.coverage
+
+# Stray go-build output — `go build ./cmd/core-agent` without -o drops a
+# binary at the repo root and under go/. The bundled binary is bin/lthn-agent.
+/core-agent
+/go/core-agent
+
+# superpowers design/plan scratch — not committed (shipped work lives in code)
+docs/superpowers/
+
+# PHP — installed dependencies are regenerated from composer.json/lock
+php/vendor/
diff --git a/.gitmodules b/.gitmodules
@@ -30,3 +30,19 @@
 	path = external/rag
 	url = https://github.com/dappcore/go-rag.git
 	branch = dev
+[submodule "external/api"]
+	path = external/api
+	url = https://github.com/dappcore/api.git
+	branch = dev
+[submodule "external/cli"]
+	path = external/cli
+	url = https://github.com/dappcore/cli.git
+	branch = dev
+[submodule "external/orm"]
+	path = external/orm
+	url = https://github.com/dAppCore/orm.git
+	branch = dev
+[submodule "external/go-container"]
+	path = external/go-container
+	url = https://github.com/dappcore/go-container.git
+	branch = dev
diff --git a/.mcp.json b/.mcp.json
@@ -1,9 +1,11 @@
 {
   "mcpServers": {
     "core": {
-      "type": "stdio",
-      "command": "core",
-      "args": ["mcp", "serve"]
+      "type": "http",
+      "url": "http://127.0.0.1:9202/mcp",
+      "headers": {
+        "Authorization": "Bearer ${MCP_AUTH_TOKEN}"
+      }
     }
   }
 }
diff --git a/AGENTS.md b/AGENTS.md
@@ -21,12 +21,15 @@ go vet ./...                          # Vet
 ## Architecture
 
 ```
-cmd/core-agent/main.go    Entry point (97 lines — core.New + services + Run)
-pkg/agentic/               Agent orchestration: dispatch, prep, verify, scan, review
-pkg/brain/                  OpenBrain memory integration
-pkg/lib/                    Embedded templates, personas, flows, workspace scaffolds
-pkg/messages/               Typed IPC message definitions (12 message types)
+cmd/core-agent/main.go    Entry point — core.New + services + CLI run
+pkg/agentic/               Agent orchestration: dispatch, prep, verify, scan, plans/phases/sessions, fleet/platform sync
+pkg/brain/                  OpenBrain memory + cross-agent messaging
+pkg/lemma/                  Local lthn-mlx client — chat sessions + /v1/admin control
+pkg/chathistory/            Per-user portable DuckDB chat archive
+pkg/lib/                    Embedded personas, prompt/flow/workspace templates
+pkg/messages/               Typed IPC message definitions
 pkg/monitor/                Agent monitoring, notifications, completion tracking
+pkg/runner/                 Local + container runners + dispatch queue
 pkg/setup/                  Workspace detection and scaffolding
 ```
 
@@ -37,11 +40,13 @@ c := core.New(
     core.WithOption("name", "core-agent"),
     core.WithService(agentic.ProcessRegister),
     core.WithService(agentic.Register),
+    core.WithService(runner.Register),
     core.WithService(monitor.Register),
     core.WithService(brain.Register),
-    core.WithService(mcp.Register),
+    core.WithService(setup.Register),
+    core.WithService(registerLemmaSubsystem),
+    core.WithService(coremcp.Register),
 )
-c.Run()
 ```
 
 ### Dispatch Flow

diff --git a/CLAUDE.md b/CLAUDE.md
@@ -4,14 +4,16 @@ This file provides guidance to Claude Code when working with code in this reposi
 
 ## Session Context
 
-Running on **Claude Max20 plan** with **1M context window** (Opus 4.6).
+Running on **Claude Max20 plan** with **1M context window** (Opus 4.8).
 
 ## Overview
 
 **core-agent** is the AI agent orchestration platform for the Core ecosystem. Single Go binary (`core-agent`) that runs as an MCP server — either via stdio (Claude Code integration) or HTTP daemon (cross-agent communication).
 
 **Module:** `dappco.re/go/agent`
 
+**Source of truth:** the RFC specs live in the plans tree at `plans/code/core/agent/` (`RFC.md`, `RFC.pipeline.md`, `RFC.topology.md`, `RFC.serve.md`, `flow/`, `plugins/`) — the present-tense contract for every subsystem. `docs/` in this repo holds literal feature documentation only — `architecture.md`, `known-issues.md`, a `development/` guide, and a folder per feature (each a URL: `dispatch/`, `pipeline/`, `plans/`, `brain/`, `inference/`, `providers/`, …) whose `README.md` is a concise SEO index linking to detail pages. This file is the operational quick-reference; when docs and code disagree, the code wins.
+
 ## Build & Test
 
 ```bash
@@ -30,19 +32,30 @@ GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -o core-agent-linux ./cmd/core-ag
 ## Architecture
 
 ```
-cmd/core-agent/main.go          Entry point (mcp + serve commands)
-pkg/agentic/                     MCP tools — dispatch, verify, remote, mirror, review queue
-pkg/brain/                       OpenBrain — recall, remember, messaging
-pkg/monitor/                     Background monitoring + repo sync
-pkg/prompts/                     Embedded templates + personas (go:embed)
+cmd/core-agent/main.go           Entry point — core.New + services + CLI run
+pkg/agentic/                     MCP dispatch tools, IPC pipeline, plans/phases/sessions, fleet/platform sync
+pkg/brain/                        OpenBrain — recall, remember, forget, list, messaging
+pkg/lemma/                        Local lthn-mlx client — chat sessions + /v1/admin control
+pkg/chathistory/                  Per-user portable DuckDB chat archive
+pkg/monitor/                      Background monitoring + repo sync
+pkg/runner/                       Local + container runners + dispatch queue
+pkg/setup/                        Project detection + .core/ scaffolding
+pkg/lib/                          Embedded personas, prompt + flow + workspace templates (go:embed)
+pkg/messages/                     Typed IPC message definitions
 ```
 
+> Also `pkg/opencode/` — the sandboxed opencode host (Service Start/Stop/Generate, profiles, reverse-proxy, hub control + audit): the AUI surface (RFC.md §6).
+
 ### Binary Modes
 
-- `core-agent mcp` — stdio MCP server for Claude Code
-- `core-agent serve` — HTTP daemon (Charon, CI, cross-agent). PID file, health check, registry.
+- `core-agent mcp` — stdio MCP server for Claude Code (registered by the `dappco.re/go/mcp` service)
+- `core-agent serve` — HTTP MCP daemon (Charon, CI, cross-agent)
+- `core-agent hub` — loopback control plane: `--http 127.0.0.1:9201` (bearer) + `--mcp-http 127.0.0.1:9202` (fail-closed MCP), fronting the opencode control/proxy groups + brain with a non-optional audit edge (RFC.md §2/§6)
+- `core-agent chat --user=<id>` — REPL against the local lthn-mlx engine, auto-captured to the user's archive
+- `core-agent serve-status` / `serve-reload` / `serve-profiles` — inspect / hot-swap the local model engine
+- `core-agent models-download` / `models-job` — queue + poll Hugging Face model downloads
 
-### MCP Tools (33)
+### MCP Tools (common subset — full action surface in `RFC.md`)
 
 | Category | Tools |
 |----------|-------|
@@ -68,6 +81,8 @@ pkg/prompts/                     Embedded templates + personas (go:embed)
 | `codex` | Codex CLI | Autonomous coding |
 | `codex:review` | Codex review | Deep security analysis |
 | `coderabbit` | CodeRabbit CLI | Code quality review |
+| `opencode` | `opencode run` | Sandboxed agent routed to local/free-compute model profiles (RFC.md §6) |
+| `local` | Codex + ollama bridge | Local OSS model via host `ollama` |
 
 ### Dispatch Flow
 
@@ -77,19 +92,13 @@ dispatch → agent works → closeout sequence (review → fix → simplify →
     → push to GitHub → CodeRabbit reviews → merge or dispatch fix agent
 ```
 
-### Personas (pkg/prompts/lib/personas/)
-
-116 personas across 16 domains. Path = context, filename = lens.
+### Personas (pkg/lib/persona/)
 
-```
-prompts.Persona("engineering/security-developer")   # code-level security review
-prompts.Persona("smm/security-secops")              # social media incident response
-prompts.Persona("devops/senior")                     # infrastructure architecture
-```
+Personas across many domains (ads, blockchain, code, design, devops, plan, product, sales, secops, smm, spatial, support, testing). Path = context, filename = lens.
 
-### Templates (pkg/prompts/lib/templates/)
+### Templates (pkg/lib/prompt/, pkg/lib/task/, pkg/lib/flow/)
 
-Prompt templates for different task types: `coding`, `conventions`, `security`, `verify`, plus YAML plan templates (`bug-fix`, `code-review`, `new-feature`, `refactor`, etc.)
+Prompt + task templates for different task types (`coding`, `conventions`, `security`, `verify`, code review, simplifier), plus per-language flow definitions in `pkg/lib/flow/` and YAML upgrade flows in `pkg/lib/flow/upgrade/`.
 
 ## Key Patterns
 
@@ -114,14 +123,12 @@ All paths use `CORE_WORKSPACE` env var, fallback `~/Code/.core`:
 
 Always check `err != nil` BEFORE accessing `resp.StatusCode`. Split into two checks.
 
-## Plugin (claude/core/)
+## Plugin Providers (provider/)
+
+core-agent ships its capabilities to a coding-agent host through two providers, one capability set (RFC.md §7):
 
-The Claude Code plugin provides:
-- **MCP server** via `mcp.json` (auto-registers core-agent)
-- **Hooks** via `hooks.json` (PostToolUse inbox notifications, auto-format, debug warnings)
-- **Agents**: `agent-task-code-review`, `agent-task-code-simplifier`
-- **Commands**: dispatch, status, review, recall, remember, scan, etc.
-- **Skills**: security review, architecture review, test analysis, etc.
+- **`provider/claude/`** — Claude Code plugin: MCP server (`mcp.json`, auto-registers core-agent), hooks (`hooks.json` — inbox notifications, auto-format, debug warnings), agents (`agent-task-code-review`, `agent-task-code-simplifier`), commands (dispatch, status, review, recall, remember, scan…), skills (security / architecture / test review…).
+- **`provider/opencode/`** — opencode plugin (`@opencode-ai/plugin`): capabilities as custom `tool()` exports (dispatch, status, scan, brain_recall…); `session.*` event hooks feeding the report-home loop; the ctx `client` SDK drives the running session. Personas ≡ opencode agent-defs (markdown frontmatter); skills ≡ `SKILL.md`; dispatch is two-layer (opencode `Task` subagents + core-agent's cross-host fleet), or attach the hub MCP plane via `POST /mcp`.
 
 ## Testing Conventions