proofscan 0.10.62 → 0.11.0

package/dist/shell/router-commands.js

@@ -5,12 +5,18 @@
  * for exploring connectors, sessions, and RPC calls.
  */
 import { PIPELINE_SESSION_LIMIT } from './types.js';
+import { AgentCacheStore } from '../db/agent-cache-store.js';
+import { A2AClient } from '../a2a/client.js';
 import { printSuccess, printError, printInfo, shortenSessionId } from './prompt.js';
+import ora from 'ora';
 import { selectSession, canInteract } from './selector.js';
 import { EventLineStore } from '../eventline/store.js';
 import { EventsStore } from '../db/events-store.js';
 import { ConfigManager } from '../config/index.js';
+import { TargetsStore } from '../db/targets-store.js';
 import { setCurrentSession, clearCurrentSession, formatRelativeTime } from '../utils/index.js';
+import { createA2ASessionManager } from '../a2a/session-manager.js';
+import { randomUUID } from 'crypto';
 import { createRefFromContext, refToJson, parseRef, isRef, RefResolver, createRefDataProvider, } from './ref-resolver.js';
 // ProtoType is imported from types.ts
 /**
@@ -36,9 +42,10 @@ export function detectProto(store, sessionId) {
         if (hasMcpInit || hasMcpTools) {
             return 'mcp';
         }
-        // A2A detection: a2a.* or agent.* methods
+        // A2A detection: a2a.*, agent.*, message/*, or tasks/* methods
         for (const method of allMethods) {
-            if (method.startsWith('a2a.') || method.startsWith('agent.')) {
+            if (method.startsWith('a2a.') || method.startsWith('agent.') ||
+                method.startsWith('message/') || method.startsWith('tasks/')) {
                 return 'a2a';
             }
         }
@@ -108,26 +115,26 @@ function savePreviousLocation(context) {
  *
  * @returns true if a session was selected, false otherwise
  */
-async function selectSessionFromMatches(matches, prefix, context, store, connectorId) {
+async function selectSessionFromMatches(matches, prefix, context, store, targetId) {
     if (matches.length === 1) {
         savePreviousLocation(context);
         context.session = matches[0].session_id;
-        context.connector = connectorId;
+        context.connector = targetId;
         context.proto = detectProto(store, matches[0].session_id);
-        setCurrentSession(matches[0].session_id, connectorId);
-        printSuccess(`→ /${connectorId}/${shortenSessionId(matches[0].session_id)}`);
+        setCurrentSession(matches[0].session_id, targetId);
+        printSuccess(`→ /${targetId}/${shortenSessionId(matches[0].session_id)}`);
         return true;
     }
     if (canInteract()) {
         printInfo(`Multiple sessions match "${prefix}". Select one:`);
-        const selected = await selectSession(matches.slice(0, MAX_INTERACTIVE_OPTIONS).map(s => ({ id: s.session_id, connector_id: s.connector_id })));
+        const selected = await selectSession(matches.slice(0, MAX_INTERACTIVE_OPTIONS).map(s => ({ id: s.session_id, connector_id: s.target_id })));
         if (selected) {
             savePreviousLocation(context);
             context.session = selected;
-            context.connector = connectorId;
+            context.connector = targetId;
             context.proto = detectProto(store, selected);
-            setCurrentSession(selected, connectorId);
-            printSuccess(`→ /${connectorId}/${shortenSessionId(selected)}`);
+            setCurrentSession(selected, targetId);
+            printSuccess(`→ /${targetId}/${shortenSessionId(selected)}`);
             return true;
         }
     }
@@ -242,7 +249,7 @@ export async function handleCc(args, context, configPath) {
             printInfo('Already at session context');
             return;
         }
-        // Get latest session (optionally filtered by current connector)
+        // Get latest session (optionally filtered by current target)
         const sessions = store.getSessions(context.connector, 1);
         if (sessions.length === 0) {
             if (context.connector) {
@@ -281,44 +288,44 @@ export async function handleCc(args, context, configPath) {
         // Navigate based on ref kind
         if (ref.kind === 'rpc') {
             // For RPC refs, navigate to the containing session
-            if (!ref.session || !ref.connector) {
+            if (!ref.session || !ref.target) {
                 printError(`Cannot navigate to RPC reference: missing session/connector`);
                 printInfo(`Use: show ${arg} to view RPC details`);
                 return;
             }
             savePreviousLocation(context);
-            context.connector = ref.connector;
+            context.connector = ref.target;
             context.session = ref.session;
             context.proto = detectProto(store, ref.session);
-            setCurrentSession(ref.session, ref.connector);
-            printSuccess(`→ /${ref.connector}/${shortenSessionId(ref.session)}`);
+            setCurrentSession(ref.session, ref.target);
+            printSuccess(`→ /${ref.target}/${shortenSessionId(ref.session)}`);
             printInfo(`(navigated to session containing RPC)`);
             return;
         }
         if (ref.kind === 'session') {
-            if (!ref.session || !ref.connector) {
+            if (!ref.session || !ref.target) {
                 printError(`Invalid session reference: missing session/connector`);
                 return;
             }
             savePreviousLocation(context);
-            context.connector = ref.connector;
+            context.connector = ref.target;
             context.session = ref.session;
             context.proto = detectProto(store, ref.session);
-            setCurrentSession(ref.session, ref.connector);
-            printSuccess(`→ /${ref.connector}/${shortenSessionId(ref.session)}`);
+            setCurrentSession(ref.session, ref.target);
+            printSuccess(`→ /${ref.target}/${shortenSessionId(ref.session)}`);
             return;
         }
         if (ref.kind === 'connector') {
-            if (!ref.connector) {
+            if (!ref.target) {
                 printError(`Invalid connector reference: missing connector`);
                 return;
             }
             savePreviousLocation(context);
-            context.connector = ref.connector;
+            context.connector = ref.target;
             context.session = undefined;
-            context.proto = detectConnectorProto(store, ref.connector);
-            setCurrentSession('', ref.connector);
-            printSuccess(`→ /${ref.connector}`);
+            context.proto = detectConnectorProto(store, ref.target);
+            setCurrentSession('', ref.target);
+            printSuccess(`→ /${ref.target}`);
             return;
         }
         if (ref.kind === 'context') {
@@ -345,13 +352,13 @@ export async function handleCc(args, context, configPath) {
             // Validate absoluteTarget is not empty (handles "cd //" case)
             if (!absoluteTarget || absoluteTarget.trim() === '') {
                 printError('Invalid path: empty connector ID');
-                printInfo('Use: cd /connector or cd /connector/session');
+                printInfo('Use: cd /target or cd /target/session');
                 return;
             }
             // Validate against path traversal attempts (e.g., /.. or /../foo)
             if (absoluteTarget.includes('..')) {
                 printError('Invalid path: path traversal not allowed');
-                printInfo('Use: cd /connector or cd /connector/session');
+                printInfo('Use: cd /target or cd /target/session');
                 return;
             }
             // Check if target contains another / (i.e., /connector/session)
@@ -359,19 +366,31 @@ export async function handleCc(args, context, configPath) {
             const segments = absoluteTarget.split('/').filter(s => s !== '');
             if (segments.length > 2) {
                 printError('Invalid path format: too many segments');
-                printInfo('Use: cd /connector or cd /connector/session');
+                printInfo('Use: cd /target or cd /target/session');
                 return;
             }
             if (segments.length === 2) {
                 const [absConnector, absSession] = segments;
-                // Find connector
+                // Find connector or agent
                 const connectors = store.getConnectors();
-                const connector = connectors.find(c => c.id === absConnector || c.id.startsWith(absConnector));
+                let connector = connectors.find(c => c.id === absConnector || c.id.startsWith(absConnector));
                 if (!connector) {
-                    printError(`Connector not found: ${absConnector}`);
+                    try {
+                        const configDir = configPath.replace(/\/[^/]+$/, '');
+                        const targetsStore = new TargetsStore(configDir);
+                        const agents = targetsStore.list({ type: 'agent' });
+                        const agent = agents.find(a => a.id === absConnector || a.id.startsWith(absConnector));
+                        if (agent) {
+                            connector = { id: agent.id, session_count: 0, latest_session: undefined };
+                        }
+                    }
+                    catch { /* targets table may not exist */ }
+                }
+                if (!connector) {
+                    printError(`Target not found: ${absConnector}`);
                     const available = connectors.map(c => c.id);
                     if (available.length > 0) {
-                        printInfo(`Available connectors: ${available.join(', ')}`);
+                        printInfo(`Available: ${available.join(', ')}`);
                     }
                     return;
                 }
@@ -385,15 +404,28 @@ export async function handleCc(args, context, configPath) {
                 await selectSessionFromMatches(matches, absSession, context, store, connector.id);
                 return;
             }
-            // Just /connectorId - navigate to connector (segments.length === 1)
+            // Just /connectorId - navigate to connector or agent (segments.length === 1)
             const absConnectorId = segments[0];
             const connectors = store.getConnectors();
-            const connector = connectors.find(c => c.id === absConnectorId || c.id.startsWith(absConnectorId));
+            let connector = connectors.find(c => c.id === absConnectorId || c.id.startsWith(absConnectorId));
+            // Also check A2A agents if not found in MCP connectors
             if (!connector) {
-                printError(`Connector not found: ${absConnectorId}`);
+                try {
+                    const configDir = configPath.replace(/\/[^/]+$/, '');
+                    const targetsStore = new TargetsStore(configDir);
+                    const agents = targetsStore.list({ type: 'agent' });
+                    const agent = agents.find(a => a.id === absConnectorId || a.id.startsWith(absConnectorId));
+                    if (agent) {
+                        connector = { id: agent.id, session_count: 0, latest_session: undefined };
+                    }
+                }
+                catch { /* targets table may not exist */ }
+            }
+            if (!connector) {
+                printError(`Target not found: ${absConnectorId}`);
                 const available = connectors.map(c => c.id);
                 if (available.length > 0) {
-                    printInfo(`Available connectors: ${available.join(', ')}`);
+                    printInfo(`Available: ${available.join(', ')}`);
                 }
                 return;
             }
@@ -415,7 +447,7 @@ export async function handleCc(args, context, configPath) {
         const connectors = store.getConnectors();
         const connector = connectors.find(c => c.id === connectorPart || c.id.startsWith(connectorPart));
         if (!connector) {
-            printError(`Connector not found: ${connectorPart}`);
+            printError(`Target not found: ${connectorPart}`);
             return;
         }
         // Find session by prefix
@@ -436,11 +468,19 @@ export async function handleCc(args, context, configPath) {
         const historyConnectors = store.getConnectors();
         const manager = new ConfigManager(configPath);
         const configuredConnectors = await manager.getConnectors();
-        // Merge IDs from both sources (deduplicated)
+        // Merge IDs from all sources (deduplicated): history + config + A2A agents
         const allConnectorIds = new Set([
             ...historyConnectors.map(c => c.id),
             ...configuredConnectors.map(c => c.id),
         ]);
+        try {
+            const configDir = configPath.replace(/\/[^/]+$/, '');
+            const targetsStore = new TargetsStore(configDir);
+            for (const a of targetsStore.list({ type: 'agent' })) {
+                allConnectorIds.add(a.id);
+            }
+        }
+        catch { /* targets table may not exist */ }
         // Find matching connector (exact match first, then prefix)
         let matchId;
         for (const id of allConnectorIds) {
@@ -458,7 +498,7 @@ export async function handleCc(args, context, configPath) {
             }
         }
         if (!matchId) {
-            printError(`Connector not found: ${arg}`);
+            printError(`Target not found: ${arg}`);
             printInfo('Available: ' + [...allConnectorIds].join(', '));
             return;
         }
@@ -582,15 +622,36 @@ export async function handleLs(args, context, configPath, executeCommand) {
             printError('No connector in context');
             return;
         }
-        await listSessions(store, context.connector, isLong, isJson, idsOnly);
+        // Check if this is an A2A agent
+        const configDir = configPath.replace(/\/[^/]+$/, '');
+        let isA2A = false;
+        try {
+            const targetsStore = new TargetsStore(configDir);
+            const agents = targetsStore.list({ type: 'agent' });
+            isA2A = agents.some(a => a.id === context.connector);
+        }
+        catch { /* targets table may not exist */ }
+        if (isA2A) {
+            await listA2ASessions(configDir, context.connector, isLong, isJson, idsOnly);
+        }
+        else {
+            await listSessions(store, context.connector, isLong, isJson, idsOnly);
+        }
         return;
     }
-    // Session level - list RPC calls
+    // Session level - list RPC calls or A2A messages
     if (!context.session) {
         printError('No session in context');
         return;
     }
-    await listRpcs(store, context.session, isLong, isJson, idsOnly, executeCommand);
+    // Check if this is an A2A session (proto = 'a2a')
+    if (context.proto === 'a2a') {
+        const configDir = configPath.replace(/\/[^/]+$/, '');
+        await listA2AMessages(configDir, context.session, isLong, isJson, idsOnly);
+    }
+    else {
+        await listRpcs(store, context.session, isLong, isJson, idsOnly, executeCommand);
+    }
 }
 /**
  * List connectors at root level (router-style table)
@@ -627,6 +688,25 @@ async function listConnectors(store, configPath, _isLong, isJson, idsOnly) {
             });
         }
     }
+    // Add A2A agents from targets store
+    try {
+        const configDir = configPath.replace(/\/[^/]+$/, '');
+        const targetsStore = new TargetsStore(configDir);
+        const agents = targetsStore.list({ type: 'agent' });
+        for (const agent of agents) {
+            mergedConnectors.push({
+                id: agent.id,
+                session_count: 0,
+                latest_session: null,
+                configured: true,
+                hasHistory: false,
+                proto: 'a2a',
+            });
+        }
+    }
+    catch {
+        // targets table may not exist yet
+    }
     if (mergedConnectors.length === 0) {
         printInfo('No connectors found. Add one with: connectors add --id <id> --command <cmd>');
         return;
@@ -651,7 +731,7 @@ async function listConnectors(store, configPath, _isLong, isJson, idsOnly) {
     const isTTY = process.stdout.isTTY;
     const data = mergedConnectors.map(c => ({
         id: c.id,
-        proto: c.hasHistory ? detectConnectorProto(store, c.id) : '?',
+        proto: c.proto || (c.hasHistory ? detectConnectorProto(store, c.id) : '?'),
         sessions: c.session_count,
         latest: c.latest_session ? formatRelativeTime(c.latest_session) : '-',
         configured: c.configured,
@@ -693,23 +773,23 @@ async function listConnectors(store, configPath, _isLong, isJson, idsOnly) {
     if (hasHistoryOnly || hasConfigOnly) {
         console.log();
         if (hasConfigOnly) {
-            printInfo('+ = ready (run: plans run basic-mcp)');
+            printInfo('+ = ready (mcp: plans run basic-mcp, a2a: agent scan <id>)');
         }
         if (hasHistoryOnly) {
             printInfo('* = history only (not in config)');
         }
     }
     console.log();
-    printInfo(`Hint: cd <connector> to enter, show <connector> for details`);
+    printInfo(`Hint: cd <target> to enter, show <target> for details`);
 }
 /**
- * List sessions for a connector (router-style table)
+ * List sessions for a target (router-style table)
  */
-async function listSessions(store, connectorId, _isLong, isJson, idsOnly) {
-    const sessions = store.getSessions(connectorId, 50);
+async function listSessions(store, targetId, _isLong, isJson, idsOnly) {
+    const sessions = store.getSessions(targetId, 50);
     if (sessions.length === 0) {
-        printInfo(`No sessions for connector: ${connectorId}`);
-        printInfo('Run: plans run basic-mcp');
+        printInfo(`No sessions for target: ${targetId}`);
+        printInfo('Start a session first (mcp: plans run basic-mcp, a2a: agent scan <id>)');
         return;
     }
     if (isJson) {
@@ -854,11 +934,11 @@ export async function handleShow(args, context, configPath, executeCommand) {
             return;
         }
         if (ref.kind === 'connector') {
-            if (!ref.connector) {
+            if (!ref.target) {
                 printError(`Invalid connector reference: missing connector ID`);
                 return;
             }
-            await executeCommand(['connectors', 'show', '--id', ref.connector, ...(isJson ? ['--json'] : []), ...htmlOptions]);
+            await executeCommand(['connectors', 'show', '--id', ref.target, ...(isJson ? ['--json'] : []), ...htmlOptions]);
             return;
         }
         if (ref.kind === 'context') {
@@ -870,8 +950,22 @@ export async function handleShow(args, context, configPath, executeCommand) {
     }
     if (level === 'root') {
         if (target) {
-            // Show connector details with HTML support
-            await executeCommand(['connectors', 'show', '--id', target, ...(isJson ? ['--json'] : []), ...htmlOptions]);
+            // Check if target is an A2A agent
+            let isAgent = false;
+            try {
+                const configDir = configPath.replace(/\/[^/]+$/, '');
+                const targetsStore = new TargetsStore(configDir);
+                const agents = targetsStore.list({ type: 'agent' });
+                isAgent = agents.some(a => a.id === target || a.id.startsWith(target));
+            }
+            catch { /* targets table may not exist */ }
+            if (isAgent) {
+                await executeCommand(['agent', 'show', target]);
+            }
+            else {
+                // Show connector details with HTML support
+                await executeCommand(['connectors', 'show', '--id', target, ...(isJson ? ['--json'] : []), ...htmlOptions]);
+            }
         }
         else {
             printInfo('At root level. Use: show <connector> or cc <connector>');
@@ -902,8 +996,21 @@ export async function handleShow(args, context, configPath, executeCommand) {
             await executeCommand(['sessions', 'show', '--id', matches[0].session_id, ...(isJson ? ['--json'] : []), ...htmlOptions]);
         }
         else {
-            // Show connector details with HTML support (connector-level)
-            await executeCommand(['connectors', 'show', '--id', context.connector, ...(isJson ? ['--json'] : []), ...htmlOptions]);
+            // Show connector/agent details (connector-level)
+            let isAgent = false;
+            try {
+                const configDir = configPath.replace(/\/[^/]+$/, '');
+                const targetsStore = new TargetsStore(configDir);
+                const agents = targetsStore.list({ type: 'agent' });
+                isAgent = agents.some(a => a.id === context.connector || a.id.startsWith(context.connector));
+            }
+            catch { /* targets table may not exist */ }
+            if (isAgent) {
+                await executeCommand(['agent', 'show', context.connector]);
+            }
+            else {
+                await executeCommand(['connectors', 'show', '--id', context.connector, ...(isJson ? ['--json'] : []), ...htmlOptions]);
+            }
         }
         return;
     }
@@ -912,11 +1019,17 @@ export async function handleShow(args, context, configPath, executeCommand) {
         printError('No session in context');
         return;
     }
-    // Handle --id option for specific RPC (e.g., show --html --id 1)
+    // Handle --id option for specific RPC/message (e.g., show --html --id 1)
     const rpcTarget = idValue || target;
     if (rpcTarget) {
-        // Show RPC details
-        await executeCommand(['rpc', 'show', '--session', context.session, '--id', rpcTarget, ...(isJson ? ['--json'] : []), ...htmlOptions]);
+        // A2A sessions show message details, MCP sessions show RPC details
+        if (context.proto === 'a2a') {
+            const configDir = configPath.replace(/\/[^/]+$/, '');
+            await showA2AMessage(configDir, context.session, rpcTarget, isJson);
+        }
+        else {
+            await executeCommand(['rpc', 'show', '--session', context.session, '--id', rpcTarget, ...(isJson ? ['--json'] : []), ...htmlOptions]);
+        }
     }
     else {
         // Show session details
@@ -1058,6 +1171,39 @@ export function getLsRows(context, configPath) {
     const connectors = getConnectorRowsInternal(store, configPath);
     return { kind: 'rows', rows: connectors, rowType: 'connector' };
 }
+/**
+ * Get history result as pipeline rows for filtering
+ *
+ * Used by: history | where <filter-expr>
+ */
+export function getHistoryRows(context, configPath) {
+    const level = getContextLevel(context);
+    const configDir = configPath.replace(/\/[^/]+$/, '');
+    const eventsStore = new EventsStore(configDir);
+    if (level === 'session' && context.session) {
+        const messages = eventsStore.getA2AMessages(context.session, 100);
+        // Convert to rows format
+        const rows = messages.map(m => ({
+            id: m.id,
+            role: m.role,
+            content: m.content,
+            timestamp: m.timestamp,
+        }));
+        return { kind: 'rows', rows, rowType: 'a2a-message' };
+    }
+    if (level === 'connector' && context.connector) {
+        const messages = eventsStore.getA2AMessagesForTarget(context.connector, 100);
+        const rows = messages.map(m => ({
+            id: m.id,
+            session_id: m.sessionId,
+            role: m.role,
+            content: m.content,
+            timestamp: m.timestamp,
+        }));
+        return { kind: 'rows', rows, rowType: 'a2a-message' };
+    }
+    return { kind: 'rows', rows: [], rowType: 'a2a-message' };
+}
 /**
  * Extract tool name from request JSON.
  * Fallback chain: params.name ?? params.tool ?? params.toolName
@@ -1132,13 +1278,14 @@ function getRpcRowsInternal(store, sessionId) {
     });
 }
 /**
- * Get session rows for a connector (internal helper)
+ * Get session rows for a target (internal helper)
  */
-function getSessionRowsInternal(store, connectorId) {
-    const sessions = store.getSessions(connectorId, PIPELINE_SESSION_LIMIT);
+function getSessionRowsInternal(store, targetId) {
+    const sessions = store.getSessions(targetId, PIPELINE_SESSION_LIMIT);
     return sessions.map((session) => ({
         session_id: session.session_id,
-        connector_id: connectorId,
+        connector_id: targetId,
+        target_id: targetId,
         started_at: session.started_at,
         ended_at: session.ended_at,
         event_count: session.event_count ?? 0,
@@ -1158,4 +1305,806 @@ function getConnectorRowsInternal(store, configPath) {
         created_at: c.latest_session ?? new Date().toISOString(),
     }));
 }
+// ===== send command (A2A) =====
+/**
+ * Send a message to an A2A agent
+ * Usage: send <message>
+ * Must be cd'd into an A2A agent target
+ */
+export async function handleA2ASend(args, context, configPath) {
+    const level = getContextLevel(context);
+    if (level === 'root') {
+        printError('Not in a target context. Use: cd <agent-id> first, then send <message>');
+        return;
+    }
+    if (!context.connector) {
+        printError('No target in context');
+        return;
+    }
+    const message = args.join(' ').trim();
+    if (!message) {
+        printError('Usage: send <message>');
+        printInfo('Example: send hello');
+        return;
+    }
+    // Check if current target is an A2A agent
+    const configDir = configPath.replace(/\/[^/]+$/, '');
+    let agentCard;
+    let allowLocal = false;
+    try {
+        const targetsStore = new TargetsStore(configDir);
+        const agents = targetsStore.list({ type: 'agent' });
+        const agent = agents.find(a => a.id === context.connector);
+        if (!agent) {
+            printError(`'${context.connector}' is not an A2A agent. send is only for A2A agents.`);
+            return;
+        }
+        // Get allow_local from agent config (set during agent add --allow-local)
+        const agentConfig = agent.config;
+        allowLocal = agentConfig?.allow_local ?? false;
+        // Get cached agent card
+        const cacheStore = new AgentCacheStore(configDir);
+        const cache = cacheStore.get(agent.id);
+        if (!cache?.agentCard) {
+            printError(`No Agent Card cached for '${agent.id}'. Run: agent scan ${agent.id}${allowLocal ? ' --allow-local' : ''}`);
+            return;
+        }
+        agentCard = cache.agentCard;
+    }
+    catch (err) {
+        // Log error for debugging (visible with DEBUG=1 or similar)
+        if (process.env.DEBUG) {
+            console.error('[handleA2ASend] Agent lookup failed:', err);
+        }
+        printError(`Failed to lookup agent: ${err instanceof Error ? err.message : String(err)}`);
+        return;
+    }
+    // Initialize session manager for recording
+    let sessionManager;
+    try {
+        const eventsStore = new EventsStore(configDir);
+        sessionManager = createA2ASessionManager(eventsStore, context.connector);
+    }
+    catch {
+        // Session manager initialization failed - continue without recording
+    }
+    // Generate RPC ID for request/response pairing
+    const rpcId = randomUUID();
+    // Store request message to record later with correct contextId
+    const requestMessage = {
+        role: 'user',
+        parts: [{ text: message }],
+        messageId: randomUUID(),
+    };
+    // Send message via A2A client
+    try {
+        const client = new A2AClient(agentCard, { allowLocal });
+        // Check if agent supports streaming
+        const supportsStreaming = agentCard.capabilities?.streaming === true;
+        // Hoisted: used in both streaming and non-streaming paths
+        const isTTY = process.stdout.isTTY;
+        const botPrefix = isTTY ? '\x1b[36m🤖\x1b[0m' : '🤖';
+        // SSE Streaming mode: When agent advertises streaming capability,
+        // use streamMessage() for real-time message display instead of
+        // blocking sendMessage(). Messages are accumulated for session
+        // recording to maintain history parity with non-streaming path.
+        if (supportsStreaming) {
+            const spinner = isTTY ? ora({ text: 'Waiting for response...', spinner: 'dots' }).start() : null;
+            // Accumulate streamed messages for session recording
+            const streamedMessages = [];
+            let streamContextId;
+            // Spinner helper to avoid repetition (with error safety)
+            const withSpinner = (fn) => {
+                if (spinner)
+                    spinner.stopAndPersist();
+                try {
+                    fn();
+                }
+                finally {
+                    if (spinner)
+                        spinner.start();
+                }
+            };
+            const streamResult = await client.streamMessage(message, {
+                onStatus: (event) => {
+                    withSpinner(() => {
+                        const statusText = `[${event.status}] ${event.taskId}`;
+                        console.log(statusText);
+                        if (event.contextId)
+                            streamContextId = event.contextId;
+                        if (event.message) {
+                            streamedMessages.push(event.message);
+                            const parts = event.message.parts || [];
+                            for (const part of parts) {
+                                if ('text' in part && part.text) {
+                                    console.log(`  ${botPrefix} ${part.text}`);
+                                }
+                            }
+                        }
+                    });
+                },
+                onArtifact: (event) => {
+                    withSpinner(() => {
+                        console.log(`\n[Artifact] ${event.artifact?.name || 'unnamed'}`);
+                    });
+                },
+                onMessage: (msg) => {
+                    withSpinner(() => {
+                        // Fallback: extract contextId from message if not yet set
+                        if (msg.contextId && !streamContextId) {
+                            streamContextId = msg.contextId;
+                        }
+                        streamedMessages.push(msg);
+                        const parts = msg.parts || [];
+                        for (const part of parts) {
+                            if ('text' in part && part.text) {
+                                console.log(`${botPrefix} ${part.text}`);
+                            }
+                        }
+                    });
+                },
+                onError: (err) => {
+                    withSpinner(() => {
+                        printError(`Stream error: ${err}`);
+                    });
+                },
+            });
+            if (spinner)
+                spinner.stop();
+            if (!streamResult.ok) {
+                // Record partial messages before error (if any were received)
+                if (sessionManager && streamedMessages.length > 0) {
+                    const ctxId = streamContextId;
+                    sessionManager.recordMessage(ctxId, requestMessage, true, rpcId);
+                    for (const msg of streamedMessages) {
+                        sessionManager.recordMessage(ctxId, msg, false, rpcId);
+                    }
+                }
+                // Record error - match success pattern with completeRpcCall
+                if (sessionManager) {
+                    const eventsStore = sessionManager.getEventsStore();
+                    const sessionId = sessionManager.getOrCreateSession(streamContextId);
+                    eventsStore.completeRpcCall(sessionId, rpcId, false);
+                    sessionManager.recordError(streamContextId, rpcId, streamResult.error || 'Unknown error');
+                }
+                printError(`Stream error: ${streamResult.error}`);
+                return;
+            }
+            // Record the streaming session (request + accumulated streamed messages)
+            if (sessionManager) {
+                const ctxId = streamContextId;
+                sessionManager.recordMessage(ctxId, requestMessage, true, rpcId);
+                for (const msg of streamedMessages) {
+                    sessionManager.recordMessage(ctxId, msg, false, rpcId);
+                }
+                const eventsStore = sessionManager.getEventsStore();
+                const sessionId = sessionManager.getOrCreateSession(ctxId);
+                eventsStore.completeRpcCall(sessionId, rpcId, streamResult.ok);
+            }
+            return;
+        }
+        // Non-streaming mode (existing code unchanged)
+        const result = await client.sendMessage(message);
+        if (!result.ok) {
+            // Record error
+            if (sessionManager) {
+                sessionManager.recordError(undefined, rpcId, result.error || 'Unknown error');
+            }
+            printError(`A2A error: ${result.error}`);
+            return;
+        }
+        // Determine contextId from response (or undefined if no response)
+        const contextId = result.message?.contextId ?? result.task?.contextId;
+        // Record request first with the same contextId as the response
+        if (sessionManager) {
+            sessionManager.recordMessage(contextId, requestMessage, true, rpcId);
+            // Record response
+            if (result.message) {
+                sessionManager.recordMessage(contextId, result.message, false, rpcId);
+            }
+            else if (result.task) {
+                sessionManager.recordTask(contextId, result.task, rpcId);
+            }
+            else {
+                // No response but success - complete RPC
+                const eventsStore = sessionManager.getEventsStore();
+                const sessionId = sessionManager.getOrCreateSession(undefined);
+                eventsStore.completeRpcCall(sessionId, rpcId, true);
+            }
+        }
+        // Display response - check message first, then task
+        if (result.message) {
+            const msg = result.message;
+            if (Array.isArray(msg.parts)) {
+                for (const part of msg.parts) {
+                    if ('text' in part && part.text) {
+                        console.log(`${botPrefix} ${part.text}`);
+                    }
+                    else if ('data' in part) {
+                        console.log('📎', JSON.stringify(part.data, null, 2));
+                    }
+                }
+            }
+        }
+        else if (result.task) {
+            const task = result.task;
+            const state = task.status ?? 'unknown';
+            if (state === 'completed' && Array.isArray(task.artifacts)) {
+                // Show artifacts for completed tasks
+                for (const artifact of task.artifacts) {
+                    if (artifact.parts) {
+                        for (const part of artifact.parts) {
+                            if ('text' in part && part.text) {
+                                console.log(`${botPrefix} ${part.text}`);
+                            }
+                        }
+                    }
+                }
+            }
+            else if (task.messages && task.messages.length > 0) {
+                // Show latest agent message
+                const agentMsgs = task.messages.filter(m => m.role === 'assistant');
+                const lastMsg = agentMsgs[agentMsgs.length - 1];
+                if (lastMsg && Array.isArray(lastMsg.parts)) {
+                    for (const part of lastMsg.parts) {
+                        if ('text' in part && part.text) {
+                            console.log(`${botPrefix} ${part.text}`);
+                        }
+                    }
+                }
+                if (state !== 'completed') {
+                    printInfo(`Task ${task.id} (state: ${state})`);
+                }
+            }
+            else {
+                printInfo(`Task ${task.id} (state: ${state})`);
+            }
+        }
+        else {
+            printInfo('(no response)');
+        }
+    }
+    catch (err) {
+        printError(`Send failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+// ==================== A2A Session Display Functions ====================
+/**
+ * List A2A sessions for an agent
+ */
+async function listA2ASessions(configDir, targetId, _isLong, isJson, idsOnly) {
+    const eventsStore = new EventsStore(configDir);
+    const sessions = eventsStore.getA2ASessions(targetId, 50);
+    if (sessions.length === 0) {
+        printInfo(`No A2A sessions for agent: ${targetId}`);
+        printInfo('Start a conversation with: send <message>');
+        return;
+    }
+    if (isJson) {
+        const data = sessions.map(s => ({
+            id: s.session_id,
+            prefix: shortenSessionId(s.session_id),
+            message_count: s.message_count,
+            last_activity: s.last_activity,
+        }));
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    if (idsOnly) {
+        sessions.forEach(s => console.log(shortenSessionId(s.session_id)));
+        return;
+    }
+    const isTTY = process.stdout.isTTY;
+    console.log();
+    // Header
+    console.log(dimText('Session ID', isTTY).padEnd(isTTY ? 19 : 12) + '  ' +
+        dimText('Messages', isTTY).padEnd(9) + '  ' +
+        dimText('Last Activity', isTTY));
+    console.log(dimText('-'.repeat(40), isTTY));
+    // Rows
+    sessions.forEach(s => {
+        const prefix = shortenSessionId(s.session_id);
+        const activity = s.last_activity ? formatRelativeTime(s.last_activity) : '-';
+        console.log(prefix.padEnd(isTTY ? 16 : 10) + '  ' +
+            String(s.message_count).padEnd(9) + '  ' +
+            activity);
+    });
+    console.log();
+    printInfo('Hint: cd <session> to enter, show <session> for details');
+}
+/**
+ * List A2A messages for a session
+ */
+async function listA2AMessages(configDir, sessionId, _isLong, isJson, idsOnly) {
+    const eventsStore = new EventsStore(configDir);
+    const messages = eventsStore.getA2AMessages(sessionId, 100);
+    if (messages.length === 0) {
+        printInfo('No messages in this session');
+        printInfo('Start a conversation with: send <message>');
+        return;
+    }
+    if (isJson) {
+        const data = messages.map(m => ({
+            id: m.id,
+            role: m.role,
+            content: m.content,
+            timestamp: m.timestamp,
+        }));
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    if (idsOnly) {
+        messages.forEach(m => console.log(m.id));
+        return;
+    }
+    const isTTY = process.stdout.isTTY;
+    console.log();
+    // Header
+    console.log(dimText('#', isTTY).padEnd(4) + '  ' +
+        dimText('Role', isTTY).padEnd(12) + '  ' +
+        dimText('Content', isTTY).padEnd(28) + '  ' +
+        dimText('Time', isTTY));
+    console.log(dimText('-'.repeat(60), isTTY));
+    // Rows
+    messages.forEach(m => {
+        const roleColor = isTTY && m.role === 'assistant' ? '\x1b[36m' : '';
+        const roleReset = isTTY && m.role === 'assistant' ? '\x1b[0m' : '';
+        const roleDisplay = `${roleColor}${m.role}${roleReset}`;
+        const contentPreview = m.content.length > 25 ? m.content.slice(0, 25) + '...' : m.content;
+        const time = m.timestamp ? formatRelativeTime(m.timestamp) : '-';
+        console.log(String(m.id).padEnd(4) + '  ' +
+            roleDisplay.padEnd(isTTY ? 21 : 12) + '  ' +
+            contentPreview.padEnd(28) + '  ' +
+            time);
+    });
+    console.log();
+    printInfo('Hint: show <id> to view details, cd .. to go back');
+}
+/**
+ * Show A2A message details
+ */
+async function showA2AMessage(configDir, sessionId, messageIndex, isJson) {
+    const eventsStore = new EventsStore(configDir);
+    const messages = eventsStore.getA2AMessages(sessionId, 100);
+    const index = parseInt(messageIndex, 10);
+    if (isNaN(index) || index < 1 || index > messages.length) {
+        printError(`Message not found: ${messageIndex}`);
+        printInfo(`Valid range: 1-${messages.length}`);
+        return;
+    }
+    const message = messages[index - 1];
+    if (isJson) {
+        console.log(JSON.stringify({
+            id: message.id,
+            role: message.role,
+            content: message.content,
+            timestamp: message.timestamp,
+        }, null, 2));
+        return;
+    }
+    const isTTY = process.stdout.isTTY;
+    console.log();
+    // Role with color
+    const roleColor = isTTY && message.role === 'assistant' ? '\x1b[36m' : '';
+    const roleReset = isTTY && message.role === 'assistant' ? '\x1b[0m' : '';
+    const roleEmoji = message.role === 'assistant' ? '🤖' : '👤';
+    console.log(`${roleEmoji} ${roleColor}${message.role}${roleReset}`);
+    console.log(dimText('─'.repeat(60), isTTY));
+    console.log(message.content);
+    console.log(dimText('─'.repeat(60), isTTY));
+    console.log(dimText(`Timestamp: ${message.timestamp}`, isTTY));
+    console.log();
+}
+// History command display constants
+const HISTORY_LINE_WIDTH = 70;
+// ANSI color codes add 9 chars (e.g., '\x1b[36m' + '\x1b[0m'), so TTY needs +9 for role padding
+const ROLE_PAD_TTY = 21;
+const ROLE_PAD_PLAIN = 12;
+/**
+ * Handle history command - show A2A message history or Task events with filtering
+ *
+ * Usage (messages):
+ *   history              - Show all messages
+ *   history -n 20        - Show last 20 messages
+ *   history --role user  - Show only user messages
+ *   history --search <query> - Search messages by text
+ *
+ * Usage (tasks - Phase 2.4):
+ *   history --task       - Show recent task events (last 20)
+ *   history --task <id>  - Show events for a specific task
+ *
+ * @param args - Command arguments
+ * @param context - Shell context
+ * @param configPath - Configuration path
+ */
+export async function handleHistory(args, context, configPath) {
+    // Handle help flag first
+    if (args.includes('-h') || args.includes('--help')) {
+        console.log(`
+Usage: history [options]
+
+Show A2A message history or Task events for the current context.
+
+Message History (default):
+  At session level: shows messages in current session.
+  At connector level: shows messages across all sessions.
+
+Task History (Phase 2.4):
+  history --task         Show recent task events (last 20)
+  history --task <id>    Show events for a specific task
+
+Options (messages):
+  -n <count>             Show last N messages (default: 100, max: 10000)
+  --role <role>          Filter by role: 'user' or 'assistant'
+  -s, --search <query>   Search messages (case-insensitive)
+  -h, --help             Show this help
+
+Examples:
+  history                Show all messages
+  history -n 20          Show last 20 messages
+  history --role user    Show only user messages
+  history -s d20         Search for 'd20' in messages
+  history --task         Show recent task events
+  history --task abc123   Show events for task abc123
+`);
+        return;
+    }
+    const level = getContextLevel(context);
+    if (level === 'root') {
+        printError('Not in a session. Use: cd <agent-id>/<session-id> first');
+        printInfo('Tip: history -h for usage');
+        return;
+    }
+    if (!context.connector) {
+        printError('No target in context');
+        return;
+    }
+    // Default and maximum limit to prevent DoS
+    const DEFAULT_LIMIT = 100;
+    const MAX_LIMIT = 10000;
+    // Parse arguments
+    let limit = DEFAULT_LIMIT;
+    let roleFilter = null;
+    let searchQuery = null;
+    let taskId = null; // Phase 2.4: --task <id>
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '-n' && i + 1 < args.length) {
+            const limitStr = args[i + 1];
+            const parsedLimit = parseInt(limitStr, 10);
+            if (!isNaN(parsedLimit) && parsedLimit > 0) {
+                limit = parsedLimit;
+                i++;
+            }
+            else {
+                printError(`Invalid limit: ${limitStr}`);
+                return;
+            }
+        }
+        else if (arg === '--role' && i + 1 < args.length) {
+            const role = args[i + 1];
+            if (role === 'user' || role === 'assistant') {
+                roleFilter = role;
+                i++;
+            }
+            else {
+                printError(`Invalid role: ${role}. Use 'user' or 'assistant'`);
+                return;
+            }
+        }
+        else if ((arg === '--search' || arg === '-s') && i + 1 < args.length) {
+            searchQuery = args[i + 1];
+            i++;
+        }
+        else if (arg === '--task') {
+            // Phase 2.4: --task option for task event history
+            if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
+                taskId = args[i + 1];
+                i++;
+            }
+        }
+        else if (arg.startsWith('-')) {
+            // Unknown option - warn user
+            printError(`Unknown option: ${arg}`);
+            printInfo('Use: history -h for usage');
+            return;
+        }
+    }
+    // Cap limit to prevent DoS
+    if (limit > MAX_LIMIT) {
+        printInfo(`Limit capped to ${MAX_LIMIT}`);
+        limit = MAX_LIMIT;
+    }
+    const configDir = configPath.replace(/\/[^/]+$/, '');
+    const eventsStore = new EventsStore(configDir);
+    // ==================== Phase 2.4.1: Task Event History ====================
+    if (taskId !== null) {
+        // history --task <id>: Show timeline for a specific task
+        const taskEvents = eventsStore.getTaskEventsByTaskId(taskId);
+        if (taskEvents.length === 0) {
+            printInfo(`No task events found for: ${taskId}`);
+            return;
+        }
+        // Filter: remove duplicate status updates (only show transitions)
+        const filteredEvents = [];
+        let lastStatus = null;
+        for (const event of taskEvents) {
+            const payload = JSON.parse(event.payload_json);
+            // Always show non-updated events (created, completed, failed, canceled, client errors)
+            if (event.event_kind !== 'a2a:task:updated') {
+                filteredEvents.push(event);
+                lastStatus = payload.status;
+                continue;
+            }
+            // For updated events, only show if status changed
+            if (payload.status !== lastStatus) {
+                filteredEvents.push(event);
+                lastStatus = payload.status;
+            }
+        }
+        const isTTY = process.stdout.isTTY;
+        console.log();
+        // Header
+        console.log(dimText('#', isTTY).padEnd(4) + '  ' +
+            dimText('Time', isTTY).padEnd(10) + '  ' +
+            dimText('Category', isTTY).padEnd(14) + '  ' +
+            dimText('Status', isTTY).padEnd(12) + '  ' +
+            dimText('Details', isTTY));
+        console.log(dimText('-'.repeat(70), isTTY));
+        // Normalize event kind to category
+        const getCategory = (kind) => {
+            if (kind === 'a2a:task:created')
+                return 'created';
+            if (kind === 'a2a:task:updated')
+                return 'status';
+            if (kind === 'a2a:task:completed' || kind === 'a2a:task:failed' || kind === 'a2a:task:canceled')
+                return 'terminal';
+            if (kind.includes('timeout') || kind.includes('error'))
+                return 'client_error';
+            return kind.replace('a2a:task:', '');
+        };
+        // Rows
+        filteredEvents.forEach((event, idx) => {
+            const payload = JSON.parse(event.payload_json);
+            const timeStr = event.ts ? event.ts.slice(11, 19) : '--:--:--';
+            const category = getCategory(event.event_kind);
+            // Color-code category
+            let categoryStr = category;
+            let statusStr = payload.status || '';
+            if (isTTY) {
+                switch (category) {
+                    case 'terminal':
+                        if (payload.status === 'completed') {
+                            categoryStr = '\x1b[32m' + category + '\x1b[0m'; // green
+                            statusStr = '\x1b[32m' + statusStr + '\x1b[0m';
+                        }
+                        else {
+                            categoryStr = '\x1b[31m' + category + '\x1b[0m'; // red
+                            statusStr = '\x1b[31m' + statusStr + '\x1b[0m';
+                        }
+                        break;
+                    case 'client_error':
+                        categoryStr = '\x1b[31m' + category + '\x1b[0m'; // red
+                        break;
+                    case 'status':
+                        categoryStr = '\x1b[33m' + category + '\x1b[0m'; // yellow
+                        break;
+                    default:
+                        break;
+                }
+            }
+            // Build details string
+            let details = '';
+            if (payload.error) {
+                details = payload.error;
+            }
+            if (payload.messages && Array.isArray(payload.messages) && payload.messages.length > 0) {
+                details = details ? `${details} | ${payload.messages.length} msgs` : `${payload.messages.length} msgs`;
+            }
+            console.log(String(idx + 1).padEnd(4) + '  ' +
+                timeStr.padEnd(10) + '  ' +
+                categoryStr.padEnd(isTTY ? 23 : 14) + '  ' +
+                statusStr.padEnd(isTTY ? 21 : 12) + '  ' +
+                details);
+        });
+        console.log();
+        const skipped = taskEvents.length - filteredEvents.length;
+        if (skipped > 0) {
+            printInfo(`Showing ${filteredEvents.length} event${filteredEvents.length !== 1 ? 's' : ''} (${skipped} duplicate status updates hidden)`);
+        }
+        else {
+            printInfo(`Showing ${filteredEvents.length} event${filteredEvents.length !== 1 ? 's' : ''}`);
+        }
+        return;
+    }
+    // Check for --task flag without taskId (show task summary list)
+    if (args.includes('--task')) {
+        const taskEvents = eventsStore.getRecentTaskEvents(500); // Get more events to aggregate
+        if (taskEvents.length === 0) {
+            printInfo('No task events found');
+            return;
+        }
+        // Aggregate events by taskId
+        const taskSummary = new Map();
+        for (const event of taskEvents) {
+            const payload = JSON.parse(event.payload_json);
+            const existing = taskSummary.get(event.task_id);
+            if (!existing) {
+                taskSummary.set(event.task_id, {
+                    taskId: event.task_id,
+                    status: payload.status || 'unknown',
+                    eventCount: 1,
+                    lastTs: event.ts,
+                    hasError: event.event_kind.includes('failed') || event.event_kind.includes('timeout') || event.event_kind.includes('error'),
+                });
+            }
+            else {
+                existing.eventCount++;
+                existing.status = payload.status || existing.status;
+                if (event.ts > existing.lastTs) {
+                    existing.lastTs = event.ts;
+                }
+                if (event.event_kind.includes('failed') || event.event_kind.includes('timeout') || event.event_kind.includes('error')) {
+                    existing.hasError = true;
+                }
+            }
+        }
+        // Sort by lastTs descending and limit
+        const sortedTasks = Array.from(taskSummary.values())
+            .sort((a, b) => b.lastTs.localeCompare(a.lastTs))
+            .slice(0, limit);
+        const isTTY = process.stdout.isTTY;
+        console.log();
+        // Header
+        console.log(dimText('Task ID', isTTY).padEnd(14) + '  ' +
+            dimText('Status', isTTY).padEnd(12) + '  ' +
+            dimText('Events', isTTY).padEnd(8) + '  ' +
+            dimText('Last Activity', isTTY));
+        console.log(dimText('-'.repeat(60), isTTY));
+        // Rows
+        for (const task of sortedTasks) {
+            const taskIdShort = task.taskId.slice(0, 12) + '...';
+            // Color-code status
+            let statusStr = task.status;
+            if (isTTY) {
+                if (task.status === 'completed') {
+                    statusStr = '\x1b[32m' + task.status + '\x1b[0m'; // green
+                }
+                else if (task.hasError || task.status === 'failed' || task.status === 'canceled') {
+                    statusStr = '\x1b[31m' + task.status + '\x1b[0m'; // red
+                }
+                else if (task.status === 'working') {
+                    statusStr = '\x1b[33m' + task.status + '\x1b[0m'; // yellow
+                }
+            }
+            // Format time as relative
+            const lastDate = new Date(task.lastTs);
+            const now = new Date();
+            const diffMs = now.getTime() - lastDate.getTime();
+            const diffMin = Math.floor(diffMs / 60000);
+            let timeAgo;
+            if (diffMin < 1) {
+                timeAgo = 'just now';
+            }
+            else if (diffMin < 60) {
+                timeAgo = `${diffMin}m ago`;
+            }
+            else if (diffMin < 1440) {
+                timeAgo = `${Math.floor(diffMin / 60)}h ago`;
+            }
+            else {
+                timeAgo = `${Math.floor(diffMin / 1440)}d ago`;
+            }
+            console.log(taskIdShort.padEnd(14) + '  ' +
+                statusStr.padEnd(isTTY ? 21 : 12) + '  ' + // Extra padding for ANSI codes
+                String(task.eventCount).padEnd(8) + '  ' +
+                timeAgo);
+        }
+        console.log();
+        printInfo(`Showing ${sortedTasks.length} task${sortedTasks.length !== 1 ? 's' : ''}`);
+        printInfo('Use: history --task <id> for task timeline');
+        return;
+    }
+    // ====================================================================
+    // Connector level: search across all sessions for this target
+    if (level === 'connector') {
+        // Get messages across all sessions for this target
+        const messages = eventsStore.getA2AMessagesForTarget(context.connector, limit * 2);
+        // Apply filters
+        let filteredMessages = messages;
+        if (roleFilter) {
+            filteredMessages = filteredMessages.filter(m => m.role === roleFilter);
+        }
+        if (searchQuery) {
+            const lowerQuery = searchQuery.toLowerCase();
+            filteredMessages = filteredMessages.filter(m => m.content.toLowerCase().includes(lowerQuery));
+        }
+        // Apply limit after filtering (get newest N)
+        if (filteredMessages.length > limit) {
+            filteredMessages = filteredMessages.slice(0, limit);
+        }
+        // Reverse to display in chronological order (oldest first)
+        filteredMessages = filteredMessages.reverse();
+        if (filteredMessages.length === 0) {
+            printInfo('No messages match the criteria');
+            return;
+        }
+        const isTTY = process.stdout.isTTY;
+        console.log();
+        // Header (with Session column for connector level)
+        console.log(dimText('#', isTTY).padEnd(4) + '  ' +
+            dimText('Session', isTTY).padEnd(isTTY ? 16 : 10) + '  ' +
+            dimText('Time', isTTY).padEnd(10) + '  ' +
+            dimText('Role', isTTY).padEnd(12) + '  ' +
+            dimText('Content', isTTY));
+        console.log(dimText('-'.repeat(HISTORY_LINE_WIDTH + 10), isTTY));
+        // Rows
+        filteredMessages.forEach(m => {
+            const sessionPrefix = shortenSessionId(m.sessionId);
+            const timeStr = m.timestamp ? m.timestamp.slice(11, 19) : '--:--:--';
+            const roleColor = isTTY && m.role === 'assistant' ? '\x1b[36m' : '';
+            const roleReset = isTTY && m.role === 'assistant' ? '\x1b[0m' : '';
+            const roleDisplay = `${roleColor}${m.role}${roleReset}`;
+            console.log(String(m.id).padEnd(4) + '  ' +
+                sessionPrefix.padEnd(isTTY ? 16 : 10) + '  ' +
+                timeStr.padEnd(10) + '  ' +
+                roleDisplay.padEnd(isTTY ? ROLE_PAD_TTY : ROLE_PAD_PLAIN) + '  ' +
+                m.content);
+        });
+        console.log();
+        printInfo(`Showing ${filteredMessages.length} message${filteredMessages.length !== 1 ? 's' : ''} across ${new Set(filteredMessages.map(m => m.sessionId)).size} session${new Set(filteredMessages.map(m => m.sessionId)).size !== 1 ? 's' : ''}`);
+        return;
+    }
+    // Session level
+    if (!context.session) {
+        printError('Not in a session. Use: cd <session-id> to enter a session');
+        printInfo('Tip: history -h for usage');
+        return;
+    }
+    if (context.proto !== 'a2a') {
+        printError('history is only available for A2A sessions');
+        printInfo('Use: ls or rpc to view this session');
+        return;
+    }
+    // Get messages with higher limit for filtering
+    const messages = eventsStore.getA2AMessages(context.session, limit * 2);
+    // Apply filters
+    let filteredMessages = messages;
+    if (roleFilter) {
+        filteredMessages = filteredMessages.filter(m => m.role === roleFilter);
+    }
+    if (searchQuery) {
+        const lowerQuery = searchQuery.toLowerCase();
+        filteredMessages = filteredMessages.filter(m => m.content.toLowerCase().includes(lowerQuery));
+    }
+    // Apply limit after filtering
+    if (filteredMessages.length > limit) {
+        filteredMessages = filteredMessages.slice(-limit);
+    }
+    if (filteredMessages.length === 0) {
+        printInfo('No messages match the criteria');
+        return;
+    }
+    const isTTY = process.stdout.isTTY;
+    console.log();
+    // Header
+    console.log(dimText('#', isTTY).padEnd(4) + '  ' +
+        dimText('Time', isTTY).padEnd(10) + '  ' +
+        dimText('Role', isTTY).padEnd(12) + '  ' +
+        dimText('Content', isTTY));
+    console.log(dimText('-'.repeat(HISTORY_LINE_WIDTH), isTTY));
+    // Rows
+    filteredMessages.forEach(m => {
+        const timeStr = m.timestamp ? m.timestamp.slice(11, 19) : '--:--:--';
+        const roleColor = isTTY && m.role === 'assistant' ? '\x1b[36m' : '';
+        const roleReset = isTTY && m.role === 'assistant' ? '\x1b[0m' : '';
+        const roleDisplay = `${roleColor}${m.role}${roleReset}`;
+        console.log(String(m.id).padEnd(4) + '  ' +
+            timeStr.padEnd(10) + '  ' +
+            roleDisplay.padEnd(isTTY ? ROLE_PAD_TTY : ROLE_PAD_PLAIN) + '  ' +
+            m.content);
+    });
+    console.log();
+    printInfo(`Showing ${filteredMessages.length} message${filteredMessages.length !== 1 ? 's' : ''}`);
+}
 //# sourceMappingURL=router-commands.js.map