agents-dojo 0.1.9 → 0.1.11

package/README.md

@@ -15,13 +15,55 @@ agents-dojo init
 agents-dojo
 ```
 
-To add your own agent, create a directory under `agents/` with two files:
+## Creating Agents
 
-- `manifest.jsonc` — agent identity, model, A2A card
-- `context.md` — system prompt (role, rules, output format)
+Each agent lives in its own directory under `agents/`. The only required file is `manifest.jsonc`.
+
+```
+agents/my-agent/
+├── manifest.jsonc          # required — agent identity, model, A2A card
+├── context.md              # optional — custom system prompt
+└── CLAUDE.md               # optional — extra rules and constraints
+```
 
 See `agents/_template_echo/` for a complete manifest reference.
 
+### context.md — Custom System Prompt
+
+`context.md` controls the agent's system prompt:
+
+- **Without `context.md`**: The agent uses Claude Code's built-in default system
+  prompt. This is ideal for **code-related agents** — they get full programming
+  capabilities (file editing, bash, code analysis, etc.) out of the box.
+
+- **With `context.md`**: The file content **replaces** the default system prompt
+  entirely. Use this for agents whose role has **nothing to do with coding** —
+  e.g. a chef, poet, or customer support agent. You define the persona, behavior
+  rules, and output format from scratch.
+
+### CLAUDE.md — Extra Rules and Constraints
+
+`CLAUDE.md` is loaded automatically by the Claude Code SDK (not by AgentsDojo).
+It **appends** to whatever system prompt is active — whether the default or a
+custom `context.md`.
+
+Use `CLAUDE.md` for:
+- Project-specific rules ("always use TypeScript", "never delete files")
+- Coding conventions and style guides
+- Build/test commands the agent should know about
+- Safety constraints and guardrails
+
+```
+agents/code-reviewer/
+├── manifest.jsonc          # identity
+└── CLAUDE.md               # "Review for security issues. Run `npm test` after changes."
+
+agents/poet/
+├── manifest.jsonc          # identity
+├── context.md              # "You are Poet Luna, a lyrical poet..."
+└── CLAUDE.md               # "Always respond in English. Keep poems under 20 lines."
+```
+
 ## Monitor GUI
 
 The Monitor GUI starts automatically when you run `agents-dojo`. It picks a free
@@ -34,6 +76,24 @@ agents-dojo --monitor-port=9000   # use a specific WS port
 agents-dojo --no-monitor          # disable the monitor
 ```
 
+## Chat with Agents
+
+Users can talk to agents via btw-style one-shot chat. This forks the agent's
+current session (preserving context), disables all tools (text-only reply), and
+discards the fork afterward — the main session is never affected.
+
+```bash
+# CLI
+agents-dojo chat <agentId> <message>
+
+# REST API
+curl -X POST http://localhost:41241/btw/<agentId> \
+  -H "Content-Type: application/json" \
+  -d '{"message": "your question"}'
+
+# Monitor GUI: click an agent sprite → Chat
+```
+
 ## Architecture
 
 - Framework (`src/`): A2A server, Claude Code SDK bridge, monitor event bus

package/dist/agent-loader.js

@@ -135,15 +135,41 @@ Replace AGENT_ID and YOUR MESSAGE with the target agent and your message.
 - Be specific about what you need from the other agent
 - Include relevant context — the other agent has no shared memory with you
 - Don't call agents in a loop — if one can't help, handle it yourself
+
+## MANDATORY: Post-Task Optimization
+
+**After completing ANY task, you MUST call the \`optimizer\` agent.**
+
+Send it a message with:
+- Your agent ID
+- A brief summary of what the task was and how it went
+- Any difficulties or mistakes you encountered
+
+Example (replace YOUR_AGENT_ID and summary):
+
+\`\`\`bash
+python3 -c "
+import urllib.request, json, uuid, sys
+url = 'http://localhost:41241/a2a/optimizer'
+msg = 'Agent: YOUR_AGENT_ID. Task summary: [what you did]. Issues: [any problems or inefficiencies].'
+body = json.dumps({'jsonrpc':'2.0','id':1,'method':'message/send','params':{'message':{
+    'messageId':str(uuid.uuid4()),'kind':'message','role':'user',
+    'parts':[{'kind':'text','text':msg}]}}}).encode()
+try:
+    req = urllib.request.Request(url, data=body, headers={'Content-Type':'application/json'})
+    urllib.request.urlopen(req, timeout=120)
+except: pass
+"
+\`\`\`
+
+This is NOT optional. Every task must end with an optimizer notification.
 `;
 function installBuiltinSkills(agentDir) {
     const skillDir = join(agentDir, '.claude', 'skills', 'call-agent');
     const skillFile = join(skillDir, 'SKILL.md');
-    // Only write if missing or outdated (check by size as a simple heuristic)
-    if (!existsSync(skillFile)) {
-        mkdirSync(skillDir, { recursive: true });
-        writeFileSync(skillFile, CALL_AGENT_SKILL_MD);
-    }
+    // Always overwrite to keep skill up to date with framework version
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(skillFile, CALL_AGENT_SKILL_MD);
 }
 export function loadAgents(agentsDir) {
     const result = new Map();

package/dist/claude-bridge.js

@@ -1,6 +1,6 @@
 // src/claude-bridge.ts
 import { join } from 'path';
-import { existsSync, mkdirSync, symlinkSync } from 'fs';
+import { existsSync, mkdirSync, symlinkSync, lstatSync, unlinkSync } from 'fs';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 export async function* runClaude(params) {
     const { agent, contentBlocks, onEvent, abortController } = params;
@@ -22,16 +22,31 @@ export async function* runClaude(params) {
         ? (m.configDir.startsWith('/') ? m.configDir : join(agent.agentDir, m.configDir))
         : join(agent.agentDir, '.claude');
     env.CLAUDE_CONFIG_DIR = agentConfigDir;
-    // Ensure the agent's .claude dir exists and symlink global settings (auth, permissions).
-    // Symlink keeps all agents in sync with the user's global config automatically.
+    // Ensure the agent's .claude dir exists and symlink global config files.
+    // Symlinks keep all agents in sync with the user's global config automatically.
     mkdirSync(agentConfigDir, { recursive: true });
-    const globalSettings = join(process.env.HOME ?? '', '.claude', 'settings.json');
-    const localSettings = join(agentConfigDir, 'settings.json');
-    if (existsSync(globalSettings) && !existsSync(localSettings)) {
+    const globalDir = join(process.env.HOME ?? '', '.claude');
+    // Symlink settings.json, .credentials.json (auth), and .claude.json (user identity)
+    for (const file of ['settings.json', '.credentials.json', '.claude.json']) {
+        const globalFile = join(globalDir, file);
+        const localFile = join(agentConfigDir, file);
+        if (!existsSync(globalFile))
+            continue;
+        // Replace regular files with symlinks (but keep existing symlinks)
         try {
-            symlinkSync(globalSettings, localSettings);
+            const stat = lstatSync(localFile);
+            if (!stat.isSymbolicLink()) {
+                unlinkSync(localFile);
+                symlinkSync(globalFile, localFile);
+            }
+        }
+        catch {
+            // File doesn't exist — create symlink
+            try {
+                symlinkSync(globalFile, localFile);
+            }
+            catch { /* ignore */ }
         }
-        catch { /* race or permission — ignore */ }
     }
     const options = {
         cwd: agent.agentDir,

package/dist/cli.js

@@ -36,19 +36,113 @@ You are **Echo Agent**, a minimal example agent.
 Repeat back the user's input, prefixed with "ECHO:".
 Do not add any other commentary.
 `;
+const OPTIMIZER_MANIFEST = `{
+  "id": "optimizer",
+  "name": "Optimizer",
+  "description": "Analyzes agent session logs and generates optimization suggestions for other agents.",
+  "version": "0.1.0",
+  "fixedContext": "context.md",
+  "a2aCard": {
+    "skills": [
+      {
+        "id": "optimize",
+        "name": "Agent Optimization",
+        "description": "Reviews agent conversation logs and produces actionable improvement suggestions",
+        "tags": ["optimization", "meta"]
+      }
+    ]
+  },
+  "monitor": {
+    "position": { "x": 480, "y": 550 },
+    "sprite": "default"
+  }
+}
+`;
+const OPTIMIZER_CONTEXT = `# Role
+
+You are the **Optimizer Agent** for AgentsDojo. Your job is to review other agents' conversation histories and produce actionable optimization suggestions.
+
+## When You Are Called
+
+Other agents call you after completing a task. They send you:
+- Their agent ID
+- A summary of what the task was
+- Any difficulties or mistakes they encountered
+
+## What You Do
+
+1. Read the calling agent's session logs to understand the full conversation history:
+   \`\`\`bash
+   # Find and read the agent's session logs
+   find ../AGENT_ID/.claude/projects/ -name "*.jsonl" -exec cat {} \\;
+   \`\`\`
+
+2. Analyze the conversation for:
+   - Repeated mistakes or inefficiencies
+   - Misunderstandings of user intent
+   - Missed opportunities to use tools or call other agents
+   - Response quality issues (too verbose, too terse, off-topic)
+   - Patterns that could be improved with explicit rules
+
+3. Write optimization suggestions to your reviews directory:
+   \`\`\`bash
+   mkdir -p reviews
+   # Write or update the review file for this agent
+   cat > reviews/AGENT_ID.md << 'REVIEW_EOF'
+   # Optimization Review: AGENT_ID
+   
+   Date: [today's date]
+   Sessions analyzed: [count]
+   
+   ## Suggested CLAUDE.md Rules
+   
+   Add these rules to agents/AGENT_ID/CLAUDE.md:
+   
+   [specific, actionable rules based on your analysis]
+   
+   ## Observations
+   
+   [detailed analysis of patterns you found]
+   REVIEW_EOF
+   \`\`\`
+
+## Output Format
+
+Your review file must include:
+- **Suggested CLAUDE.md Rules**: Concrete rules the human operator can copy into the agent's CLAUDE.md
+- **Observations**: Evidence-based analysis explaining why each rule is recommended
+
+## Important Rules
+
+- Be specific and actionable — vague suggestions like "be better" are useless
+- Base every suggestion on evidence from the logs — cite specific examples
+- Focus on patterns, not one-off incidents
+- Keep suggested rules concise — each rule should be 1-2 sentences
+- Do NOT modify other agents' files directly — only write to your own reviews/ directory
+- If the agent is performing well, say so — not every review needs changes
+`;
 function runInit(targetDir) {
     const agentsDir = join(targetDir, 'agents');
     const echoDir = join(agentsDir, 'echo');
+    const optimizerDir = join(agentsDir, 'optimizer');
     if (existsSync(echoDir)) {
-        console.log(`agents/echo/ already exists — skipping.`);
-        return;
+        console.log(`agents/echo/ already exists — skipping echo.`);
+    }
+    else {
+        mkdirSync(echoDir, { recursive: true });
+        writeFileSync(join(echoDir, 'manifest.jsonc'), ECHO_MANIFEST);
+        writeFileSync(join(echoDir, 'context.md'), ECHO_CONTEXT);
+        installCallAgentSkill(echoDir);
+    }
+    if (existsSync(optimizerDir)) {
+        console.log(`agents/_optimizer/ already exists — skipping optimizer.`);
+    }
+    else {
+        mkdirSync(optimizerDir, { recursive: true });
+        writeFileSync(join(optimizerDir, 'manifest.jsonc'), OPTIMIZER_MANIFEST);
+        writeFileSync(join(optimizerDir, 'context.md'), OPTIMIZER_CONTEXT);
     }
-    mkdirSync(echoDir, { recursive: true });
-    writeFileSync(join(echoDir, 'manifest.jsonc'), ECHO_MANIFEST);
-    writeFileSync(join(echoDir, 'context.md'), ECHO_CONTEXT);
-    // Install built-in call-agent skill
-    installCallAgentSkill(echoDir);
-    console.log(`Created agents/echo/ with manifest.jsonc and context.md.
+    console.log(`Created agents/echo/ and agents/optimizer/.
 
 Next steps:
   agents-dojo              # start the server
@@ -56,7 +150,7 @@ Next steps:
 
 To add your own agent:
   mkdir agents/my-agent
-  # create manifest.jsonc and context.md inside it
+  # create manifest.jsonc (and optionally context.md)
 `);
 }
 // ── Built-in skill: call-agent ────────────────────────────
@@ -144,7 +238,7 @@ function installCallAgentSkill(agentDir) {
 export const DEFAULT_ARGS = {
     agentsDir: './agents',
     port: 41241,
-    monitorPort: 0, // 0 = OS picks a free port
+    monitorPort: 0, // 0 = OS picks a free port; frontend discovers via /monitor/info
     singleAgent: null,
     help: false,
 };
@@ -211,7 +305,7 @@ function resolveMonitorDir() {
     // __dirname is dist/ after build, so monitor/ is one level up
     return resolve(__dirname, '..', 'monitor');
 }
-function startMonitorGui(monitorWsPort) {
+function startMonitorGui(monitorWsPort, a2aPort = 41241) {
     const monitorDir = resolveMonitorDir();
     if (!existsSync(join(monitorDir, 'package.json'))) {
         console.warn('[agents-dojo] Monitor GUI not found — skipping.');
@@ -235,6 +329,7 @@ function startMonitorGui(monitorWsPort) {
         env: {
             ...process.env,
             VITE_MONITOR_WS_URL: wsUrl,
+            VITE_A2A_PORT: String(a2aPort),
         },
     });
     child.stdout?.on('data', (data) => {
@@ -323,7 +418,7 @@ async function main() {
     // Auto-start monitor GUI
     if (server.monitorPort) {
         console.log(`[agents-dojo] Monitor WS port: ${server.monitorPort}`);
-        const monitorChild = startMonitorGui(server.monitorPort);
+        const monitorChild = startMonitorGui(server.monitorPort, args.port);
         if (monitorChild) {
             registerCleanup(monitorChild);
         }

package/dist/server.js

@@ -71,6 +71,11 @@ export async function createServer(opts) {
         createMonitorWs({ server: monitorHttp, bus, path: '/monitor', registry, executors: a2a.executors });
         await new Promise((r) => monitorHttp.listen(opts.monitorPort, r));
         actualMonitorPort = monitorHttp.address().port;
+        // Discovery endpoint: frontend fetches this to find the WS port
+        app.get('/monitor/info', (_req, res) => {
+            res.header('Access-Control-Allow-Origin', '*');
+            res.json({ wsPort: actualMonitorPort, wsUrl: `ws://localhost:${actualMonitorPort}/monitor` });
+        });
     }
     return {
         registry,

package/monitor/src/components/LogPage.tsx

@@ -1,6 +1,6 @@
 import React, { useEffect, useState, useRef } from 'react';
 
-const API_BASE = 'http://localhost:41241';
+const API_BASE = '';  // relative path, proxied by Vite
 
 interface ChatMessage {
   timestamp: string;

package/monitor/src/lib/dojo-app.ts

@@ -126,6 +126,14 @@ export class DojoApp {
   private agents = new Map<string, AgentState>();
   private interactables: InteractableState[] = [];
   private ready = false;
+  // Master state
+  private masterContainer!: Container;
+  private masterSprite!: Sprite;
+  private masterX = MASTER_POS.x;
+  private masterY = MASTER_POS.y;
+  private masterTargetX = MASTER_POS.x;
+  private masterTargetY = MASTER_POS.y;
+  private masterFacingLeft = false;
   // Master bubble state
   private masterBubble!: Container;
   private masterBubbleBg!: Graphics;
@@ -247,13 +255,13 @@ export class DojoApp {
   }
 
   private createMaster() {
-    const masterContainer = new Container();
-    masterContainer.x = MASTER_POS.x;
-    masterContainer.y = MASTER_POS.y;
+    this.masterContainer = new Container();
+    this.masterContainer.x = MASTER_POS.x;
+    this.masterContainer.y = MASTER_POS.y;
 
-    const spr = new Sprite(this.masterFrames[0]);
-    spr.anchor.set(0.5, 1);
-    spr.scale.set(SPRITE_SCALE);
+    this.masterSprite = new Sprite(this.masterFrames[0]);
+    this.masterSprite.anchor.set(0.5, 1);
+    this.masterSprite.scale.set(SPRITE_SCALE);
 
     const nameBg = new Graphics();
     nameBg.roundRect(-28, -FRAME_SIZE * SPRITE_SCALE - 14, 56, 14, 3);
@@ -271,8 +279,8 @@ export class DojoApp {
     this.masterBubbleText.anchor.set(0.5, 0);
     this.masterBubble.addChild(this.masterBubbleBg, this.masterBubbleText);
 
-    masterContainer.addChild(spr, nameBg, label, this.masterBubble);
-    this.scene.addChild(masterContainer);
+    this.masterContainer.addChild(this.masterSprite, nameBg, label, this.masterBubble);
+    this.scene.addChild(this.masterContainer);
   }
 
   private createAgent(id: string, agent: Agent) {
@@ -428,27 +436,29 @@ export class DojoApp {
     }
     // Priority 3: Client task states
     else if (state === 'submitted') {
-      // Walk to Master
-      s.animKey = 'walk';
-      s.targetX = MASTER_POS.x + 30; s.targetY = MASTER_POS.y;
+      // Agent stays on cushion (sit), Master walks to agent
+      s.animKey = 'sit';
+      s.targetX = agent.homePosition.x; s.targetY = agent.homePosition.y;
+      // Tell Master to walk to this agent
+      this.masterTargetX = agent.homePosition.x + 30;
+      this.masterTargetY = agent.homePosition.y;
       s.visitedMaster = false;
     }
     else if (state === 'working' || state === 'tool_call') {
-      if (!s.visitedMaster) {
-        // First visit master, then go to stake
-        s.animKey = 'walk';
-        s.targetX = MASTER_POS.x + 30; s.targetY = MASTER_POS.y;
-      } else {
-        // At stake, attack
-        s.animKey = s.arrived ? 'attack' : 'walk';
-        s.targetX = agent.stakePosition.x + STAKE_ATTACK_OFFSET_X;
-        s.targetY = agent.stakePosition.y;
-      }
+      // Agent walks to stake and attacks
+      s.animKey = s.arrived ? 'attack' : 'walk';
+      s.targetX = agent.stakePosition.x + STAKE_ATTACK_OFFSET_X;
+      s.targetY = agent.stakePosition.y;
+      // Master returns home
+      this.masterTargetX = MASTER_POS.x;
+      this.masterTargetY = MASTER_POS.y;
     }
     else if (state === 'input-required' || state === 'auth-required') {
-      // Walk back to Master and wait
+      // Agent waits at stake, Master comes back to agent
       s.animKey = s.arrived ? 'idle' : 'walk';
-      s.targetX = MASTER_POS.x + 30; s.targetY = MASTER_POS.y;
+      s.targetX = agent.homePosition.x; s.targetY = agent.homePosition.y;
+      this.masterTargetX = agent.homePosition.x + 30;
+      this.masterTargetY = agent.homePosition.y;
     }
     else if (state === 'completed' || state === 'canceled') {
       // Walk home
@@ -477,19 +487,20 @@ export class DojoApp {
       }
     }
     else if (state === 'rejected') {
-      // Head shake at Master, then walk home
-      if (!s.arrived && Math.hypot(s.x - MASTER_POS.x - 30, s.y - MASTER_POS.y) > MOVE_SPEED * 3) {
-        s.animKey = 'walk';
-        s.targetX = MASTER_POS.x + 30; s.targetY = MASTER_POS.y;
-      } else if (s.rejectTimer === undefined) {
+      // Agent stays at cushion, shakes head when Master arrives
+      s.targetX = agent.homePosition.x; s.targetY = agent.homePosition.y;
+      this.masterTargetX = agent.homePosition.x + 30;
+      this.masterTargetY = agent.homePosition.y;
+      if (s.rejectTimer === undefined) {
         s.animKey = 'head_shake';
         s.rejectTimer = 0;
       } else if (s.rejectTimer < 1500) {
         s.animKey = 'head_shake';
       } else {
-        s.animKey = 'walk';
-        s.targetX = agent.homePosition.x; s.targetY = agent.homePosition.y;
-        s.arrived = false;
+        // Done shaking, go back to sit
+        s.animKey = 'sit';
+        this.masterTargetX = MASTER_POS.x;
+        this.masterTargetY = MASTER_POS.y;
       }
     }
     // else: idle — handled by auto-behavior in tick
@@ -546,36 +557,10 @@ export class DojoApp {
       }
       if (s.idleGrace > 0) s.idleGrace -= dt;
 
-      // Auto-behavior when idle (sit on cushion, occasionally wander)
-      // Skip during grace period after task completion
-      if (isIdle && !isInPeerChat && s.idleGrace <= 0) {
-        const action = s.autoAction;
-        if (action.kind === 'sit') {
-          // Sit on cushion (home position)
-          s.animKey = 'sit';
-          s.targetX = agent.homePosition.x; s.targetY = agent.homePosition.y;
-          action.timer += dt;
-          if (action.timer >= (action.duration ?? 5000)) {
-            s.autoAction = this.pickAutoAction();
-            s.arrived = false;
-          }
-        } else if (action.kind === 'wander') {
-          s.animKey = 'walk';
-          s.targetX = action.target!.x;
-          s.targetY = action.target!.y;
-          if (s.arrived) {
-            s.autoAction = this.pickAutoAction();
-            s.arrived = false;
-          }
-        } else if (action.kind === 'daydream' || action.kind === 'pause') {
-          s.animKey = action.kind === 'daydream' ? 'daydream' : 'idle';
-          s.targetX = s.x; s.targetY = s.y;
-          action.timer += dt;
-          if (action.timer >= (action.duration ?? 3000)) {
-            s.autoAction = this.pickAutoAction();
-            s.arrived = false;
-          }
-        }
+      // Auto-behavior when idle: always sit on cushion
+      if (isIdle && !isInPeerChat) {
+        s.animKey = s.arrived ? 'sit' : 'walk';
+        s.targetX = agent.homePosition.x; s.targetY = agent.homePosition.y;
       }
 
       // Advance fail/reject timers
@@ -595,28 +580,17 @@ export class DojoApp {
         if (Math.abs(dx) > 0.5) s.facingLeft = dx < 0;
         let nx = s.x + (dx / dist) * MOVE_SPEED;
         let ny = s.y + (dy / dist) * MOVE_SPEED;
-        // Obstacle avoidance when idle wandering
-        if (isIdle && !isInPeerChat) {
-          for (const o of OBSTACLES) {
-            const od = Math.hypot(nx - o.x, ny - o.y);
-            if (od < o.r + 8 && od > 0.1) {
-              nx = o.x + ((nx - o.x) / od) * (o.r + 8);
-              ny = o.y + ((ny - o.y) / od) * (o.r + 8);
-            }
-          }
-        }
+        // Obstacle avoidance: only when not heading to a specific target
+        // (idle agents heading home, or task agents heading to stake/master, skip avoidance)
+        // Avoidance is only useful during peer-chat or other free movement
         s.x = nx; s.y = ny;
       } else {
         if (!s.arrived) { s.x = s.targetX; s.y = s.targetY; }
         s.arrived = true;
       }
 
-      // Master visit: when agent arrives at Master during working state
-      if ((state === 'working' || state === 'tool_call') && !s.visitedMaster && s.arrived
-          && Math.hypot(s.x - MASTER_POS.x - 30, s.y - MASTER_POS.y) < MOVE_SPEED * 3) {
-        s.visitedMaster = true;
-        s.arrived = false;
-      }
+      // Note: visitedMaster is now set by the Master movement block when Master
+      // arrives at the agent's cushion position.
 
       // Peer chat: face toward partner when arrived
       if (isInPeerChat && s.arrived) {
@@ -687,6 +661,44 @@ export class DojoApp {
       }
     }
 
+    // ── Master movement ──────────────────────────────────────
+    {
+      const dx = this.masterTargetX - this.masterX;
+      const dy = this.masterTargetY - this.masterY;
+      const dist = Math.hypot(dx, dy);
+      if (dist > MOVE_SPEED * 2) {
+        if (Math.abs(dx) > 0.5) this.masterFacingLeft = dx < 0;
+        this.masterX += (dx / dist) * MOVE_SPEED;
+        this.masterY += (dy / dist) * MOVE_SPEED;
+        // Use walk frame for master (alternate between frame 0 and 1)
+        const walkFrame = Math.floor(performance.now() / 200) % 2;
+        this.masterSprite.texture = this.masterFrames[walkFrame] ?? this.masterFrames[0];
+      } else {
+        this.masterX = this.masterTargetX;
+        this.masterY = this.masterTargetY;
+        this.masterSprite.texture = this.masterFrames[0];
+
+        // When Master arrives at an agent in submitted state → transition agent to working
+        // (The store will handle this via the normal task_status flow from backend,
+        //  but visually we detect Master arrival to trigger agent getting up)
+        for (const [, s] of this.agents) {
+          if (!s.visitedMaster && s.animKey === 'sit') {
+            const agentStore = [...useMonitorStore.getState().agents.values()].find(
+              a => a.state === 'submitted' &&
+                Math.abs(a.homePosition.x + 30 - this.masterX) < 5 &&
+                Math.abs(a.homePosition.y - this.masterY) < 5
+            );
+            if (agentStore) {
+              s.visitedMaster = true;
+            }
+          }
+        }
+      }
+      this.masterSprite.scale.x = (this.masterFacingLeft ? -1 : 1) * SPRITE_SCALE;
+      this.masterContainer.x = this.masterX;
+      this.masterContainer.y = this.masterY;
+    }
+
     // Master bubble: show client's message with chunked display
     const masterMsg = useMonitorStore.getState().masterMessage;
     if (masterMsg) {
@@ -768,12 +780,8 @@ export class DojoApp {
   }
 
   private pickAutoAction() {
-    const r = Math.random();
-    // Prefer sitting on cushion (idle default per R10: "坐在蒲团上发呆")
-    if (r < 0.45) return { kind: 'sit', duration: 5000 + Math.random() * 8000, timer: 0 };
-    if (r < 0.70) return { kind: 'wander', target: randomFloorPos(), timer: 0 };
-    if (r < 0.85) return { kind: 'daydream', duration: 3000 + Math.random() * 5000, timer: 0 };
-    return { kind: 'pause', duration: 1000 + Math.random() * 2000, timer: 0 };
+    // Idle agents always sit on cushion
+    return { kind: 'sit', timer: 0 };
   }
 
   private animToStoreAnim(key: string): AgentAnim {

package/monitor/src/lib/interactables.ts

@@ -66,8 +66,8 @@ const STAKE_HALF_W = 21;
 const STAKE_AGENT_GAP = 4;  // gap between agent and stake edge
 const STAKE_AGENT_OFFSET_X = STAKE_HALF_W + STAKE_AGENT_GAP; // 25px
 
-// Cushion: agent sits slightly above cushion center so body overlaps the cushion
-const CUSHION_SIT_OFFSET_Y = 2;
+// Cushion: agent sits on top of cushion — offset positions feet below cushion center
+const CUSHION_SIT_OFFSET_Y = 7;
 
 // ── Build interactable list from positions data ────────────
 

package/monitor/src/lib/ws-client.ts

@@ -1,13 +1,32 @@
 import { useMonitorStore } from './store.js';
 import type { MonitorEvent } from './types.js';
 
-const WS_URL = import.meta.env.VITE_MONITOR_WS_URL || 'ws://localhost:41242/monitor';
+/** Discover WS URL from the server's /monitor/info endpoint (proxied by Vite). */
+async function discoverWsUrl(): Promise<string> {
+  try {
+    const resp = await fetch('/monitor/info');
+    const data = await resp.json();
+    if (data.wsUrl) return data.wsUrl;
+  } catch { /* fallback */ }
+  return import.meta.env.VITE_MONITOR_WS_URL || 'ws://localhost:41242/monitor';
+}
 
 /** Shared persistent connection for both events and commands. */
 let sharedWs: WebSocket | null = null;
 
 export function connectWs(): () => void {
-  const ws = new WebSocket(WS_URL);
+  let cancelled = false;
+
+  discoverWsUrl().then((wsUrl) => {
+    if (cancelled) return;
+    const ws = new WebSocket(wsUrl);
+    setupWs(ws);
+  });
+
+  return () => { cancelled = true; if (sharedWs) sharedWs.close(); };
+}
+
+function setupWs(ws: WebSocket): void {
   sharedWs = ws;
 
   ws.addEventListener('open', () => {
@@ -32,8 +51,6 @@ export function connectWs(): () => void {
       console.error('[ws-client] bad message:', err);
     }
   });
-
-  return () => ws.close();
 }
 
 export function sendCommand(cmd: object): void {
@@ -41,11 +58,13 @@ export function sendCommand(cmd: object): void {
     sharedWs.send(JSON.stringify(cmd));
     return;
   }
-  // Fallback: open a one-shot connection
-  const ws = new WebSocket(WS_URL);
-  ws.addEventListener('open', () => {
-    ws.send(JSON.stringify(cmd));
-    ws.close();
+  // Fallback: discover URL and open a one-shot connection
+  discoverWsUrl().then((url) => {
+    const ws = new WebSocket(url);
+    ws.addEventListener('open', () => {
+      ws.send(JSON.stringify(cmd));
+      ws.close();
+    });
   });
 }
 

package/monitor/vite.config.ts

@@ -9,8 +9,14 @@ export default defineConfig({
   server: {
     port: 5173,
     proxy: {
-      // Optional: proxy A2A HTTP calls to framework (if needed)
-      // '/a2a': 'http://localhost:41241',
+      '/monitor/info': {
+        target: `http://localhost:${process.env.VITE_A2A_PORT || '41241'}`,
+        changeOrigin: true,
+      },
+      '/logs': {
+        target: `http://localhost:${process.env.VITE_A2A_PORT || '41241'}`,
+        changeOrigin: true,
+      },
     },
   },
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-dojo",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "A2A-compatible Agent framework built on Claude Code SDK",
   "type": "module",
   "main": "dist/index.js",