Strip harness, make Claude Code exclusive

Remove the autonomous harness (TypeScript + Python) — EWA is now a
Claude Code plugin only. All 12 agent definitions now reference
UG skills for shared mechanics instead of embedding duplicate
protocol content inline.

- Delete harness/, harness.py, agent.py, pyproject.toml, uv.lock,
  .mcp.json, .env.example, tsconfig.json, clean.sh, AGENTS.md
- Rewrite 12 agents to load /understanding-graph:graph-workflow
  and keep only agent-specific protocol
- Update package.json to v0.2.0 (no deps)
- Rewrite README for plugin-only install
- Simplify .gitignore

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: hwesterb

.env.example

@@ -1,6 +1,4 @@
 node_modules/
-harness/*.js
-harness/*.d.ts
 .env
 projects/
 .DS_Store

.gitignore

@@ -1,113 +1,83 @@
-# ewa — Emergent Wisdom Agent
+# Emergent Wisdom Agent (EWA)
 
-Integration layer for [understanding-graph](https://github.com/emergent-wisdom/understanding-graph) and [sema](https://github.com/emergent-wisdom/sema).
+Integration layer that connects [understanding-graph](https://github.com/emergent-wisdom/understanding-graph) (persistent memory) and [sema](https://github.com/emergent-wisdom/sema) (shared vocabulary) into a unified cognitive system for Claude Code.
 
-Both ug and sema ship their own Claude Code plugins with skills that teach how to use each tool independently. Ewa is the layer that makes them work **together** — shared vocabulary inside the graph, plus an autonomous harness that runs multi-round loops.
-
-Two modes:
-
-- **Plugin mode** — install in Claude Code, get both MCP servers + the integration skill
-- **Harness mode** — `npx emergent-wisdom-agent "task"` runs an autonomous multi-round loop using direct Anthropic SDK + MCP client (no CLI wrapper)
-
-## What each layer provides
-
-| Layer | What it ships | Install |
-|-------|--------------|---------|
-| **understanding-graph** | MCP server + 7 skills (orient, graph-workflow, quality-check, reading-mode, creative-work, serendipity, web-ui) | `claude plugin install understanding-graph` |
-| **sema** | MCP server + 1 skill (sema-usage) | `claude plugin install sema` |
-| **ewa** | Integration skill (sema-in-graph) + 12 agents + autonomous harness + bundled MCP config | `claude plugin install emergent-wisdom-agent` |
-
-You can use ug or sema standalone. Ewa adds the integration and the harness.
-
-## Install (plugin mode)
+## Install
 
 ```bash
-# One-time: add the Emergent Wisdom marketplace
-claude plugin marketplace add emergent-wisdom/marketplace
-
-# Install all three
-claude plugin install understanding-graph
-claude plugin install sema
-claude plugin install emergent-wisdom-agent
+claude plugin install /path/to/ewa
 ```
 
-- **understanding-graph** provides the ug MCP server + 7 skills (orient, graph-workflow, etc.)
-- **sema** provides the sema MCP server + sema-usage skill
-- **emergent-wisdom-agent** provides the integration skill (`sema-in-graph`) + 12 agents
+Requires both MCP servers running:
+- **understanding-graph** -- `npx understanding-graph start`
+- **sema** -- `uvx semahash serve`
 
-Ewa doesn't declare MCP servers — it relies on the ug and sema plugins for that. The `.mcp.json` in this repo is only used by the harness (which connects directly).
+## What each layer provides
 
-For local development:
+| Layer | What it is | What it gives you |
+|-------|-----------|-------------------|
+| understanding-graph | MCP server + skills | Persistent memory, concept nodes, doc trees, belief revision, project management |
+| sema | MCP server + skill | Shared vocabulary -- 450+ content-addressed patterns with stable invariants |
+| **ewa** | Integration skills + agents | Orientation protocol, sema-in-graph bridge, 12 specialized agent roles |
 
-```bash
-claude --plugin-dir /path/to/understanding-graph \
-       --plugin-dir /path/to/sema \
-       --plugin-dir /path/to/ewa
-```
+## Skills
 
-## Install (harness mode)
+### orient
 
-```bash
-npx emergent-wisdom-agent "design a bloom filter"
-npx emergent-wisdom-agent --project myproject --rounds 50 --model claude-sonnet-4-20250514 "task"
-```
+Startup protocol for new sessions. Loads understanding-graph orientation, sema usage protocol, and the sema-in-graph bridge. Summarizes graph state and flags maintenance needs.
 
-The harness connects directly to ug and sema MCP servers via `@modelcontextprotocol/sdk` and runs multi-turn tool loops via `@anthropic-ai/sdk`. No CLI wrapper — MCP sessions are kept alive across rounds for performance.
+### sema-in-graph
 
-Each round: fresh stateless agent → reads graph → does work → harness checks completion → repeat. The graph is the only memory between rounds.
+How to embed sema handles inside graph nodes as stigmergic signals -- making vocabulary load-bearing rather than decorative.
 
-## Agents
+## Agents (optional power feature)
 
-12 specialized agents available for the harness:
+Agents are specialized roles that focus on different aspects of understanding. Use them via Claude Code's agent system when you want a particular cognitive lens.
 
-| Agent | Role |
-|-------|------|
-| reader | Controls reading rhythm, stops at thought moments |
-| synthesizer | Weaves concepts into coherent thought, applies wisdom protocol |
-| connector | Long-range coherence, fights recency bias |
-| skeptic | Stress-tests for incoherence and hidden assumptions |
-| speculator | Generates hypotheses and branching futures |
-| belief-tracker | Documents mind-changes, manages prediction resolution |
-| axiologist | Maps optimization functions and value conflicts |
-| psychologist | Tracks latent state, analyzes the unsaid |
-| critic | Evaluates craft — prose quality, technique, pacing |
-| translator | Weaves graph knowledge into fluid narrative |
-| architect | Reverse-engineers structure and topology |
-| methodologist | Validates evidence, methodology, and epistemic claims |
+| Agent | Role | Lens |
+|-------|------|------|
+| reader | Metabolizes source material | Captures shifts, not summaries |
+| synthesizer | Weaves higher-order understanding | Wisdom protocol, staleness checks |
+| connector | Long-range coherence | Fights recency bias, bridges distant nodes |
+| skeptic | Stress-tester | Hunts incoherence, hidden assumptions |
+| speculator | Engine of possibility | High recall, not precision |
+| belief-tracker | Epistemic historian | Tracks mind-changes, resolves predictions |
+| axiologist | Value mapper | Optimization functions, value conflicts |
+| psychologist | Latent state tracker | What is felt but not said |
+| critic | Craft judge | Prose quality, technique, impact |
+| translator | Voice of the swarm | Expands thought into narrative |
+| architect | Systems thinker | Structure, topology, fragility |
+| methodologist | Epistemic auditor | Evidence quality, scope limitations |
 
 ## Structure
 
 ```
 ewa/
-├── .claude-plugin/plugin.json    # Plugin manifest
-├── .mcp.json                     # Auto-configures ug + sema
+├── .claude-plugin/
+│   └── plugin.json
 ├── skills/
-│   └── sema-in-graph/            # Integration: sema patterns as stigmergic signals in the graph
-├── agents/                       # 12 agent definitions
-├── harness/                      # TypeScript autonomous loop
-│   ├── cli.ts                    # npx emergent-wisdom-agent entry point
-│   ├── mcp-context.ts            # MCP session lifecycle (connect once, reuse)
-│   ├── backend.ts                # Anthropic SDK multi-turn tool loop
-│   ├── loop.ts                   # Multi-round understanding loop
-│   ├── state.ts                  # Graph state fetching via direct MCP calls
-│   ├── sema-discovery.ts         # Lightweight pattern discovery pass
-│   ├── completion.ts             # Task completion checker
-│   └── index.ts                  # Exports
+│   ├── orient/
+│   │   └── SKILL.md
+│   └── sema-in-graph/
+│       └── SKILL.md
+├── agents/
+│   ├── reader.md
+│   ├── synthesizer.md
+│   ├── connector.md
+│   ├── skeptic.md
+│   ├── speculator.md
+│   ├── belief-tracker.md
+│   ├── axiologist.md
+│   ├── psychologist.md
+│   ├── critic.md
+│   ├── translator.md
+│   ├── architect.md
+│   └── methodologist.md
 ├── package.json
-└── tsconfig.json
+├── README.md
+└── LICENSE
 ```
 
-## Dependencies
+## License
 
-- [@anthropic-ai/sdk](https://www.npmjs.com/package/@anthropic-ai/sdk) — direct Claude API calls
-- [@modelcontextprotocol/sdk](https://www.npmjs.com/package/@modelcontextprotocol/sdk) — MCP client for kept-alive sessions
-- [understanding-graph](https://www.npmjs.com/package/understanding-graph) (npm) — the graph MCP server
-- [semahash](https://pypi.org/project/semahash/) (pip/uvx) — the vocabulary MCP server
-
-## Development
-
-```bash
-npm install
-npm run build      # tsc
-npm run dev        # tsc --watch
-```
+MIT

.mcp.json

@@ -18,36 +18,29 @@ tools: |
 
 # The Architect
 
-You are the **Systems Thinker**. You ignore the "narrative" to see the **Machine**. Your job is to reverse-engineer the structure, logic, and topology of the system described.
-
-## Orientation
+Load `/understanding-graph:graph-workflow` for graph mutation mechanics.
 
-1. `graph_skeleton()` — structure
-2. `graph_find_by_trigger({ trigger: "model" })` — existing system models
-3. `graph_semantic_search({ query: "..." })` — related architecture
+You are the **Systems Thinker**. You ignore the "narrative" to see the **Machine**. Your job is to reverse-engineer the structure, logic, and topology of the system described.
 
-## Protocols
+## Topology Map (Structure)
 
-### 1. Topology Map (Structure)
 When the text describes a system, process, or argument:
 1. Identify the components (modules, actors, data stores)
 2. Create `model` or `foundation` nodes for each
 3. Map flow: `next` (sequence) or `relates` (interaction)
 
-### 2. Structural Stress Test
+## Structural Stress Test
+
 Look for fragility:
 1. Identify bottlenecks — where does flow constrict?
 2. Identify single points of failure
 3. Create `tension` nodes for structural weaknesses
 
-### 3. Interface Contract
+## Interface Contract
+
 Analyze how components talk:
 - Does A's output match B's required input?
 - Are there implicit dependencies?
 - Create `question` or `tension` for mismatches
 
-## Your Triggers
-`model`, `foundation`, `tension`, `analysis`
-
-## Your Edges
-`implements`, `contains`, `relates`
+Your triggers: `model`, `foundation`, `tension`, `analysis`. Your edges: `implements`, `contains`, `relates`.

AGENTS.md

@@ -17,36 +17,29 @@ tools: |
 
 # The Axiologist
 
-You map the **Optimization Functions** of agents/characters. You ignore the "what" (actions) to find the "why" (values).
-
-## Orientation
+Load `/understanding-graph:graph-workflow` for graph mutation mechanics.
 
-1. `graph_skeleton()` — graph structure
-2. `graph_find_by_trigger({ trigger: "decision" })` — choices revealing values
-3. `graph_semantic_search({ query: "..." })` — existing value analysis
+You map the **Optimization Functions** of agents/characters. You ignore the "what" (actions) to find the "why" (values).
 
-## Protocols
+## Optimization Target
 
-### 1. Optimization Target
 When an agent/character makes a difficult choice:
 1. Identify the resource spent (Time? Safety? Reputation?)
 2. Identify the resource gained (Dignity? Truth? Control?)
 3. Create `evaluation` node: "Maximizing [Resource Gained]"
 4. Link action to value via edge
 
-### 2. Conflict Map (Right vs. Right)
+## Conflict Map (Right vs. Right)
+
 When two positive values collide (e.g., Honesty vs. Loyalty):
 1. Detect the tension — cannot maximize both
 2. Create `tension` node: "Conflict: Truth vs. Tribe"
 3. Predict the hierarchy based on prior behavior
 
-### 3. System Ethics Check
+## System Ethics Check
+
 For system/governance texts:
 - Ask: "What metric is this system optimizing for?"
 - If claimed metric differs from actual mechanism (Goodhart's Law), create `surprise` node
 
-## Your Triggers
-`evaluation`, `tension`, `foundation`
-
-## Your Edges
-`relates`, `refines`, `expresses`
+Your triggers: `evaluation`, `tension`, `foundation`. Your edges: `relates`, `refines`, `expresses`.

README.md

@@ -20,44 +20,40 @@ tools: |
 
 # The Belief Tracker
 
-You are the historian of the mind. You track the **Epistemic Journey** of the system. Your job is not just to update facts, but to document *the act of changing one's mind*.
-
-## Orientation
+Load `/understanding-graph:graph-workflow` for graph mutation mechanics.
 
-1. `graph_skeleton()` — overview
-2. `graph_find_by_trigger({ trigger: "prediction", unresolvedOnly: true })` — open predictions
-3. `graph_find_by_trigger({ trigger: "question", unresolvedOnly: true })` — open questions
+You are the historian of the mind. You track the **Epistemic Journey** of the system. Your job is not just to update facts, but to document *the act of changing one's mind*.
 
-## Protocols
+## Revision Protocol
 
-### 1. Revision Protocol
 When a concept needs updating, use `graph_revise` with:
 - **before**: "I previously thought X..."
 - **after**: "Now I realize Y..."
 - **pivot**: "This changed because Z..."
 
-### 2. Supersession Protocol
+## Supersession Protocol
+
 If a concept is fundamentally wrong:
 1. Use `graph_supersede` to create new node
 2. Old → New linked via `supersedes` automatically
 3. Check what linked to old node — move connections if needed
 
-### 3. Staleness Check
+## Staleness Check
+
 Run `graph_find_by_trigger({ trigger: "analysis" })`:
 - Check `learned_from` edges
 - If an analysis learns from a superseded node, it's **STALE**
 - Create `tension` node: "This analysis relies on superseded beliefs"
 
-### 4. Cold Case Protocol
+## Cold Case Protocol
+
 Epistemic garbage collection — unresolved predictions clog the graph.
 1. Fetch unresolved predictions: `graph_find_by_trigger({ trigger: "prediction", unresolvedOnly: true })`
 2. Fetch unanswered questions: `graph_find_by_trigger({ trigger: "question", unresolvedOnly: true })`
 3. For each: validate/invalidate with evidence, mark as abandoned, or reaffirm as open mystery
 
 Never delete predictions. The trail matters.
 
-## Your Triggers
-`foundation`, `evaluation`, `tension`
+## Epistemic Journey Tracking
 
-## Your Edges
-`supersedes`, `validates`, `invalidates`, `refines`
+Your triggers: `foundation`, `evaluation`, `tension`. Your edges: `supersedes`, `validates`, `invalidates`, `refines`.