@phuetz/code-buddy 0.3.0 → 1.0.0-rc.8

package/dist/commands/handlers/fleet-handler.js

@@ -0,0 +1,1580 @@
+/**
+ * Fleet listener slash command handler — `/fleet` (Phase (d).5 → (d).12 V0.4.1).
+ *
+ * Closes the inter-Claude streaming loop started in (d).1: connects to a
+ * peer Code Buddy's Gateway WebSocket, subscribes to fleet:* events, and
+ * prints them live to the chat. Authentication uses the existing apiKey
+ * path; the key must have the `fleet:listen` scope.
+ *
+ * Sub-actions:
+ *   /fleet listen <ws-url> [--api-key <key>] [--name <id>]
+ *                  [--auto-reconnect [--max-attempts <n>]]
+ *                                              Connect + start streaming.
+ *                                              --name (Phase (d).12) gives
+ *                                              the peer a stable id; default
+ *                                              is derived from the WS host.
+ *                                              --auto-reconnect (Phase (d).6)
+ *                                              keeps the listener alive
+ *                                              across ws drops with
+ *                                              exponential-backoff retry.
+ *   /fleet stop [name|--all]                    Disconnect a peer (or all).
+ *                                              Defaults to the only active
+ *                                              listener when there's one.
+ *   /fleet status                               Show all connected peers.
+ *   /fleet history [N] [--peer <name>]          Show last N fleet:* events
+ *                                              from one peer (or the only
+ *                                              one if not specified).
+ *
+ * Phase (d).12 — multi-peer fan-in: a single Claude can now hold N
+ * simultaneous /fleet listen sessions to different peers, each with its
+ * own auto-reconnect, presence beacon, compaction state and event ring.
+ *
+ * Honest scope cuts (V0.4.1):
+ * - apiKey can come from --api-key flag or CODEBUDDY_FLEET_API_KEY env;
+ *   no TOML wiring yet (the rest of the codebase reads server keys from
+ *   env, so this matches).
+ * - Routing actif (sending tasks to peers) is Phase (d).13.
+ */
+import { logger } from '../../utils/logger.js';
+import { getFleetRegistry, } from '../../fleet/fleet-registry.js';
+import { executePeerDelegate } from '../../tools/peer-delegate-tool.js';
+import { executeRoutePeer, } from '../../tools/route-peer-tool.js';
+import { FLEET_DISPATCH_PROFILES, normalizeDispatchProfile, } from '../../fleet/dispatch-profile.js';
+// eslint-disable-next-line no-control-regex -- Fleet stream chunks may contain terminal control bytes from remote peers.
+const ANSI_ESCAPE_PATTERN = /\x1B\[[0-?]*[ -/]*[@-~]/g;
+// eslint-disable-next-line no-control-regex -- Keep human line breaks, strip the rest before writing to the operator TTY.
+const UNSAFE_CONTROL_CHARS_PATTERN = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g;
+function sanitizeFleetStreamChunk(delta) {
+    return delta
+        .replace(ANSI_ESCAPE_PATTERN, '')
+        .replace(UNSAFE_CONTROL_CHARS_PATTERN, '');
+}
+const HELP = `Usage: /fleet <action> [args]
+
+Actions:
+  listen <ws-url> [--api-key <key>]   Connect to a peer Code Buddy's WS
+         [--name <id>]                and stream fleet:* events live.
+         [--auto-reconnect]           Example: /fleet listen ws://100.98.18.76:3000/ws
+         [--max-attempts <n>]         apiKey from --api-key flag or
+                                      CODEBUDDY_FLEET_API_KEY env. Must
+                                      have fleet:listen scope on the peer.
+                                      --name (d).12 gives the peer a stable
+                                      id; default derived from the WS host.
+                                      --auto-reconnect (d).6 keeps the
+                                      listener alive across ws drops.
+                                      --max-attempts caps retry tries
+                                      (default 5; with --auto-reconnect).
+  stop [name|--all]                   Disconnect a peer (or all). Defaults
+                                      to the only active listener when one.
+  status [--with-sessions]            Show all connected peers + their state.
+                                      --with-sessions fans out peer.chat-session.list
+                                      to each peer (in parallel, 5s timeout) and
+                                      prints the open chat sessions per peer.
+  history [N] [--peer <name>]         Show last N fleet:* events from one
+            [--type <glob>] [--json]   peer (default 20, caps at ring size).
+                                      --type filters by event-type glob
+                                      (e.g. "fleet:agent:tool*"). --json
+                                      emits raw event records as JSON
+                                      for pipe-to-jq workflows.
+  describe [peer] [--timeout <ms>]    Human wrapper around peer.describe.
+            [--json]                  Defaults to the only active peer when
+                                      exactly one listener is connected.
+  send <peer> <method> [json-params]  (Phase (d).13) Invoke a peer RPC
+            [--timeout <ms>]          method synchronously and print the
+                                      response. Method names are dotted,
+                                      e.g. "peer.describe" / "peer.ping" /
+                                      "peer.echo". The peer's apiKey must
+                                      have peer:invoke scope. Default
+                                      timeout is 30000ms.
+  tool <peer> <name> [json-args]      (Phase (d).23 / V1.3) UX wrapper
+            [--timeout <ms>]          around peer.tool.invoke for the
+            [--stream]                read-only allowlist {view_file,
+                                      list_directory, search}. With
+                                      --stream, prints peer:chunk frames
+                                      live (uses peer.tool.invoke.stream).
+                                      Example: /fleet tool darkstar
+                                      view_file {"file_path":"README.md"}
+  route <prompt>                      Choose the best peer/model for a task
+            [--privacy public|sensitive]
+            [--profile balanced|research|code|review|safe]
+            [--max-cost-usd <n>]       using peer.describe + TaskRouter.
+            [--max-latency-ms <n>]     Use --delegate to immediately run the
+            [--parallelism <n>]        selected peer.chat lane. Use --json
+            [--estimated-tokens <n>]   for machine-readable output.
+            [--timeout <ms>]
+            [--delegate]
+            [--delegate-timeout <ms>]
+            [--council]                Plan a consensus council: same
+                                      question to ≥2 peers + deterministic
+                                      agreement score. Planning-only at the
+                                      CLI — execute it from Cowork.
+            [--json]
+  chat start <peer>                   (V1.2.1) UX wrapper around
+       [--system "<prompt>"]          peer.chat-session.* — opens a
+       [--model <id>]                 multi-turn session with stable alias
+       [--profile balanced|research|code|review|safe]
+       [--name <alias>]               so you don't have to copy sessionId
+                                      between turns.
+  chat say <message>                  Send the next user turn. Uses the
+       [--session <alias>]            single active session, the last
+                                      started one, or --session override.
+  chat end [<alias>] | --all          Close one (or all) chat sessions.
+  chat list                           Show open chat sessions.
+  autonomous status                   (Phase (d).18) Show Autonomous Fleet
+            tick-now                  Protocol v0.1 config + state. tick-now
+                                      fires a one-shot tick (pull, claim a
+                                      task, run, log, push). Configured via
+                                      TOML [autonomous_fleet].
+
+Phase (d).5 → (d).18 — multi-peer fan-in, opt-in auto-reconnect,
+presence beacon, compaction notices, in-memory event history, active peer
+RPC routing, autonomous task claim/exec loop.`;
+/** Default count rendered by `/fleet history` when no N supplied. */
+const HISTORY_DEFAULT_COUNT = 20;
+/** Stale threshold for /fleet status `⚠ stale` flag (Phase (d).9). */
+const STALE_THRESHOLD_MS = 90_000;
+function textResult(content) {
+    return {
+        handled: true,
+        entry: { type: 'assistant', content, timestamp: new Date() },
+    };
+}
+/**
+ * Phase (d).11 — format the time portion of a history line as HH:mm:ss.
+ * Uses local timezone (matches the user's terminal display).
+ */
+function formatHistoryTime(at) {
+    const d = new Date(at);
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+/**
+ * Phase (d).11 — render a one-line summary of a fleet event payload,
+ * keyed off the event type. Goal: make /fleet history scannable at a
+ * glance without forcing the reader to dig into the JSON.
+ */
+function summarizeHistoryPayload(type, payload) {
+    if (type === 'fleet:peer:heartbeat')
+        return '(heartbeat)';
+    if (type === 'fleet:peer:compacting:start')
+        return '(compacting started)';
+    if (type === 'fleet:peer:compacting:complete') {
+        const strategy = typeof payload.strategy === 'string' ? payload.strategy : 'unknown';
+        const dur = typeof payload.durationMs === 'number' ? `${payload.durationMs}ms` : 'n/a';
+        return `(compacted: ${strategy} ${dur})`;
+    }
+    if (type.startsWith('fleet:agent:tool')) {
+        const tool = typeof payload.toolName === 'string'
+            ? payload.toolName
+            : typeof payload.tool === 'string'
+                ? payload.tool
+                : 'unknown';
+        return `tool=${tool}`;
+    }
+    if (type.startsWith('fleet:workflow:')) {
+        const wid = typeof payload.workflowId === 'string' ? payload.workflowId : 'unknown';
+        return `workflowId=${wid}`;
+    }
+    if (type.startsWith('fleet:session:')) {
+        const child = typeof payload.childSessionId === 'string' ? payload.childSessionId :
+            typeof payload.sessionId === 'string' ? payload.sessionId :
+                'unknown';
+        return `child=${child}`;
+    }
+    // Fallback: stringify and clip. Excludes the `source` key (already
+    // rendered in the source column).
+    const filtered = {};
+    for (const [k, v] of Object.entries(payload)) {
+        if (k !== 'source')
+            filtered[k] = v;
+    }
+    const json = JSON.stringify(filtered);
+    return json.length > 60 ? json.slice(0, 57) + '...' : json;
+}
+/** Phase (d).11 — render the source column "[hostname:agentShort]" or "" when unknown. */
+function formatHistorySource(record) {
+    if (!record.hostname && !record.agentId)
+        return '';
+    const host = record.hostname ?? '?';
+    const agent = record.agentId ? `:${record.agentId.slice(0, 8)}` : '';
+    return ` [${host}${agent}]`;
+}
+/**
+ * Phase (d).12 — derive a default peer id from the WS URL (host:port).
+ * `ws://100.98.18.76:3000/ws` → `100-98-18-76:3000` (dots → dashes for
+ * easier shell typing in /fleet stop / --peer).
+ */
+function deriveDefaultPeerId(url) {
+    try {
+        const u = new URL(url);
+        return u.host.replace(/\./g, '-');
+    }
+    catch {
+        return `peer-${Date.now()}`;
+    }
+}
+function parseArgs(rest) {
+    let url = null;
+    let apiKey = null;
+    let name = null;
+    let autoReconnect = false;
+    let maxAttempts = null;
+    for (let i = 0; i < rest.length; i++) {
+        const arg = rest[i];
+        if (arg === undefined)
+            continue;
+        if (arg === '--api-key' && i + 1 < rest.length) {
+            apiKey = rest[i + 1] ?? null;
+            i++;
+        }
+        else if (arg === '--name' && i + 1 < rest.length) {
+            name = rest[i + 1] ?? null;
+            i++;
+        }
+        else if (arg === '--auto-reconnect') {
+            autoReconnect = true;
+        }
+        else if (arg === '--max-attempts' && i + 1 < rest.length) {
+            const n = parseInt(rest[i + 1] ?? '', 10);
+            if (Number.isFinite(n) && n > 0)
+                maxAttempts = n;
+            i++;
+        }
+        else if (!url && (arg.startsWith('ws://') || arg.startsWith('wss://'))) {
+            url = arg;
+        }
+    }
+    return { url, apiKey, name, autoReconnect, maxAttempts };
+}
+function parseStopArgs(rest) {
+    let name = null;
+    let all = false;
+    for (const arg of rest) {
+        if (arg === '--all')
+            all = true;
+        else if (!name && !arg.startsWith('--'))
+            name = arg;
+    }
+    return { name, all };
+}
+function parseHistoryArgs(rest) {
+    let count = null;
+    let peer = null;
+    let type = null;
+    let json = false;
+    for (let i = 0; i < rest.length; i++) {
+        const arg = rest[i];
+        if (arg === undefined)
+            continue;
+        if (arg === '--peer' && i + 1 < rest.length) {
+            peer = rest[i + 1] ?? null;
+            i++;
+        }
+        else if (arg === '--type' && i + 1 < rest.length) {
+            type = rest[i + 1] ?? null;
+            i++;
+        }
+        else if (arg === '--json') {
+            json = true;
+        }
+        else if (count === null && !arg.startsWith('--')) {
+            const n = parseInt(arg, 10);
+            if (Number.isFinite(n) && n > 0)
+                count = n;
+        }
+    }
+    return { count, peer, type, json };
+}
+function parseDescribeArgs(rest) {
+    let peerName = null;
+    let timeoutMs = 5_000;
+    let json = false;
+    for (let i = 0; i < rest.length; i++) {
+        const arg = rest[i];
+        if (arg === undefined)
+            continue;
+        if (arg === '--timeout') {
+            const parsed = parsePositiveIntegerFlag(arg, rest[i + 1]);
+            if (parsed.error)
+                return { peerName, timeoutMs, json, error: parsed.error };
+            timeoutMs = parsed.value ?? timeoutMs;
+            i++;
+        }
+        else if (arg === '--json') {
+            json = true;
+        }
+        else if (!peerName) {
+            peerName = arg;
+        }
+    }
+    return { peerName, timeoutMs, json };
+}
+function parsePositiveNumberFlag(flag, raw) {
+    if (raw === undefined) {
+        return { error: `Error: ${flag} expects a positive number.` };
+    }
+    const value = Number(raw);
+    if (!Number.isFinite(value) || value <= 0) {
+        return { error: `Error: ${flag} expects a positive number, got "${raw}".` };
+    }
+    return { value };
+}
+function parsePositiveIntegerFlag(flag, raw) {
+    const parsed = parsePositiveNumberFlag(flag, raw);
+    if (parsed.error || parsed.value === undefined)
+        return parsed;
+    return { value: Math.floor(parsed.value) };
+}
+function parseDispatchProfileFlag(raw) {
+    if (raw === undefined) {
+        return {
+            error: `Error: --profile expects one of ${FLEET_DISPATCH_PROFILES.join(', ')}.`,
+        };
+    }
+    if (!FLEET_DISPATCH_PROFILES.includes(raw)) {
+        return {
+            error: `Error: --profile must be one of ${FLEET_DISPATCH_PROFILES.join(', ')}, got "${raw}".`,
+        };
+    }
+    return { value: normalizeDispatchProfile(raw) };
+}
+function parseRouteArgs(rest) {
+    const promptParts = [];
+    const routeParams = {};
+    let delegate = false;
+    let delegateTimeoutMs;
+    let json = false;
+    let council = false;
+    for (let i = 0; i < rest.length; i++) {
+        const arg = rest[i];
+        if (arg === undefined)
+            continue;
+        if (arg === '--privacy' && i + 1 < rest.length) {
+            const privacy = rest[i + 1];
+            if (privacy !== 'public' && privacy !== 'sensitive') {
+                return {
+                    prompt: '',
+                    routeParams,
+                    delegate,
+                    json,
+                    error: 'Error: --privacy must be "public" or "sensitive".',
+                };
+            }
+            routeParams.privacyTag = privacy;
+            i++;
+        }
+        else if ((arg === '--profile' || arg === '--dispatch-profile') && i + 1 < rest.length) {
+            const parsed = parseDispatchProfileFlag(rest[i + 1]);
+            if (parsed.error)
+                return { prompt: '', routeParams, delegate, json, error: parsed.error };
+            routeParams.dispatchProfile = parsed.value;
+            i++;
+        }
+        else if ((arg === '--max-cost' || arg === '--max-cost-usd') && i + 1 < rest.length) {
+            const parsed = parsePositiveNumberFlag(arg, rest[i + 1]);
+            if (parsed.error)
+                return { prompt: '', routeParams, delegate, json, error: parsed.error };
+            routeParams.maxCostUsd = parsed.value;
+            i++;
+        }
+        else if ((arg === '--max-latency' || arg === '--max-latency-ms') && i + 1 < rest.length) {
+            const parsed = parsePositiveIntegerFlag(arg, rest[i + 1]);
+            if (parsed.error)
+                return { prompt: '', routeParams, delegate, json, error: parsed.error };
+            routeParams.maxLatencyMs = parsed.value;
+            i++;
+        }
+        else if (arg === '--parallelism' && i + 1 < rest.length) {
+            const parsed = parsePositiveIntegerFlag(arg, rest[i + 1]);
+            if (parsed.error)
+                return { prompt: '', routeParams, delegate, json, error: parsed.error };
+            routeParams.parallelism = parsed.value;
+            i++;
+        }
+        else if ((arg === '--estimated-tokens' || arg === '--tokens') && i + 1 < rest.length) {
+            const parsed = parsePositiveIntegerFlag(arg, rest[i + 1]);
+            if (parsed.error)
+                return { prompt: '', routeParams, delegate, json, error: parsed.error };
+            routeParams.estimatedTokens = parsed.value;
+            i++;
+        }
+        else if (arg === '--timeout' && i + 1 < rest.length) {
+            const parsed = parsePositiveIntegerFlag(arg, rest[i + 1]);
+            if (parsed.error)
+                return { prompt: '', routeParams, delegate, json, error: parsed.error };
+            routeParams.timeoutMs = parsed.value;
+            i++;
+        }
+        else if (arg === '--delegate-timeout' && i + 1 < rest.length) {
+            const parsed = parsePositiveIntegerFlag(arg, rest[i + 1]);
+            if (parsed.error)
+                return { prompt: '', routeParams, delegate, json, error: parsed.error };
+            delegateTimeoutMs = parsed.value;
+            i++;
+        }
+        else if (arg === '--delegate') {
+            delegate = true;
+        }
+        else if (arg === '--council') {
+            council = true;
+        }
+        else if (arg === '--json') {
+            json = true;
+        }
+        else {
+            promptParts.push(arg);
+        }
+    }
+    // Council mode needs at least 2 lanes to deliberate; force it here so
+    // the planned route shows the parallel fan-out the council requires.
+    if (council) {
+        routeParams.parallelism = Math.max(2, routeParams.parallelism ?? 2);
+    }
+    return {
+        prompt: promptParts.join(' ').trim(),
+        routeParams,
+        delegate,
+        ...(delegateTimeoutMs !== undefined ? { delegateTimeoutMs } : {}),
+        json,
+        council,
+    };
+}
+/**
+ * Compile a glob-ish event-type filter (e.g. `fleet:agent:tool*`) to
+ * a RegExp. Only `*` is special — everything else is escaped. `*`
+ * matches any run of non-empty characters except newline, which is
+ * what users expect from a CLI glob.
+ */
+function compileTypeFilter(pattern) {
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+    const regex = escaped.replace(/\*/g, '.*');
+    return new RegExp('^' + regex + '$');
+}
+/**
+ * Phase (d).12 — render one peer block for /fleet status.
+ * Reused logic from the V0.4.1 single-peer status; output now stacks
+ * one block per active peer.
+ */
+function formatPeerStatus(p) {
+    const elapsed = Math.round((Date.now() - p.startedAt.getTime()) / 1000);
+    const lines = [];
+    lines.push(`Peer "${p.id}"`);
+    lines.push(`  URL:     ${p.url}`);
+    lines.push(`  Uptime:  ${elapsed}s`);
+    lines.push(`  Events:  ${p.eventCount} received`);
+    if (p.autoReconnect) {
+        const attempts = p.listener.getReconnectAttempts();
+        const pending = p.listener.isReconnecting();
+        lines.push(`  Reconnect: enabled (${attempts}/${p.maxAttempts} attempts since last connect` +
+            `${pending ? ', retry pending' : ''})`);
+    }
+    else {
+        lines.push('  Reconnect: disabled');
+    }
+    // Presence
+    const seen = p.listener.getLastSeen();
+    if (seen.at === null) {
+        lines.push('  Last seen: never (no events received yet)');
+    }
+    else {
+        const ageSec = Math.round((seen.ageMs ?? 0) / 1000);
+        const reason = seen.reason ?? 'unknown';
+        const stale = p.listener.isStale(STALE_THRESHOLD_MS);
+        const prefix = stale ? `  ⚠ stale (>${STALE_THRESHOLD_MS / 1000}s) — ` : '  ';
+        lines.push(`${prefix}Last seen: ${ageSec}s ago (${reason})`);
+    }
+    // Compaction
+    const compactionState = p.listener.getPeerCompactionState();
+    if (compactionState.active) {
+        const ageSec = Math.round((compactionState.ageMs ?? 0) / 1000);
+        lines.push(`  ⏸ Peer compacting (started ${ageSec}s ago, in progress)`);
+    }
+    else if (compactionState.lastResult) {
+        const r = compactionState.lastResult;
+        const saved = typeof r.originalTokens === 'number' && typeof r.compactedTokens === 'number'
+            ? r.originalTokens - r.compactedTokens
+            : null;
+        const strategyTxt = r.strategy ?? 'unknown';
+        const durTxt = typeof r.durationMs === 'number' ? `${r.durationMs}ms` : 'n/a';
+        const savedTxt = saved !== null ? ` (saved ${saved} tokens)` : '';
+        lines.push(`  Last compaction: ${strategyTxt} in ${durTxt}${savedTxt}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Phase (d).12 — pick a default peer when /fleet stop / history is given
+ * without a name and there's exactly one listener active. Returns null
+ * when 0 or >1 listeners (caller must error / require name).
+ */
+function pickDefaultPeer() {
+    const reg = getFleetRegistry();
+    if (reg.size() !== 1)
+        return null;
+    return reg.list()[0] ?? null;
+}
+/** Module-level state. Mirror of `dispatchedTasks` in peer-chat-bridge. */
+const chatSessions = new Map();
+let activeAlias = null;
+/** Test-only — reset state between cases. Not exported in the index. */
+export function _resetChatSessionsForTests() {
+    chatSessions.clear();
+    activeAlias = null;
+}
+function deriveDefaultAlias(peerName) {
+    let n = 1;
+    while (chatSessions.has(`${peerName}-${n}`))
+        n++;
+    return `${peerName}-${n}`;
+}
+function parseChatStartArgs(rest) {
+    let peerName = null;
+    let systemPrompt = null;
+    let model = null;
+    let dispatchProfile;
+    let alias = null;
+    for (let i = 0; i < rest.length; i++) {
+        const arg = rest[i];
+        if (arg === undefined)
+            continue;
+        if ((arg === '--system' || arg === '--system-prompt') && i + 1 < rest.length) {
+            systemPrompt = rest[i + 1] ?? null;
+            i++;
+        }
+        else if (arg === '--model' && i + 1 < rest.length) {
+            model = rest[i + 1] ?? null;
+            i++;
+        }
+        else if ((arg === '--profile' || arg === '--dispatch-profile') && i + 1 < rest.length) {
+            const parsed = parseDispatchProfileFlag(rest[i + 1]);
+            if (parsed.error)
+                return { peerName, systemPrompt, model, alias, error: parsed.error };
+            dispatchProfile = parsed.value;
+            i++;
+        }
+        else if (arg === '--name' && i + 1 < rest.length) {
+            alias = rest[i + 1] ?? null;
+            i++;
+        }
+        else if (!peerName) {
+            peerName = arg;
+        }
+    }
+    return { peerName, systemPrompt, model, dispatchProfile, alias };
+}
+function parseChatSayArgs(rest) {
+    let alias = null;
+    const messageParts = [];
+    for (let i = 0; i < rest.length; i++) {
+        const arg = rest[i];
+        if (arg === undefined)
+            continue;
+        if (arg === '--session' && i + 1 < rest.length) {
+            alias = rest[i + 1] ?? null;
+            i++;
+        }
+        else {
+            messageParts.push(arg);
+        }
+    }
+    return { message: messageParts.join(' ').trim(), alias };
+}
+/**
+ * Resolve which chat session a `say`/`end` command targets. Returns
+ * either the alias or null + an error message when ambiguity prevents
+ * a unique pick. Order: explicit `--session`, single existing, last
+ * `start` (`activeAlias`).
+ */
+function resolveChatAlias(explicit) {
+    if (explicit) {
+        if (!chatSessions.has(explicit)) {
+            return {
+                alias: null,
+                error: `No chat session named "${explicit}". Active: ${[...chatSessions.keys()].join(', ') || '(none)'}`,
+            };
+        }
+        return { alias: explicit, error: null };
+    }
+    if (chatSessions.size === 0) {
+        return { alias: null, error: 'No active chat sessions. Open one with /fleet chat start <peer>.' };
+    }
+    if (chatSessions.size === 1) {
+        return { alias: [...chatSessions.keys()][0] ?? null, error: null };
+    }
+    if (activeAlias && chatSessions.has(activeAlias)) {
+        return { alias: activeAlias, error: null };
+    }
+    return {
+        alias: null,
+        error: `Multiple chat sessions active (${chatSessions.size}). Specify --session <alias>. Active: ${[...chatSessions.keys()].join(', ')}`,
+    };
+}
+function formatRelativeAge(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    const sec = Math.floor(ms / 1000);
+    if (sec < 60)
+        return `${sec}s`;
+    const min = Math.floor(sec / 60);
+    if (min < 60)
+        return `${min}m`;
+    const hr = Math.floor(min / 60);
+    return `${hr}h`;
+}
+function formatToolDecisionSummary(decisions) {
+    if (!decisions || decisions.length === 0)
+        return '';
+    const shown = decisions.slice(0, 6);
+    const suffix = decisions.length > shown.length ? `, +${decisions.length - shown.length}` : '';
+    return shown.map((decision) => `${decision.tool}=${decision.action}`).join(', ') + suffix;
+}
+function formatChatSessionPolicySummary(session) {
+    const parts = [];
+    const policyProfile = session.toolPolicy?.policyProfile ?? session.toolset?.policyProfile;
+    const defaultAction = session.toolPolicy?.defaultAction ?? session.toolset?.defaultAction;
+    if (policyProfile && defaultAction) {
+        parts.push(`policy ${policyProfile} / ${defaultAction}`);
+    }
+    if (session.toolset?.toolsetId) {
+        parts.push(`toolset ${session.toolset.toolsetId}`);
+    }
+    const decisions = formatToolDecisionSummary(session.toolDecisions ?? session.toolset?.decisions);
+    if (decisions) {
+        parts.push(`decisions ${decisions}`);
+    }
+    return parts.length > 0 ? parts.join('; ') : null;
+}
+/**
+ * Drop any chat sessions tied to a peer that's been stopped. Called
+ * from the `stop` branch right after `unregister`. The peer's
+ * connection is gone so we can't politely `peer.chat-session.end` —
+ * server-side sessions will idle out within 30 min anyway.
+ */
+function purgeChatSessionsForPeer(peerName) {
+    let dropped = 0;
+    for (const [alias, ref] of chatSessions) {
+        if (ref.peerName === peerName) {
+            chatSessions.delete(alias);
+            dropped++;
+            if (activeAlias === alias)
+                activeAlias = null;
+        }
+    }
+    if (!activeAlias && chatSessions.size > 0) {
+        activeAlias = [...chatSessions.keys()][chatSessions.size - 1] ?? null;
+    }
+    return dropped;
+}
+async function handleChat(rest) {
+    const sub = (rest[0] || 'list').trim().toLowerCase();
+    const inner = rest.slice(1);
+    if (sub === 'list') {
+        if (chatSessions.size === 0) {
+            return textResult('No active chat sessions. Open one with /fleet chat start <peer>.');
+        }
+        const lines = [];
+        lines.push(`Active chat sessions (${chatSessions.size}):`);
+        const now = Date.now();
+        for (const ref of chatSessions.values()) {
+            const age = formatRelativeAge(now - ref.lastUsedAt);
+            const modelTxt = ref.model ? `model ${ref.model}` : 'default model';
+            const profileTxt = ref.dispatchProfile ? `, profile ${ref.dispatchProfile}` : '';
+            const isActive = ref.alias === activeAlias ? '   ← active' : '';
+            lines.push(`  ${ref.alias.padEnd(20)} → ${ref.peerName.padEnd(18)} [turn ${ref.turnCount}, ${age} ago, ${modelTxt}${profileTxt}]${isActive}`);
+        }
+        return textResult(lines.join('\n'));
+    }
+    if (sub === 'start') {
+        const { peerName, systemPrompt, model, dispatchProfile, alias: explicitAlias, error, } = parseChatStartArgs(inner);
+        if (error) {
+            return textResult(error);
+        }
+        if (!peerName) {
+            return textResult('Usage: /fleet chat start <peer> [--system "<prompt>"] [--model <id>] [--profile balanced|research|code|review|safe] [--name <alias>]');
+        }
+        const target = getFleetRegistry().get(peerName);
+        if (!target) {
+            return textResult(`No fleet peer named "${peerName}". Active peers: ${getFleetRegistry().ids().join(', ') || '(none — /fleet listen first)'}`);
+        }
+        const alias = explicitAlias ?? deriveDefaultAlias(peerName);
+        if (chatSessions.has(alias)) {
+            return textResult(`Chat alias "${alias}" already in use. End it first with /fleet chat end ${alias}, or pick another --name.`);
+        }
+        const params = {};
+        if (systemPrompt)
+            params.systemPrompt = systemPrompt;
+        if (model)
+            params.model = model;
+        if (dispatchProfile)
+            params.dispatchProfile = dispatchProfile;
+        try {
+            const result = (await target.listener.request('peer.chat-session.start', params, {
+                timeoutMs: 30_000,
+            }));
+            const sessionId = result?.sessionId;
+            if (typeof sessionId !== 'string' || !sessionId) {
+                return textResult(`Peer "${peerName}" → peer.chat-session.start returned no sessionId. Got: ${JSON.stringify(result)}`);
+            }
+            const storedProfile = result.dispatchProfile ?? dispatchProfile;
+            const now = Date.now();
+            chatSessions.set(alias, {
+                alias,
+                peerName,
+                sessionId,
+                systemPrompt: systemPrompt ?? undefined,
+                model: model ?? undefined,
+                dispatchProfile: storedProfile,
+                turnCount: 0,
+                startedAt: now,
+                lastUsedAt: now,
+            });
+            activeAlias = alias;
+            const sidShort = sessionId.length > 14 ? `${sessionId.slice(0, 14)}…` : sessionId;
+            const profileTxt = storedProfile ? ` Profile: ${storedProfile}.` : '';
+            return textResult(`Chat session "${alias}" opened with ${peerName} (sessionId=${sidShort}).${profileTxt} ` +
+                `Send turns with /fleet chat say <message>.`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return textResult(`Peer "${peerName}" → peer.chat-session.start FAILED:\n  ${message}`);
+        }
+    }
+    if (sub === 'say' || sub === 'send') {
+        const { message, alias: explicitAlias } = parseChatSayArgs(inner);
+        if (!message) {
+            return textResult('Usage: /fleet chat say <message> [--session <alias>]');
+        }
+        const { alias, error } = resolveChatAlias(explicitAlias);
+        if (!alias) {
+            return textResult(error ?? 'Unable to resolve chat session.');
+        }
+        const ref = chatSessions.get(alias);
+        const target = getFleetRegistry().get(ref.peerName);
+        if (!target) {
+            // Peer disconnected behind our back. Drop the local handle.
+            chatSessions.delete(alias);
+            if (activeAlias === alias)
+                activeAlias = null;
+            return textResult(`Peer "${ref.peerName}" is no longer connected. Chat session "${alias}" dropped locally.`);
+        }
+        try {
+            const t0 = Date.now();
+            const result = (await target.listener.request('peer.chat-session.continue', { sessionId: ref.sessionId, prompt: message }, { timeoutMs: 120_000 }));
+            const elapsed = Date.now() - t0;
+            ref.turnCount++;
+            ref.lastUsedAt = Date.now();
+            ref.dispatchProfile = result.dispatchProfile ?? ref.dispatchProfile;
+            activeAlias = alias;
+            const text = result?.text ?? '';
+            const profileTxt = ref.dispatchProfile ? `, profile ${ref.dispatchProfile}` : '';
+            return textResult(`← ${alias} (${ref.peerName}) [turn ${ref.turnCount}, ${elapsed}ms${profileTxt}]:\n${text}`);
+        }
+        catch (err) {
+            const messageText = err instanceof Error ? err.message : String(err);
+            // Server-side TTL or alias drift — drop our local handle so the
+            // user sees the error once and can restart cleanly.
+            if (messageText.includes('SESSION_NOT_FOUND') || messageText.includes('SESSION_EXPIRED')) {
+                chatSessions.delete(alias);
+                if (activeAlias === alias)
+                    activeAlias = null;
+                return textResult(`Chat session "${alias}" expired or was dropped on ${ref.peerName}. ` +
+                    `Reopen with /fleet chat start ${ref.peerName} (--name ${alias}).`);
+            }
+            return textResult(`Peer "${ref.peerName}" → peer.chat-session.continue FAILED:\n  ${messageText}`);
+        }
+    }
+    if (sub === 'end') {
+        const all = inner.includes('--all');
+        if (all) {
+            let closed = 0;
+            const failures = [];
+            for (const ref of [...chatSessions.values()]) {
+                const target = getFleetRegistry().get(ref.peerName);
+                if (target) {
+                    try {
+                        await target.listener.request('peer.chat-session.end', { sessionId: ref.sessionId }, { timeoutMs: 5_000 });
+                    }
+                    catch (err) {
+                        failures.push(`${ref.alias}: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
+                chatSessions.delete(ref.alias);
+                closed++;
+            }
+            activeAlias = null;
+            const failTxt = failures.length > 0 ? ` (${failures.length} server-side close failure(s) — sessions will TTL out)` : '';
+            return textResult(`Closed ${closed} chat session(s)${failTxt}.`);
+        }
+        const explicitAlias = inner.find((a) => !a.startsWith('--')) ?? null;
+        const { alias, error } = resolveChatAlias(explicitAlias);
+        if (!alias) {
+            return textResult(error ?? 'Unable to resolve chat session.');
+        }
+        const ref = chatSessions.get(alias);
+        const target = getFleetRegistry().get(ref.peerName);
+        let serverWarn = '';
+        if (target) {
+            try {
+                await target.listener.request('peer.chat-session.end', { sessionId: ref.sessionId }, { timeoutMs: 5_000 });
+            }
+            catch (err) {
+                serverWarn = ` (server-side close failed: ${err instanceof Error ? err.message : String(err)} — session will TTL out)`;
+            }
+        }
+        chatSessions.delete(alias);
+        if (activeAlias === alias) {
+            activeAlias = chatSessions.size > 0 ? [...chatSessions.keys()][chatSessions.size - 1] ?? null : null;
+        }
+        return textResult(`Chat session "${alias}" closed${serverWarn}.`);
+    }
+    return textResult(`Unknown chat sub-action: ${sub}\n` +
+        `Usage: /fleet chat (start|say|end|list) ...\n` +
+        `  start <peer> [--system <s>] [--model <m>] [--profile <profile>] [--name <alias>]\n` +
+        `  say <message> [--session <alias>]\n` +
+        `  end [<alias>] | --all\n` +
+        `  list`);
+}
+export async function handleFleet(args) {
+    const action = (args[0] || 'status').trim().toLowerCase();
+    const rest = args.slice(1);
+    if (action === 'help' || action === '') {
+        return textResult(HELP);
+    }
+    if (action === 'status') {
+        if (getFleetRegistry().size() === 0) {
+            return textResult('No fleet listeners active.\n\n' + HELP);
+        }
+        const withSessions = rest.includes('--with-sessions');
+        const blocks = [];
+        blocks.push(`Fleet listeners — ${getFleetRegistry().size()} active`);
+        blocks.push('');
+        // When --with-sessions, fetch peer.chat-session.list from each peer
+        // in parallel so the slowest peer doesn't serialise the whole
+        // status command. Best-effort: a failing peer just gets a short
+        // "(unreachable)" note instead of a session list.
+        const sessionsByPeer = new Map();
+        if (withSessions) {
+            await Promise.all(getFleetRegistry().list().map(async (peer) => {
+                try {
+                    const result = await peer.listener.request('peer.chat-session.list', {}, { timeoutMs: 5_000 });
+                    const payload = result;
+                    sessionsByPeer.set(peer.id, payload?.sessions ?? []);
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    sessionsByPeer.set(peer.id, { error: message });
+                }
+            }));
+        }
+        for (const peer of getFleetRegistry().list()) {
+            blocks.push(formatPeerStatus(peer));
+            if (withSessions) {
+                const entry = sessionsByPeer.get(peer.id);
+                if (entry && 'error' in entry) {
+                    blocks.push(`  Chat sessions: (unreachable — ${entry.error})`);
+                }
+                else if (entry && entry.length > 0) {
+                    blocks.push(`  Chat sessions (${entry.length}):`);
+                    for (const s of entry) {
+                        const modelTxt = s.model ? `model ${s.model}` : 'default model';
+                        const profileTxt = s.dispatchProfile ? `  profile ${s.dispatchProfile}` : '';
+                        blocks.push(`    ${s.sessionId.padEnd(22)} turn ${String(s.turnCount).padEnd(2)} ` +
+                            `idle ${formatRelativeAge(s.idleMs)}  ${modelTxt}${profileTxt}`);
+                        const policySummary = formatChatSessionPolicySummary(s);
+                        if (policySummary) {
+                            blocks.push(`      ${policySummary}`);
+                        }
+                    }
+                }
+                else {
+                    blocks.push('  Chat sessions: (none open on this peer)');
+                }
+            }
+            blocks.push('');
+        }
+        blocks.push('Stop a peer with /fleet stop <name>, or all with /fleet stop --all.');
+        return textResult(blocks.join('\n'));
+    }
+    if (action === 'stop') {
+        if (getFleetRegistry().size() === 0) {
+            return textResult('No fleet listeners active to stop.');
+        }
+        const { name, all } = parseStopArgs(rest);
+        if (all) {
+            const stopped = [];
+            let chatPurged = 0;
+            for (const peer of getFleetRegistry().list()) {
+                try {
+                    await peer.listener.disconnect();
+                }
+                catch (err) {
+                    logger.debug('Fleet listener disconnect error (ignored)', { error: String(err) });
+                }
+                getFleetRegistry().unregister(peer.id);
+                chatPurged += purgeChatSessionsForPeer(peer.id);
+                stopped.push(`${peer.id} (${peer.eventCount} event(s))`);
+            }
+            const chatTxt = chatPurged > 0 ? ` Dropped ${chatPurged} chat session(s).` : '';
+            return textResult(`Fleet stopped ${stopped.length} listener(s): ${stopped.join(', ')}.${chatTxt}`);
+        }
+        let target = null;
+        if (name) {
+            target = getFleetRegistry().get(name) ?? null;
+            if (!target) {
+                return textResult(`No fleet peer named "${name}". Active peers: ${getFleetRegistry().ids().join(', ')}`);
+            }
+        }
+        else {
+            target = pickDefaultPeer();
+            if (!target) {
+                return textResult(`Multiple fleet listeners active (${getFleetRegistry().size()}). ` +
+                    `Specify a peer name or use --all. Active: ${getFleetRegistry().ids().join(', ')}`);
+            }
+        }
+        const url = target.url;
+        const count = target.eventCount;
+        const id = target.id;
+        try {
+            await target.listener.disconnect();
+        }
+        catch (err) {
+            logger.debug('Fleet listener disconnect error (ignored)', { error: String(err) });
+        }
+        getFleetRegistry().unregister(id);
+        const chatPurged = purgeChatSessionsForPeer(id);
+        const chatTxt = chatPurged > 0 ? `\nDropped ${chatPurged} chat session(s) tied to "${id}".` : '';
+        return textResult(`Fleet listener "${id}" stopped. URL: ${url}\nReceived ${count} event(s) total.${chatTxt}`);
+    }
+    if (action === 'listen') {
+        const { url, apiKey: cliKey, name: explicitName, autoReconnect, maxAttempts } = parseArgs(rest);
+        if (!url) {
+            return textResult('Usage: /fleet listen <ws-url> [--api-key <key>] [--name <id>] [--auto-reconnect] [--max-attempts <n>]\n\n' + HELP);
+        }
+        const apiKey = cliKey ?? process.env.CODEBUDDY_FLEET_API_KEY;
+        if (!apiKey) {
+            return textResult('Error: no apiKey provided.\n' +
+                'Pass --api-key <key> or set CODEBUDDY_FLEET_API_KEY env.\n' +
+                'Key must have fleet:listen scope on the peer.');
+        }
+        const peerId = explicitName ?? deriveDefaultPeerId(url);
+        if (getFleetRegistry().has(peerId)) {
+            return textResult(`Fleet peer "${peerId}" is already active for ${getFleetRegistry().get(peerId).url}. ` +
+                `Stop it first with /fleet stop ${peerId}, then re-issue /fleet listen, ` +
+                `or pick a different --name.`);
+        }
+        try {
+            const { FleetListener } = await import('../../fleet/fleet-listener.js');
+            const cap = maxAttempts ?? 5;
+            const listener = new FleetListener({
+                url,
+                apiKey,
+                autoReconnect,
+                reconnect: autoReconnect ? { maxRetries: cap } : undefined,
+            });
+            const startedAt = new Date();
+            // Phase (d).12 — wire stdout streaming with the peer id in the prefix
+            // so multi-peer output stays distinguishable when interleaved.
+            listener.on('fleet:event', (data) => {
+                const peer = getFleetRegistry().get(peerId);
+                if (peer)
+                    peer.eventCount++;
+                const source = data.payload?.source;
+                const hostInfo = source ? ` [${source.hostname}${source.agentId ? `:${source.agentId.slice(0, 8)}` : ''}]` : '';
+                process.stdout.write(`  [fleet:${peerId}${hostInfo}] ${data.type}\n`);
+            });
+            listener.on('disconnected', () => {
+                process.stdout.write(`  [fleet:${peerId}] disconnected from ${url}\n`);
+                // Without auto-reconnect, the disconnected event marks the end of
+                // the session — clear the registry entry. With auto-reconnect,
+                // disconnected starts a retry cycle, so we keep the entry.
+                if (!autoReconnect) {
+                    getFleetRegistry().unregister(peerId);
+                }
+            });
+            listener.on('error', (err) => {
+                process.stdout.write(`  [fleet:${peerId}] error: ${err.message}\n`);
+            });
+            if (autoReconnect) {
+                listener.on('reconnecting', (data) => {
+                    process.stdout.write(`  [fleet:${peerId}] reconnect attempt ${data.attempt}/${cap} in ${data.delayMs}ms\n`);
+                });
+                listener.on('reconnected', (data) => {
+                    process.stdout.write(`  [fleet:${peerId}] reconnected after ${data.attempt} attempt(s)\n`);
+                });
+                listener.on('exhausted', (data) => {
+                    process.stdout.write(`  [fleet:${peerId}] reconnect exhausted after ${data.totalAttempts} attempt(s) — listener stopped\n`);
+                    getFleetRegistry().unregister(peerId);
+                });
+            }
+            await listener.connect();
+            getFleetRegistry().register({
+                id: peerId,
+                url,
+                startedAt,
+                eventCount: 0,
+                autoReconnect,
+                maxAttempts: cap,
+                listener,
+            });
+            logger.info('Fleet listener started', { id: peerId, url, autoReconnect });
+            const reconnectNote = autoReconnect
+                ? ` Auto-reconnect enabled (max ${cap} attempts).`
+                : '';
+            return textResult(`Fleet peer "${peerId}" connected to ${url}.\n` +
+                `Streaming fleet:* events live.${reconnectNote} ` +
+                `Stop with /fleet stop ${peerId}.`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return textResult(`Fleet listener connect failed: ${msg}`);
+        }
+    }
+    if (action === 'history') {
+        if (getFleetRegistry().size() === 0) {
+            return textResult('No fleet listeners active.\n\n' + HELP);
+        }
+        const { count, peer: peerName, type: typeFilter, json } = parseHistoryArgs(rest);
+        const n = count ?? HISTORY_DEFAULT_COUNT;
+        let target = null;
+        if (peerName) {
+            target = getFleetRegistry().get(peerName) ?? null;
+            if (!target) {
+                return textResult(`No fleet peer named "${peerName}". Active peers: ${getFleetRegistry().ids().join(', ')}`);
+            }
+        }
+        else {
+            target = pickDefaultPeer();
+            if (!target) {
+                return textResult(`Multiple fleet listeners active (${getFleetRegistry().size()}). ` +
+                    `Specify --peer <name>. Active: ${getFleetRegistry().ids().join(', ')}`);
+            }
+        }
+        let history = target.listener.getEventHistory();
+        if (typeFilter) {
+            let re;
+            try {
+                re = compileTypeFilter(typeFilter);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return textResult(`Invalid --type pattern "${typeFilter}": ${msg}`);
+            }
+            history = history.filter((rec) => re.test(rec.type));
+        }
+        if (history.length === 0) {
+            if (json)
+                return textResult('[]');
+            const noteSuffix = typeFilter ? ` matching "${typeFilter}"` : '';
+            return textResult(`No fleet events recorded yet for "${target.id}"${noteSuffix}.`);
+        }
+        const slice = history.slice(Math.max(0, history.length - n));
+        if (json) {
+            // JSON output: emit each event verbatim, augmented with the
+            // peer id so consumers can pipe multiple peers' history into
+            // jq without losing context.
+            const targetId = target.id;
+            const payload = slice.map((rec) => ({
+                peer: targetId,
+                at: rec.at,
+                type: rec.type,
+                hostname: rec.hostname ?? null,
+                agentId: rec.agentId ?? null,
+                payload: rec.payload ?? null,
+            }));
+            return textResult(JSON.stringify(payload, null, 2));
+        }
+        const lines = [];
+        const filterNote = typeFilter ? ` (filter: "${typeFilter}")` : '';
+        lines.push(`Fleet event history for "${target.id}" — last ${slice.length} of ${history.length}${filterNote}`);
+        for (const rec of slice) {
+            lines.push(`  [${formatHistoryTime(rec.at)}] ${rec.type}${formatHistorySource(rec)} ${summarizeHistoryPayload(rec.type, rec.payload)}`);
+        }
+        return textResult(lines.join('\n'));
+    }
+    if (action === 'describe') {
+        return await handleDescribe(rest);
+    }
+    if (action === 'send') {
+        if (getFleetRegistry().size() === 0) {
+            return textResult('No fleet listeners active. Connect with /fleet listen first.');
+        }
+        // Parse: send <peer> <method> [json-params] [--timeout <ms>]
+        let peerName = null;
+        let method = null;
+        let jsonParams = null;
+        let timeoutMs = 30_000;
+        for (let i = 0; i < rest.length; i++) {
+            const arg = rest[i];
+            if (arg === undefined)
+                continue;
+            if (arg === '--timeout' && i + 1 < rest.length) {
+                const n = parseInt(rest[i + 1] ?? '', 10);
+                if (Number.isFinite(n) && n > 0)
+                    timeoutMs = n;
+                i++;
+            }
+            else if (!peerName) {
+                peerName = arg;
+            }
+            else if (!method) {
+                method = arg;
+            }
+            else if (!jsonParams) {
+                // Take everything from here until --timeout as the params blob,
+                // re-joining with spaces. Lets users paste un-quoted JSON.
+                const remaining = rest.slice(i);
+                const tIdx = remaining.indexOf('--timeout');
+                const blobEnd = tIdx === -1 ? remaining.length : tIdx;
+                jsonParams = remaining.slice(0, blobEnd).join(' ');
+                i += blobEnd - 1;
+            }
+        }
+        if (!peerName || !method) {
+            return textResult('Usage: /fleet send <peer> <method> [json-params] [--timeout <ms>]\n\n' + HELP);
+        }
+        const target = getFleetRegistry().get(peerName);
+        if (!target) {
+            return textResult(`No fleet peer named "${peerName}". Active peers: ${getFleetRegistry().ids().join(', ')}`);
+        }
+        let params = {};
+        if (jsonParams) {
+            try {
+                const parsed = JSON.parse(jsonParams);
+                if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+                    return textResult('Error: params must be a JSON object (e.g. {"key":"value"}).');
+                }
+                params = parsed;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return textResult(`Error: invalid JSON params: ${msg}`);
+            }
+        }
+        try {
+            const t0 = Date.now();
+            const result = await target.listener.request(method, params, { timeoutMs });
+            const elapsed = Date.now() - t0;
+            const formatted = JSON.stringify(result, null, 2);
+            return textResult(`Peer "${peerName}" → ${method} OK (${elapsed}ms):\n${formatted}`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return textResult(`Peer "${peerName}" → ${method} FAILED:\n  ${message}`);
+        }
+    }
+    if (action === 'chat') {
+        return await handleChat(rest);
+    }
+    if (action === 'route') {
+        return await handleRoute(rest);
+    }
+    if (action === 'tool') {
+        return await handleTool(rest);
+    }
+    if (action === 'autonomous') {
+        return await handleAutonomous(rest);
+    }
+    return textResult(`Unknown fleet action: ${args[0]}\n\n${HELP}`);
+}
+function summarizePeerCapabilities(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const cap = raw;
+    if (!Array.isArray(cap.models))
+        return null;
+    const providers = new Set();
+    const topModels = [];
+    for (const model of cap.models) {
+        if (!model || typeof model !== 'object')
+            continue;
+        const m = model;
+        if (typeof m.provider === 'string')
+            providers.add(m.provider);
+        if (typeof m.id === 'string' && topModels.length < 5)
+            topModels.push(m.id);
+    }
+    return {
+        egress: typeof cap.egress === 'string' ? cap.egress : 'unknown',
+        modelCount: cap.models.length,
+        providers: [...providers].sort(),
+        topModels,
+        ...(typeof cap.machineLabel === 'string' ? { machineLabel: cap.machineLabel } : {}),
+    };
+}
+function formatPeerChatProvider(raw) {
+    if (!raw || typeof raw !== 'object')
+        return 'none';
+    const provider = raw.provider;
+    const model = raw.model;
+    const local = raw.isLocal;
+    if (typeof provider !== 'string' || typeof model !== 'string')
+        return 'unknown';
+    return `${provider} / ${model}${local === true ? ' [local]' : ''}`;
+}
+function formatDescribePayload(peerName, payload) {
+    const methods = Array.isArray(payload.methods)
+        ? payload.methods.filter((m) => typeof m === 'string')
+        : [];
+    const capabilities = summarizePeerCapabilities(payload.capabilities);
+    const lines = [
+        `Fleet peer "${peerName}"`,
+        `  Hostname:      ${typeof payload.hostname === 'string' ? payload.hostname : 'unknown'}`,
+        `  PID:           ${typeof payload.pid === 'number' ? payload.pid : 'unknown'}`,
+        `  API version:   ${typeof payload.apiVersion === 'string' ? payload.apiVersion : 'unknown'}`,
+        `  Role:          ${typeof payload.role === 'string' ? payload.role : 'unknown'}`,
+        `  Max depth:     ${typeof payload.maxDepth === 'number' ? payload.maxDepth : 'unknown'}`,
+        `  Peer chat:     ${formatPeerChatProvider(payload.peerChatProvider)}`,
+        `  Methods:       ${methods.length > 0 ? methods.join(', ') : '(none)'}`,
+    ];
+    if (capabilities) {
+        lines.push(`  Capabilities: ${capabilities.modelCount} model(s), egress=${capabilities.egress}`);
+        if (capabilities.machineLabel) {
+            lines.push(`  Machine:      ${capabilities.machineLabel}`);
+        }
+        lines.push(`  Providers:    ${capabilities.providers.length > 0 ? capabilities.providers.join(', ') : '(none)'}`);
+        lines.push(`  Top models:   ${capabilities.topModels.length > 0 ? capabilities.topModels.join(', ') : '(none)'}`);
+    }
+    else {
+        lines.push('  Capabilities: none advertised');
+    }
+    return lines.join('\n');
+}
+async function handleDescribe(rest) {
+    if (getFleetRegistry().size() === 0) {
+        return textResult('No fleet listeners active. Connect with /fleet listen first.');
+    }
+    const parsed = parseDescribeArgs(rest);
+    if (parsed.error) {
+        return textResult(parsed.error);
+    }
+    let target = null;
+    if (parsed.peerName) {
+        target = getFleetRegistry().get(parsed.peerName) ?? null;
+        if (!target) {
+            return textResult(`No fleet peer named "${parsed.peerName}". Active peers: ${getFleetRegistry().ids().join(', ')}`);
+        }
+    }
+    else {
+        target = pickDefaultPeer();
+        if (!target) {
+            return textResult(`Multiple fleet listeners active (${getFleetRegistry().size()}). ` +
+                `Specify a peer name. Active: ${getFleetRegistry().ids().join(', ')}`);
+        }
+    }
+    try {
+        const result = (await target.listener.request('peer.describe', {}, { timeoutMs: parsed.timeoutMs }));
+        if (parsed.json) {
+            return textResult(JSON.stringify(result, null, 2));
+        }
+        return textResult(formatDescribePayload(target.id, result));
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return textResult(`Peer "${target.id}" → peer.describe FAILED:\n  ${message}`);
+    }
+}
+function getClassificationComplexity(classification) {
+    if (!classification || typeof classification !== 'object')
+        return 'unknown';
+    const complexity = classification.complexity;
+    return typeof complexity === 'string' ? complexity : 'unknown';
+}
+function isRoutePeerCommandData(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const candidate = value;
+    const rec = candidate.recommendation;
+    return Boolean(rec &&
+        typeof rec.peer === 'string' &&
+        typeof rec.model === 'string' &&
+        typeof rec.score === 'number');
+}
+function formatLane(label, lane) {
+    if (!lane)
+        return `${label}: none`;
+    return `${label}: ${lane.peer} / ${lane.model} (score ${lane.score.toFixed(3)})`;
+}
+function formatRoutePeerCommandData(data, council = false) {
+    const lines = [
+        'Fleet route recommendation',
+        formatLane('  Primary', data.recommendation),
+        formatLane('  Fallback', data.fallback),
+    ];
+    if (data.parallel && data.parallel.length > 0) {
+        lines.push(`  Parallel: ${data.parallel
+            .map((lane) => `${lane.peer}/${lane.model} (${lane.score.toFixed(3)})`)
+            .join(', ')}`);
+    }
+    if (council) {
+        const laneCount = data.parallel?.length ?? 0;
+        lines.push(`  Council: deterministic agreement score over ${laneCount} peer(s) — same question, ` +
+            'independent answers (LLM arbitration when an aggregator client is wired, else labeled ' +
+            'concat). Run via Cowork to execute.');
+    }
+    const profile = data.dispatchProfile ?? data.nextCall.args.dispatchProfile ?? 'balanced';
+    lines.push(`  Complexity: ${getClassificationComplexity(data.classification)}`);
+    lines.push(`  Profile: ${profile}`);
+    if (data.toolPolicy) {
+        lines.push(`  Tool policy: ${data.toolPolicy.policyProfile} / ${data.toolPolicy.defaultAction}`);
+        lines.push(`  Tool policy summary: ${data.toolPolicy.summary}`);
+    }
+    if (data.toolDecisions && data.toolDecisions.length > 0) {
+        lines.push(`  Tool decisions: ${data.toolDecisions
+            .map((decision) => `${decision.tool}=${decision.action}`)
+            .join(', ')}`);
+    }
+    lines.push(`  Rationale: ${data.rationale}`);
+    if (data.describeErrors.length > 0) {
+        lines.push(`  Describe warnings: ${data.describeErrors.length}`);
+        for (const warning of data.describeErrors.slice(0, 3)) {
+            lines.push(`    ${warning.peer}: ${warning.error}`);
+        }
+    }
+    lines.push('');
+    lines.push('Next call:');
+    const nextCallJson = {
+        peer: data.nextCall.args.peer,
+        model: data.nextCall.args.model,
+        dispatchProfile: profile,
+        prompt: data.nextCall.args.prompt,
+    };
+    lines.push(`  peer_delegate ${JSON.stringify(nextCallJson)}`);
+    const profileSuffix = profile !== 'balanced' ? ` --profile ${profile}` : '';
+    lines.push(`  or /fleet route ${JSON.stringify(data.nextCall.args.prompt)}${profileSuffix} --delegate`);
+    return lines.join('\n');
+}
+async function handleRoute(rest) {
+    const parsed = parseRouteArgs(rest);
+    if (parsed.error) {
+        return textResult(parsed.error);
+    }
+    if (!parsed.prompt) {
+        return textResult('Usage: /fleet route <prompt> [--privacy public|sensitive] [--delegate] [--json]\n\n' +
+            HELP);
+    }
+    const routeResult = await executeRoutePeer({
+        prompt: parsed.prompt,
+        ...parsed.routeParams,
+    });
+    if (!routeResult.success) {
+        if (parsed.json) {
+            return textResult(JSON.stringify(routeResult, null, 2));
+        }
+        const details = routeResult.data ? `\n${JSON.stringify(routeResult.data, null, 2)}` : '';
+        return textResult(`Fleet route FAILED:\n  ${routeResult.error ?? 'unknown error'}${details}`);
+    }
+    if (!isRoutePeerCommandData(routeResult.data)) {
+        return textResult(parsed.json
+            ? JSON.stringify(routeResult, null, 2)
+            : `Fleet route returned an unexpected payload:\n${routeResult.output ?? '(empty)'}`);
+    }
+    const routeData = routeResult.data;
+    if (!parsed.delegate) {
+        return textResult(parsed.json
+            ? JSON.stringify(routeData, null, 2)
+            : formatRoutePeerCommandData(routeData, parsed.council));
+    }
+    const delegateResult = await executePeerDelegate({
+        peer: routeData.recommendation.peer,
+        prompt: parsed.prompt,
+        model: routeData.recommendation.model,
+        dispatchProfile: routeData.nextCall.args.dispatchProfile ?? parsed.routeParams.dispatchProfile,
+        ...(parsed.delegateTimeoutMs !== undefined ? { timeoutMs: parsed.delegateTimeoutMs } : {}),
+    });
+    if (parsed.json) {
+        return textResult(JSON.stringify({
+            route: routeData,
+            delegate: delegateResult,
+        }, null, 2));
+    }
+    const delegateText = delegateResult.success
+        ? delegateResult.output ?? ''
+        : `FAILED:\n  ${delegateResult.error ?? 'unknown error'}`;
+    return textResult(`${formatRoutePeerCommandData(routeData)}\n\nDelegated response:\n${delegateText}`);
+}
+/**
+ * Phase (d).23 / V1.3 — `/fleet tool <peer> <name> [json-args]`
+ * [--timeout <ms>] [--stream]
+ *
+ * UX wrapper around peer.tool.invoke. Same JSON-blob parser as
+ * `/fleet send` (joins tokens until --timeout/--stream so users can
+ * paste un-quoted JSON). With --stream, uses
+ * peer.tool.invoke.stream and prints peer:chunk deltas via
+ * `process.stdout.write` (the user sees output flow while the call
+ * is in flight, then a final OK summary line).
+ */
+async function handleTool(rest) {
+    if (getFleetRegistry().size() === 0) {
+        return textResult('No fleet listeners active. Connect with /fleet listen first.');
+    }
+    let peerName = null;
+    let toolName = null;
+    let jsonArgs = null;
+    let timeoutMs = 30_000;
+    let stream = false;
+    for (let i = 0; i < rest.length; i++) {
+        const arg = rest[i];
+        if (arg === undefined)
+            continue;
+        if (arg === '--timeout' && i + 1 < rest.length) {
+            const n = parseInt(rest[i + 1] ?? '', 10);
+            if (Number.isFinite(n) && n > 0)
+                timeoutMs = n;
+            i++;
+        }
+        else if (arg === '--stream') {
+            stream = true;
+        }
+        else if (!peerName) {
+            peerName = arg;
+        }
+        else if (!toolName) {
+            toolName = arg;
+        }
+        else if (!jsonArgs) {
+            // Consume tokens until we hit a flag, mirroring /fleet send.
+            const remaining = rest.slice(i);
+            const flagIdx = remaining.findIndex((r) => r === '--timeout' || r === '--stream');
+            const blobEnd = flagIdx === -1 ? remaining.length : flagIdx;
+            jsonArgs = remaining.slice(0, blobEnd).join(' ');
+            i += blobEnd - 1;
+        }
+    }
+    if (!peerName || !toolName) {
+        return textResult('Usage: /fleet tool <peer> <name> [json-args] [--timeout <ms>] [--stream]\n\n' + HELP);
+    }
+    const target = getFleetRegistry().get(peerName);
+    if (!target) {
+        return textResult(`No fleet peer named "${peerName}". Active peers: ${getFleetRegistry().ids().join(', ')}`);
+    }
+    let parsedArgs = {};
+    if (jsonArgs && jsonArgs.trim().length > 0) {
+        try {
+            const parsed = JSON.parse(jsonArgs);
+            if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+                return textResult('Error: tool args must be a JSON object (e.g. {"file_path":"README.md"}).');
+            }
+            parsedArgs = parsed;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return textResult(`Error: invalid JSON args: ${msg}`);
+        }
+    }
+    // The optional shape on FleetListenerPublicAPI lets test mocks omit
+    // these — guard so we fail clean instead of TypeError'ing in JS.
+    const invokeTool = target.listener.invokeTool?.bind(target.listener);
+    const invokeToolStream = target.listener.invokeToolStream?.bind(target.listener);
+    if (!invokeTool || !invokeToolStream) {
+        return textResult(`Peer "${peerName}" listener does not expose invokeTool/invokeToolStream — likely an older Code Buddy build (pre-Phase d.23).`);
+    }
+    try {
+        const t0 = Date.now();
+        let payload;
+        if (stream) {
+            let streamedAny = false;
+            payload = await invokeToolStream(toolName, parsedArgs, (delta) => {
+                streamedAny = true;
+                // Best-effort live print. In a TUI session this gives the
+                // operator immediate feedback without waiting for the final
+                // peer:response. Errors writing to stdout are non-fatal.
+                try {
+                    process.stdout.write(sanitizeFleetStreamChunk(delta));
+                }
+                catch { /* ignore */ }
+            }, { timeoutMs });
+            if (streamedAny) {
+                try {
+                    process.stdout.write('\n');
+                }
+                catch { /* ignore */ }
+            }
+        }
+        else {
+            payload = await invokeTool(toolName, parsedArgs, { timeoutMs });
+        }
+        const elapsed = Date.now() - t0;
+        const tag = stream ? `${toolName} (stream)` : toolName;
+        const trunc = payload.truncated ? ' [truncated]' : '';
+        if (stream) {
+            // The body has already been streamed live — keep the summary terse.
+            return textResult(`Peer "${peerName}" → ${tag} OK (${elapsed}ms)${trunc}: ${payload.output.length} bytes`);
+        }
+        return textResult(`Peer "${peerName}" → ${tag} OK (${elapsed}ms)${trunc}:\n${payload.output}`);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return textResult(`Peer "${peerName}" → ${toolName} FAILED:\n  ${message}`);
+    }
+}
+/**
+ * Phase (d).18 — `/fleet autonomous` sub-command.
+ * Sub-actions: status | tick-now (manual fire). Configuration lives in
+ * TOML `[autonomous_fleet]` and is honoured at boot — this slash is
+ * for inspection and ad-hoc one-shot ticks.
+ */
+async function handleAutonomous(rest) {
+    const sub = (rest[0] || 'status').trim().toLowerCase();
+    const { getConfigManager } = await import('../../config/toml-config.js');
+    const af = getConfigManager().getConfig().autonomous_fleet;
+    if (sub === 'status' || sub === '') {
+        if (!af?.enabled) {
+            return textResult('Autonomous fleet: disabled.\n\n' +
+                'Enable in .codebuddy/config.toml:\n' +
+                '  [autonomous_fleet]\n' +
+                '  enabled = true\n' +
+                '  repo_path = "/path/to/claude-et-patrice"\n' +
+                '  host = "ministar/grok-cli"\n' +
+                '  interval_minutes = 30\n' +
+                '  priority_threshold = "high"   # critical is always skipped\n' +
+                '  llm_provider = "cloud"        # or "auto" / "ollama" / "grok" / etc.\n');
+        }
+        // Resolve preview of the provider that the next tick would use for a
+        // task with no `preferLocal` hint, so the user sees the host-default.
+        const { resolveTickProvider } = await import('../../agent/autonomous/fleet-tick-handler.js');
+        const previewProvider = resolveTickProvider({ preferLocal: false }, af.llm_provider);
+        return textResult([
+            'Autonomous fleet: ENABLED',
+            `  Repo path:           ${af.repo_path ?? '(unset!)'}`,
+            `  Host:                ${af.host ?? '(unset!)'}`,
+            `  Interval:            ${af.interval_minutes ?? 30} min`,
+            `  Max task ms:         ${af.max_task_ms ?? 600_000}`,
+            `  Priority threshold:  ${af.priority_threshold ?? 'high'}  (critical always skipped)`,
+            `  LLM provider config: ${af.llm_provider ?? 'cloud'}`,
+            `  Resolved (preview):  ${previewProvider.provider} model=${previewProvider.model}` +
+                ` ${previewProvider.isLocal ? '[LOCAL]' : '[cloud]'} (reason=${previewProvider.reason})`,
+            '',
+            'Tasks tagged `preferLocal: true` may use Ollama instead — see fleet-task-types.ts.',
+            'Use /fleet autonomous tick-now to fire a tick immediately.',
+        ].join('\n'));
+    }
+    if (sub === 'tick-now') {
+        if (!af?.enabled || !af.repo_path || !af.host) {
+            return textResult('Autonomous fleet not configured. Run /fleet autonomous status to see required keys.');
+        }
+        const { runFleetTick } = await import('../../agent/autonomous/fleet-tick-handler.js');
+        try {
+            const outcome = await runFleetTick({
+                repoPath: af.repo_path,
+                host: af.host,
+                maxTaskMs: af.max_task_ms,
+                priorityThreshold: af.priority_threshold ?? 'high',
+                llmProvider: af.llm_provider,
+            });
+            return textResult(`Autonomous fleet tick result:\n${JSON.stringify(outcome, null, 2)}`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return textResult(`Autonomous fleet tick FAILED:\n  ${msg}`);
+        }
+    }
+    return textResult(`Unknown /fleet autonomous sub-action: ${sub}\n\nAvailable: status, tick-now`);
+}
+/** Test reset hook. Stops all listeners and clears the registry. */
+export function _resetFleetHandlerForTests() {
+    const reg = getFleetRegistry();
+    for (const peer of reg.list()) {
+        peer.listener.disconnect().catch(() => { });
+    }
+    reg.clear();
+}
+//# sourceMappingURL=fleet-handler.js.map