agents-dojo 0.1.1 → 0.1.3

package/dist/agent-executor.js

@@ -4,6 +4,26 @@ import { a2aToContentBlocks } from './part-mapper.js';
 import { runClaude } from './claude-bridge.js';
 import { createTranslator } from './event-translator.js';
 import { recordTaskStart, recordTaskEnd } from './metrics.js';
+import { logConversation, AgentConversationLogger } from './agent-logger.js';
+// ── Global concurrency limiter ─────────────────────────────
+// Prevents CPU overload by limiting simultaneous Claude SDK processes.
+const MAX_CONCURRENT = 3;
+const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes per task
+let running = 0;
+const waitQueue = [];
+function acquireSlot() {
+    if (running < MAX_CONCURRENT) {
+        running++;
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => waitQueue.push(() => { running++; resolve(); }));
+}
+function releaseSlot() {
+    running--;
+    const next = waitQueue.shift();
+    if (next)
+        next();
+}
 export class DojoAgentExecutor {
     agent;
     options;
@@ -22,7 +42,6 @@ export class DojoAgentExecutor {
         this.controllers.delete(taskId);
         this.contextIds.delete(taskId);
         // Publish canceled state to the bus so the client sees the transition.
-        // Guard against publishing if the bus is no longer accepting (best-effort).
         try {
             eventBus.publish({
                 kind: 'status-update',
@@ -39,9 +58,21 @@ export class DojoAgentExecutor {
         catch {
             // ignore — the SDK subprocess may already be torn down
         }
+        // Also notify monitor
+        this.options.monitorBus?.emit({ type: 'task_status', taskId, state: 'canceled' });
     };
     async execute(requestContext, eventBus) {
         const { taskId, contextId, userMessage } = requestContext;
+        // Wait for a concurrency slot
+        await acquireSlot();
+        // Set up task timeout
+        const timeoutTimer = setTimeout(() => {
+            const ctrl = this.controllers.get(taskId);
+            if (ctrl) {
+                console.warn(`[agents-dojo] Task ${taskId} timed out after ${DEFAULT_TIMEOUT_MS / 1000}s, aborting`);
+                ctrl.abort();
+            }
+        }, DEFAULT_TIMEOUT_MS);
         recordTaskStart();
         // Publish the initial task snapshot. The A2A SDK's ResultManager only
         // initializes its currentTask from a `kind: 'task'` event; without it,
@@ -58,15 +89,21 @@ export class DojoAgentExecutor {
             history: [userMessage],
             artifacts: [],
         });
-        // Emit task_created to monitor bus. A2A has no real "sender" concept beyond
-        // user/agent, so we use the convention from: 'user' for any inbound client.
+        // Emit task_created to monitor bus.
+        const preview = extractPreview(userMessage.parts);
         this.options.monitorBus?.emit({
             type: 'task_created',
             taskId,
             contextId,
             from: 'user',
             to: this.agent.manifest.id,
-            preview: extractPreview(userMessage.parts),
+            preview,
+        });
+        // Also emit submitted state to monitor
+        this.options.monitorBus?.emit({
+            type: 'task_status',
+            taskId,
+            state: 'submitted',
         });
         // 1. Extract text content from A2A message
         const parts = userMessage.parts;
@@ -86,12 +123,28 @@ export class DojoAgentExecutor {
         this.controllers.set(taskId, controller);
         this.contextIds.set(taskId, contextId);
         // 4. Run Claude (iterate events)
+        const startTime = Date.now();
+        let finalResponse = '';
+        let taskState = 'completed';
+        // Full SDK conversation logger — captures every message for transparency
+        const sdkLogger = new AgentConversationLogger(this.agent.agentDir, this.agent.manifest.id, taskId);
         try {
             for await (const sdkMsg of runClaude({
                 agent: this.agent,
                 contentBlocks,
                 contextId,
-                onEvent: (m) => translator.onSdkEvent(m),
+                onEvent: (m) => {
+                    translator.onSdkEvent(m);
+                    sdkLogger.onSdkMessage(m);
+                    // Capture final text for summary log
+                    const msg = m;
+                    if (msg.type === 'assistant' && msg.message?.content) {
+                        for (const block of msg.message.content) {
+                            if (block.type === 'text')
+                                finalResponse = block.text;
+                        }
+                    }
+                },
                 abortController: controller,
             })) {
                 // events are published via onEvent
@@ -100,13 +153,11 @@ export class DojoAgentExecutor {
         }
         catch (err) {
             recordTaskEnd(false);
-            // If the controller was aborted, the SDK throws an AbortError. We don't
-            // want to report it as a generic failure — cancelTask already published
-            // the canceled state. Suppress the publish in that case.
+            taskState = 'failed';
             const isAbort = controller.signal.aborted || (err instanceof Error && /abort/i.test(err.message));
             if (!isAbort) {
-                // SDK subprocess crash, network failure, etc.
                 const reason = err instanceof Error ? err.message : String(err);
+                finalResponse = `Error: ${reason}`;
                 eventBus.publish({
                     kind: 'status-update',
                     taskId,
@@ -129,8 +180,22 @@ export class DojoAgentExecutor {
             }
         }
         finally {
+            clearTimeout(timeoutTimer);
+            releaseSlot();
             this.controllers.delete(taskId);
             this.contextIds.delete(taskId);
+            // Flush full SDK conversation log (all LLM interactions)
+            sdkLogger.flush(taskState, Date.now() - startTime);
+            // Also save summary log
+            logConversation(this.agent.agentDir, {
+                taskId,
+                agentId: this.agent.manifest.id,
+                timestamp: new Date().toISOString(),
+                userMessage: extractPreview(userMessage.parts),
+                agentResponse: finalResponse.slice(0, 500),
+                state: taskState,
+                durationMs: Date.now() - startTime,
+            });
         }
     }
 }

package/dist/agent-loader.js

@@ -1,5 +1,5 @@
 // src/agent-loader.ts
-import { readFileSync, readdirSync, existsSync, statSync } from 'fs';
+import { readFileSync, readdirSync, existsSync, statSync, mkdirSync, writeFileSync } from 'fs';
 import { join, resolve, isAbsolute } from 'path';
 import stripJsonComments from 'strip-json-comments';
 import { AgentManifestSchema } from './manifest-schema.js';
@@ -49,6 +49,8 @@ function resolveRef(agentDir, relPath) {
 export function loadAgent(agentDir) {
     const manifest = loadManifest(agentDir);
     const fixedContextContent = loadContext(agentDir, manifest.fixedContext);
+    // Install built-in call-agent skill so this agent can communicate with peers
+    installBuiltinSkills(agentDir);
     return {
         manifest,
         agentDir,
@@ -60,6 +62,89 @@ export function loadAgent(agentDir) {
         sandboxPath: resolveRef(agentDir, manifest.sandbox),
     };
 }
+const CALL_AGENT_SKILL_MD = `---
+name: call-agent
+description: "Call another agent in the same AgentsDojo server via A2A protocol. Use when you need to delegate a task, ask for help, or collaborate with a peer agent."
+---
+
+# Calling Other Agents
+
+You can communicate with other agents running in the same AgentsDojo server.
+
+## List Available Agents
+
+\`\`\`bash
+curl -s http://localhost:41241/agents
+\`\`\`
+
+## Send a Message and Get Response
+
+Use this helper script. It sends the message, then polls for the result (avoids blocking timeouts).
+
+\`\`\`bash
+python3 -c "
+import urllib.request, json, uuid, time, sys
+
+agent_id = 'AGENT_ID'
+message = '''YOUR MESSAGE'''
+url = f'http://localhost:41241/a2a/{agent_id}'
+
+# Step 1: Send message
+req_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':message}]
+}}}).encode()
+try:
+    req = urllib.request.Request(url, data=req_body, headers={'Content-Type':'application/json'})
+    resp = json.loads(urllib.request.urlopen(req, timeout=120).read())
+    result = resp.get('result',{})
+except Exception as e:
+    print(f'Error sending: {e}', file=sys.stderr)
+    sys.exit(1)
+
+# Step 2: If task not completed yet, poll with tasks/get
+task_id = result.get('id','')
+state = result.get('status',{}).get('state','')
+if state not in ('completed','failed') and task_id:
+    for _ in range(60):
+        time.sleep(2)
+        poll_body = json.dumps({'jsonrpc':'2.0','id':2,'method':'tasks/get','params':{'id':task_id}}).encode()
+        try:
+            poll_req = urllib.request.Request(url, data=poll_body, headers={'Content-Type':'application/json'})
+            poll_resp = json.loads(urllib.request.urlopen(poll_req, timeout=10).read())
+            result = poll_resp.get('result', result)
+            state = result.get('status',{}).get('state','')
+            if state in ('completed','failed'): break
+        except: pass
+
+# Step 3: Extract response text
+for a in result.get('artifacts',[]):
+    for p in a.get('parts',[]):
+        if p.get('kind')=='text': print(p['text'])
+msg = result.get('status',{}).get('message',{})
+if isinstance(msg, dict):
+    for p in msg.get('parts',[]):
+        if p.get('kind')=='text': print(p['text'])
+"
+\`\`\`
+
+Replace AGENT_ID and YOUR MESSAGE with the target agent and your message.
+
+## Rules
+
+- 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
+`;
+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);
+    }
+}
 export function loadAgents(agentsDir) {
     const result = new Map();
     const absDir = resolve(agentsDir);

package/dist/agent-logger.d.ts

@@ -0,0 +1,26 @@
+/**
+ * A logger that captures every SDK message for a single task.
+ * Create one per task, call .onSdkMessage() for each message,
+ * then .flush() when the task completes.
+ */
+export declare class AgentConversationLogger {
+    private agentDir;
+    private agentId;
+    private taskId;
+    private messages;
+    constructor(agentDir: string, agentId: string, taskId: string);
+    /** Record a raw SDK message (assistant, user, result, etc.) */
+    onSdkMessage(msg: unknown): void;
+    /** Write all captured messages to the agent's log file. */
+    flush(state: 'completed' | 'failed' | 'canceled', durationMs: number): void;
+}
+export interface ConversationEntry {
+    taskId: string;
+    agentId: string;
+    timestamp: string;
+    userMessage: string;
+    agentResponse: string;
+    state: 'completed' | 'failed';
+    durationMs: number;
+}
+export declare function logConversation(agentDir: string, entry: ConversationEntry): void;

package/dist/agent-logger.js

@@ -0,0 +1,63 @@
+// src/agent-logger.ts
+// Saves the complete LLM conversation (all SDK messages) for each agent task.
+import { appendFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+function todayStr() {
+    return new Date().toISOString().slice(0, 10);
+}
+/**
+ * A logger that captures every SDK message for a single task.
+ * Create one per task, call .onSdkMessage() for each message,
+ * then .flush() when the task completes.
+ */
+export class AgentConversationLogger {
+    agentDir;
+    agentId;
+    taskId;
+    messages = [];
+    constructor(agentDir, agentId, taskId) {
+        this.agentDir = agentDir;
+        this.agentId = agentId;
+        this.taskId = taskId;
+    }
+    /** Record a raw SDK message (assistant, user, result, etc.) */
+    onSdkMessage(msg) {
+        this.messages.push({
+            timestamp: new Date().toISOString(),
+            type: msg?.type ?? 'unknown',
+            data: msg,
+        });
+    }
+    /** Write all captured messages to the agent's log file. */
+    flush(state, durationMs) {
+        const logDir = join(this.agentDir, 'log');
+        mkdirSync(logDir, { recursive: true });
+        const file = join(logDir, `${todayStr()}.jsonl`);
+        const entry = {
+            taskId: this.taskId,
+            agentId: this.agentId,
+            timestamp: new Date().toISOString(),
+            state,
+            durationMs,
+            messageCount: this.messages.length,
+            messages: this.messages,
+        };
+        try {
+            appendFileSync(file, JSON.stringify(entry) + '\n');
+        }
+        catch (err) {
+            console.error(`[agent-logger] Failed to write to ${file}:`, err);
+        }
+    }
+}
+export function logConversation(agentDir, entry) {
+    const logDir = join(agentDir, 'log');
+    mkdirSync(logDir, { recursive: true });
+    const file = join(logDir, `${todayStr()}.jsonl`);
+    try {
+        appendFileSync(file, JSON.stringify(entry) + '\n');
+    }
+    catch (err) {
+        console.error(`[agent-logger] Failed to write:`, err);
+    }
+}

package/dist/claude-bridge.js

@@ -8,6 +8,8 @@ export async function* runClaude(params) {
         ? `${agent.fixedContextContent}\n\n${m.systemPromptAppend}`
         : agent.fixedContextContent;
     const env = {
+        // Preserve system PATH so agents can use curl, python3, node etc.
+        PATH: process.env.PATH,
         ...(m.env ?? {}),
     };
     // Only override CLAUDE_CONFIG_DIR if the user explicitly specified configDir.

package/dist/cli.js

@@ -42,6 +42,8 @@ function runInit(targetDir) {
     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.
 
 Next steps:
@@ -53,6 +55,88 @@ To add your own agent:
   # create manifest.jsonc and context.md inside it
 `);
 }
+// ── Built-in skill: call-agent ────────────────────────────
+const CALL_AGENT_SKILL = `---
+name: call-agent
+description: "Call another agent in the same AgentsDojo server via A2A protocol. Use this when you need to delegate a task, ask for help, or collaborate with another agent. TRIGGER when: you need expertise from another agent, the task requires skills outside your role, or you want to discuss/validate something with a peer."
+---
+
+# Calling Other Agents
+
+You can communicate with other agents running in the same AgentsDojo server.
+
+## Discover Available Agents
+
+\`\`\`bash
+curl -s http://localhost:41241/a2a/*/card 2>/dev/null || \\
+  for id in $(curl -s http://localhost:41241/agents 2>/dev/null | python3 -c "import json,sys;[print(a) for a in json.load(sys.stdin)]" 2>/dev/null); do
+    echo "--- $id ---"
+    curl -s "http://localhost:41241/a2a/$id/card" 2>/dev/null | python3 -c "import json,sys;d=json.load(sys.stdin);print(f\\"{d['name']}: {d['description']}\\");" 2>/dev/null
+  done
+\`\`\`
+
+## Send a Message to Another Agent
+
+To ask another agent a question or delegate a task, use this curl command:
+
+\`\`\`bash
+curl -s -X POST http://localhost:41241/a2a/<AGENT_ID> \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "jsonrpc": "2.0",
+    "id": 1,
+    "method": "message/send",
+    "params": {
+      "message": {
+        "messageId": "'$(python3 -c "import uuid;print(uuid.uuid4())")'",
+        "kind": "message",
+        "role": "user",
+        "parts": [{"kind": "text", "text": "YOUR MESSAGE HERE"}]
+      }
+    }
+  }'
+\`\`\`
+
+Replace \`<AGENT_ID>\` with the target agent's ID (e.g., \`alice\`, \`bob\`, \`reviewer\`).
+
+## Parse the Response
+
+The response is a JSON-RPC result. Extract the agent's reply text:
+
+\`\`\`bash
+curl -s -X POST http://localhost:41241/a2a/<AGENT_ID> \\
+  -H "Content-Type: application/json" \\
+  -d '{ ... }' | python3 -c "
+import json, sys
+r = json.load(sys.stdin)
+result = r.get('result', {})
+# Check for artifacts
+artifacts = result.get('artifacts', [])
+for a in artifacts:
+    for p in a.get('parts', []):
+        if p.get('kind') == 'text':
+            print(p['text'])
+# Check for status message
+status = result.get('status', {})
+msg = status.get('message', {})
+for p in msg.get('parts', []):
+    if p.get('kind') == 'text':
+        print(p['text'])
+"
+\`\`\`
+
+## Guidelines
+
+- **Be specific** about what you need from the other agent
+- **Include context** — the other agent doesn't share your conversation history
+- **Don't loop** — if an agent can't help, handle it yourself instead of retrying
+- You can call multiple agents in sequence to build on each other's output
+`;
+function installCallAgentSkill(agentDir) {
+    const skillDir = join(agentDir, '.claude', 'skills', 'call-agent');
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(join(skillDir, 'SKILL.md'), CALL_AGENT_SKILL);
+}
 export const DEFAULT_ARGS = {
     agentsDir: './agents',
     port: 41241,

package/dist/event-translator.js

@@ -25,6 +25,13 @@ export function createTranslator(ctx) {
             },
             final: false,
         });
+        // Also emit to monitor bus so the GUI can show speech bubbles
+        ctx.monitorBus?.emit({
+            type: 'task_status',
+            taskId: ctx.taskId,
+            state: 'working',
+            message: text.length > 80 ? text.slice(0, 77) + '...' : text,
+        });
     }
     function publishCompleted() {
         ctx.bus.publish({
@@ -38,6 +45,7 @@ export function createTranslator(ctx) {
             },
             final: true,
         });
+        ctx.monitorBus?.emit({ type: 'task_status', taskId: ctx.taskId, state: 'completed' });
         ctx.bus.finished();
     }
     function publishFailed(reason) {
@@ -60,6 +68,7 @@ export function createTranslator(ctx) {
             },
             final: true,
         });
+        ctx.monitorBus?.emit({ type: 'task_status', taskId: ctx.taskId, state: 'failed', message: reason });
         ctx.bus.finished();
     }
     function summarizeInput(input) {

package/dist/log-writer.d.ts

@@ -0,0 +1,26 @@
+import type { MonitorBus } from './monitor-bus.js';
+/**
+ * A single chat message in the conversation log.
+ */
+export interface ChatMessage {
+    timestamp: string;
+    taskId: string;
+    from: string;
+    to: string;
+    content: string;
+    direction: 'incoming' | 'outgoing';
+}
+/**
+ * Subscribe to monitor bus and save chat messages (not raw events).
+ * Only task_created (incoming message) and task_status with working/completed
+ * (agent response) are saved as chat records.
+ */
+export declare function startMonitorLogger(bus: MonitorBus, logDir: string): void;
+/**
+ * Read chat messages from logs.
+ */
+export declare function readLogs(logDir: string, date?: string): ChatMessage[];
+/**
+ * List available log dates.
+ */
+export declare function listLogDates(logDir: string): string[];

package/dist/log-writer.js

@@ -0,0 +1,123 @@
+// src/log-writer.ts
+// Saves agent conversations (who said what to whom) as chat-style records.
+import { appendFileSync, mkdirSync, existsSync, readdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+function todayStr() {
+    return new Date().toISOString().slice(0, 10);
+}
+/**
+ * Subscribe to monitor bus and save chat messages (not raw events).
+ * Only task_created (incoming message) and task_status with working/completed
+ * (agent response) are saved as chat records.
+ */
+export function startMonitorLogger(bus, logDir) {
+    mkdirSync(logDir, { recursive: true });
+    // Track taskId → agent mapping for responses
+    const taskAgents = new Map();
+    // Track which agents are currently working (for detecting peer calls)
+    const workingAgents = new Set();
+    bus.subscribe((event) => {
+        const file = join(logDir, `${todayStr()}.jsonl`);
+        if (event.type === 'task_created') {
+            // Detect agent-to-agent call: if another agent is working, it's likely the caller
+            let from = event.from;
+            if (from === 'user') {
+                for (const agentId of workingAgents) {
+                    if (agentId !== event.to) {
+                        from = agentId;
+                        break;
+                    }
+                }
+            }
+            taskAgents.set(event.taskId, { from, to: event.to });
+            const msg = {
+                timestamp: new Date().toISOString(),
+                taskId: event.taskId,
+                from,
+                to: event.to,
+                content: event.preview,
+                direction: 'incoming',
+            };
+            writeLine(file, msg);
+        }
+        // Track working agents from tool_call events too
+        if (event.type === 'tool_call_start') {
+            const targetId = [...taskAgents.entries()].find(([tid]) => tid === event.taskId)?.[1]?.to;
+            if (targetId)
+                workingAgents.add(targetId);
+        }
+        if (event.type === 'task_status') {
+            // Track working agents
+            const targetId = [...taskAgents.entries()].find(([tid]) => tid === event.taskId)?.[1]?.to;
+            if (targetId) {
+                if (event.state === 'working')
+                    workingAgents.add(targetId);
+                else if (event.state === 'completed' || event.state === 'failed' || event.state === 'canceled')
+                    workingAgents.delete(targetId);
+            }
+            if (event.message) {
+                const mapping = taskAgents.get(event.taskId);
+                if (mapping) {
+                    const msg = {
+                        timestamp: new Date().toISOString(),
+                        taskId: event.taskId,
+                        from: mapping.to, // agent is responding
+                        to: mapping.from, // back to the caller
+                        content: event.message,
+                        direction: 'outgoing',
+                    };
+                    writeLine(file, msg);
+                }
+            }
+            // Clean up on terminal states
+            const terminalStates = ['completed', 'failed', 'canceled', 'rejected'];
+            if (terminalStates.includes(event.state)) {
+                taskAgents.delete(event.taskId);
+            }
+        }
+    });
+}
+function writeLine(file, msg) {
+    try {
+        appendFileSync(file, JSON.stringify(msg) + '\n');
+    }
+    catch (err) {
+        console.error('[log-writer] Failed to write:', err);
+    }
+}
+/**
+ * Read chat messages from logs.
+ */
+export function readLogs(logDir, date) {
+    if (!existsSync(logDir))
+        return [];
+    const files = date
+        ? [`${date}.jsonl`]
+        : readdirSync(logDir).filter((f) => f.endsWith('.jsonl')).sort().reverse();
+    const entries = [];
+    for (const file of files) {
+        const path = join(logDir, file);
+        if (!existsSync(path))
+            continue;
+        const lines = readFileSync(path, 'utf-8').split('\n').filter(Boolean);
+        for (const line of lines) {
+            try {
+                entries.push(JSON.parse(line));
+            }
+            catch { /* skip */ }
+        }
+    }
+    return entries;
+}
+/**
+ * List available log dates.
+ */
+export function listLogDates(logDir) {
+    if (!existsSync(logDir))
+        return [];
+    return readdirSync(logDir)
+        .filter((f) => f.endsWith('.jsonl'))
+        .map((f) => f.replace('.jsonl', ''))
+        .sort()
+        .reverse();
+}

package/dist/server.js

@@ -1,13 +1,17 @@
 import { createServer as createHttpServer } from 'http';
+import { resolve, join } from 'path';
 import { AgentRegistry } from './agent-registry.js';
 import { createA2AServer } from './a2a-server.js';
 import { createReloadApi } from './reload-api.js';
 import { createMetricsRouter, setAgentsLoaded } from './metrics.js';
 import { createMonitorBus } from './monitor-bus.js';
 import { createMonitorWs } from './monitor-ws.js';
+import { startMonitorLogger, readLogs, listLogDates } from './log-writer.js';
 export async function createServer(opts) {
-    // Create bus FIRST so handlers can reference it
     const bus = createMonitorBus();
+    // Start monitor event logger
+    const logDir = join(resolve(opts.agentsDir), '..', 'monitor-logs');
+    startMonitorLogger(bus, logDir);
     const registry = new AgentRegistry(opts.agentsDir);
     registry.load();
     setAgentsLoaded(registry.list().length);
@@ -18,11 +22,24 @@ export async function createServer(opts) {
     registry.on('agent_reloaded', (e) => bus.emit({ type: 'agent_reloaded', ...e }));
     const a2a = createA2AServer({ registry, singleAgent: opts.singleAgent, port: opts.port, monitorBus: bus });
     const app = a2a.app;
+    // CORS for Monitor GUI (runs on a different port)
+    app.use('/logs', (_req, res, next) => {
+        res.header('Access-Control-Allow-Origin', '*');
+        res.header('Access-Control-Allow-Methods', 'GET');
+        next();
+    });
     app.use('/agents', createReloadApi(registry));
     app.use('/metrics', createMetricsRouter());
+    // Logs REST API
+    app.get('/logs', (_req, res) => {
+        const date = _req.query.date;
+        res.json({ entries: readLogs(logDir, date) });
+    });
+    app.get('/logs/dates', (_req, res) => {
+        res.json({ dates: listLogDates(logDir) });
+    });
     const httpServer = createHttpServer(app);
     if (opts.monitorPort) {
-        // Bind monitor on a separate server
         const monitorHttp = createHttpServer();
         createMonitorWs({ server: monitorHttp, bus, path: '/monitor', registry });
         await new Promise((r) => monitorHttp.listen(opts.monitorPort, r));

package/package.json

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