Revive Wizard functionality and enhance graph management tools

- Reactivated The Wizard via the HTTP bridge, improving integration with spatial LLM outputs.
- Introduced a Define Connections tool to label edges without altering the graph layout, enhancing user interaction.
- Implemented deduplication in role runners to prevent duplicate prototypes across graphs, streamlining graph management.
- Enhanced active graph awareness by improving contextual references and tool availability notifications.
- Updated API key management to store recent models, improving user experience in API key setup.
- Refined UI components for better accessibility and interaction, including new buttons for conversation management.

Author: grantiguess

WIZARD_AUTO_LAYOUT_TEST.md

@@ -0,0 +1,202 @@
+# Wizard + Auto-Layout Integration Test
+
+## What Changed
+
+The Wizard now uses **deterministic auto-layout** instead of trying to do spatial reasoning. The LLM focuses on semantics (what nodes/edges to create), and your existing `graphLayoutService.js` handles all spatial positioning.
+
+## Architecture
+
+```
+User: "Add cookie recipe components"
+   ↓
+LLM: { graphSpec: { nodes: [...], edges: [...], layoutAlgorithm: "hierarchical" } }
+   ↓
+Queue Goal → Planner → Executor
+   ↓
+Executor calls applyLayout(nodes, edges, "hierarchical")
+   ↓
+Positioned ops → Auditor → Committer → UI
+   ↓
+Graph appears with proper spatial layout!
+```
+
+## Setup
+
+1. **Start UI**:
+   ```bash
+   npm run dev
+   ```
+
+2. **Start Bridge** (separate terminal):
+   ```bash
+   npm run bridge
+   ```
+
+3. **Verify Health**:
+   ```bash
+   curl http://localhost:3001/health
+   # Should return: {"status":"ok","source":"bridge-daemon",...}
+   ```
+
+4. **Store API Key**:
+   - Open UI at http://localhost:4000
+   - Click 🔑 icon in AI panel
+   - Paste your Anthropic or OpenRouter key
+   - Click "Store API Key"
+
+## Test Cases
+
+### Test 1: Single Node (Baseline)
+**Input**: "Add Solar Energy"
+
+**Expected**:
+- LLM generates: `{ graphSpec: { nodes: [{ name: "Solar Energy" }], layoutAlgorithm: "force" } }`
+- Executor uses force-directed layout (default for single node)
+- Node appears in the active graph
+
+**Verify**: Check browser console for `[Agent] Queued create_subgraph goal` with layoutAlgorithm.
+
+---
+
+### Test 2: Simple Graph with Edges
+**Input**: "Add a recipe with Flour, Sugar, and Eggs"
+
+**Expected**:
+- LLM generates graphSpec with 4 nodes (Recipe + 3 ingredients) and 3 edges
+- Executor chooses `"hierarchical"` or `"radial"` layout (Recipe at center/top, ingredients around it)
+- Nodes appear with proper spacing and connections
+
+**Verify**: 
+- Check `/telemetry?limit=50` for the `agent_queued` entry showing node/edge counts
+- Nodes should NOT overlap
+- Edges should be visible
+
+---
+
+### Test 3: Complex Graph
+**Input**: "Fill out the components of a web application"
+
+**Expected**:
+- LLM generates 8-12 nodes (Frontend, Backend, Database, API, Auth, etc.)
+- LLM chooses appropriate layout (probably `"force"` for general graph)
+- Auto-layout positions nodes with collision avoidance
+- Network structure is clear and readable
+
+**Verify**:
+- No nodes stacked on top of each other
+- Related components are near each other (force-directed clustering)
+- Canvas feels balanced, not all nodes in one corner
+
+---
+
+### Test 4: Layout Algorithm Selection
+Try different phrases to see if LLM picks appropriate layouts:
+
+- **Hierarchical**: "Create a company org chart with CEO, managers, and employees"
+  - Should use `"hierarchical"` layout (top-down tree)
+
+- **Radial**: "Add planets orbiting the Sun"
+  - Should use `"radial"` layout (Sun at center, planets in orbit)
+
+- **Grid**: "Create a periodic table with elements"
+  - Might use `"grid"` layout (uniform spacing)
+
+**Verify**: Check telemetry for the chosen `layoutAlgorithm` in each case.
+
+---
+
+## Debugging
+
+### Check Queue Flow
+```bash
+# See what's in the goal queue
+curl http://localhost:3001/queue/peek?name=goalQueue&head=5
+
+# See what's in the task queue
+curl http://localhost:3001/queue/peek?name=taskQueue&head=5
+
+# Check if patches are being generated
+curl http://localhost:3001/queue/metrics?name=patchQueue
+```
+
+### Check Telemetry
+```bash
+# See recent agent activity
+curl 'http://localhost:3001/telemetry?limit=20' | jq '.items[] | select(.type == "agent_queued" or .type == "agent_plan")'
+
+# Filter by correlation ID (cid from agent response)
+curl 'http://localhost:3001/telemetry?cid=cid-1731626400000-abc123' | jq
+```
+
+### Common Issues
+
+**1. "Something went wrong planning the graph"**
+- Check browser console for LLM API errors
+- Verify API key is stored (🔑 icon should show "Manage API Key" not "Setup API Key")
+- Check if LLM returned invalid JSON (telemetry will show parse errors)
+
+**2. Nodes appear but all at same position**
+- Auto-layout failed - check console for `[Executor] Task execution failed`
+- Verify `graphLayoutService.js` is being imported correctly
+- Check if `applyLayout` returned empty positions array
+
+**3. Nothing happens after sending message**
+- Bridge might be down - check if `npm run bridge` is still running
+- Verify BridgeClient is mounted - check browser console for "MCP Bridge: Connection" messages
+- Check if scheduler is running: `curl http://localhost:3001/orchestration/scheduler/status`
+
+**4. Scheduler not processing tasks**
+- Manually start it via bridge startup (should auto-start on first goal enqueue)
+- Check: `curl http://localhost:3001/orchestration/scheduler/status`
+- If not enabled, something in `ensureSchedulerStarted()` failed
+
+## Success Criteria
+
+✅ LLM generates graphSpec **without** x/y coordinates
+✅ Executor logs show `[Executor]` creating positioned ops
+✅ Nodes appear in UI with proper spacing (no overlaps)
+✅ Different layout algorithms produce visually distinct results
+✅ Complex graphs (10+ nodes) are readable and well-structured
+
+## What To Look For
+
+**In Browser Console**:
+- `[Agent] Queued create_subgraph goal: { cid, graphId, nodeCount, edgeCount, layoutAlgorithm }`
+- No `[Executor] Task execution failed` errors
+- BridgeClient logs showing pending actions being executed
+
+**In Telemetry** (`/telemetry?limit=50`):
+- `agent_queued` entries with correct node/edge counts
+- `tool_call` entries for `applyMutations` with positioned ops
+- No entries with `error` field
+
+**In UI**:
+- Nodes appear in active graph after 1-2 seconds
+- Edges connect the right nodes
+- Layout looks intentional (not random scatter)
+- Refresh button in AI panel stays green (connected)
+
+## Performance Expectations
+
+- **Simple graphs** (1-3 nodes): < 2 seconds end-to-end
+- **Medium graphs** (5-10 nodes): 2-4 seconds
+- **Complex graphs** (10-20 nodes): 4-6 seconds
+
+Most time is spent in:
+1. LLM API call (~1-2s for Claude/GPT-4)
+2. Auto-layout calculation (~0.1-0.5s depending on algorithm)
+3. UI applying mutations (~0.5-1s for rendering)
+
+---
+
+## Next Steps After Testing
+
+Once basic flow works:
+1. **Enhance layout heuristics**: Teach LLM when to use each layout type
+2. **Add layout options to UI**: Let users override the chosen algorithm
+3. **Implement prototype reuse**: Check for existing prototypes before creating new ones
+4. **Add undo/redo**: For when Wizard creates unwanted nodes
+5. **Multi-graph support**: Let Wizard create new graphs and populate them
+
+The hard part (auto-layout integration) is now done. The rest is UX polish! 🎉
+

aiinstructions.txt

@@ -5,6 +5,53 @@ Redstring is a semantic knowledge graph application that allows users to create,
 
 ## Recent Enhancements (Latest)
 
+### Bridge + Wizard Revival (2025-11)
+- **Goal**: Reactivate The Wizard via the HTTP bridge instead of relying on spatial LLM outputs.
+- **Core Files**: `src/ai/BridgeClient.jsx` (state sync), `src/components/panel/views/LeftAIView.jsx` (AI panel), `bridge-daemon.js` (Orchestrator HTTP server), `src/services/bridgeConfig.js` (URL helpers).
+- **Run Loop**:
+  1. `npm install` (first time).
+  2. `npm run dev` (Vite UI on :4000) in one shell.
+  3. `npm run bridge` (starts `bridge-daemon.js` on :3001, auto-kills stale listeners). Use `npm run bridge -- --kill-only` to stop it.
+  4. Verify the daemon with `curl http://localhost:3001/health` and `curl http://localhost:3001/api/bridge/health`.
+  5. In the UI, click the 🔑 icon in the AI panel to store your Anthropic/OpenRouter key locally (never committed).
+- **Using The Wizard**:
+  - Bridge client now mounts automatically via `<BridgeClient />` in `src/App.jsx` and streams graph state + pending actions to the daemon.
+  - The left AI panel replays bridge telemetry, reconnects via the refresh icon, and calls `/api/ai/chat` or `/api/ai/agent` with your stored key.
+  - Status messages surface in-panel whenever the bridge reconnects or health checks fail.
+- **Troubleshooting**:
+  - If the refresh icon reports an unreachable bridge, rerun `npm run bridge` and ensure nothing else is bound to :3001.
+  - The bridge expects your API key in the `Authorization` header; the UI handles this once the key is stored locally.
+- **The Wizard's Magic: LLM + Auto-Layout Pipeline**:
+  - **Core Philosophy**: LLM handles semantics (what nodes/edges), auto-layout handles spatial positioning (where to place them).
+  - **Flow**: User message → `/api/ai/agent` → LLM produces graphSpec → enqueued with layoutAlgorithm → Executor calls `graphLayoutService.applyLayout()` → positioned ops → Committer → UI.
+  - **Key Files**: `bridge-daemon.js` (lines 911-1011: graphSpec routing), `src/services/orchestrator/roleRunners.js` (lines 41-132: Executor's `create_subgraph` + auto-layout), `src/services/graphLayoutService.js` (5 deterministic layouts).
+  - **LLM Guidance**: AGENT_PLANNER_PROMPT explicitly forbids x/y coordinates, instructs LLM to choose layoutAlgorithm (force/hierarchical/radial/grid/circular) based on structure.
+  - **Result**: Wizard generates complex multi-node graphs with deterministic spatial layout, no LLM spatial hallucination.
+- **The Wizard Can Now "See" (2025-11)**:
+  - **New Capability**: `read_graph_structure` tool allows Wizard to read semantic graph data (nodes, edges, relationships) without spatial coordinates.
+  - **Implementation**: `src/services/bridgeStoreAccessor.js` provides read-only access to mirrored UI state, `src/services/orchestrator/roleRunners.js` handles `read_graph_structure` execution, `src/services/Committer.js` sends results to chat.
+  - **Usage**: When user asks "what's in this graph?" or "show me what you made", LLM uses intent:"analyze" → triggers `read_graph_structure` → receives semantic data → responds with node/edge summary.
+  - **Schema**: `src/services/toolValidator.js` defines validation for `read_graph_structure` (graph_id, include_edges, include_descriptions).
+  - **Allowlists**: Added to Planner, Executor, and Auditor allowlists in `src/services/roles.js`.
+  - **Result**: Wizard can verify its creations, answer questions about graph contents, and make informed decisions about future additions.
+- **Connection Definitions (2025-11)**:
+  - **New Capability**: Wizard proactively creates connection definition nodes for all specific relationship types.
+  - **How It Works**: Edges can have `definitionNodeIds` that point to node prototypes (NOT instances). When rendering, the edge uses that prototype's color and name. Definition nodes are NOT placed in the graph - they exist as reusable type definitions.
+  - **GraphSpec Format**: LLM includes `definitionNode` in edge specs: `{"source":"A","target":"B","type":"orbits","definitionNode":{"name":"Orbital Relationship","color":"#FDB813","description":"what this means"}}`
+  - **Deduplication**: `src/services/orchestrator/roleRunners.js` (lines 131-161, 373-403) searches existing prototypes by name before creating new ones, preventing duplicates across graphs.
+  - **LLM Guidance**: AGENT_PLANNER_PROMPT instructs to ALWAYS define specific relationships ("orbits", "eats", "manages") but SKIP generic ones ("connects", "relates to").
+  - **Result**: All meaningful relationships are first-class semantic concepts with custom colors, automatically deduplicated and reusable across the entire universe.
+- **Define Connections Tool (2025-11)**:
+  - **Goal**: Label edges that lack definition nodes in the active graph without touching the layout.
+  - **Usage**: When the user asks to "define", "label", or "name" connections, the planner queues the `define_connections` tool instead of adding nodes.
+  - **Implementation**: `src/services/orchestrator/roleRunners.js` inspects `bridgeStoreData.graphEdges`, creates/reuses definition prototypes, and emits `updateEdgeDefinition` ops for the selected edges.
+  - **Options**: The tool accepts `limit` (max edges per run) and `includeGeneralTypes` if the user wants even vague links labeled.
+  - **UI Feedback**: When no edges need definitions, the tool emits a friendly read response instead of mutating the graph.
+- **Active Graph Awareness**:
+  - Treat words like "here", "this graph", or "current graph" as references to the active graph.
+  - Always mention the active graph’s name when acting on it so the user knows what’s being modified.
+  - If the user asks what tools are available, mention the list (`create_graph`, `create_subgraph`, `define_connections`, `read_graph_structure`, `verify_state`) before continuing.
+
 ### Auto Layout & Graph Generation System (2025-01)
 - **New Feature**: Comprehensive auto-layout and graph generation system in Debug menu
 - **Access**: Redstring Menu → Debug → Generate Test Graph