@codedeck/codedeck 2026.3.1-4.63

package/dist/daemon/command-handler.js

@@ -0,0 +1,770 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setRouterContext = setRouterContext;
+exports.handleWebCommand = handleWebCommand;
+/**
+ * Handle commands from the web UI and inbound chat messages via ServerLink.
+ * Commands arrive as JSON objects with a `type` field.
+ */
+const session_manager_js_1 = require("../agent/session-manager.js");
+const tmux_js_1 = require("../agent/tmux.js");
+const session_store_js_1 = require("../store/session-store.js");
+const message_router_js_1 = require("../router/message-router.js");
+const terminal_streamer_js_1 = require("./terminal-streamer.js");
+const timeline_emitter_js_1 = require("./timeline-emitter.js");
+const timeline_store_js_1 = require("./timeline-store.js");
+const subsession_manager_js_1 = require("./subsession-manager.js");
+const logger_js_1 = __importDefault(require("../util/logger.js"));
+const os_1 = require("os");
+// ── Binary frame packing ─────────────────────────────────────────────────────
+/**
+ * Pack a raw PTY buffer into the v1 binary frame format:
+ *   byte 0: version (0x01)
+ *   bytes 1-2: sessionName length (uint16 BE)
+ *   bytes 3..3+N-1: sessionName (UTF-8)
+ *   bytes 3+N..: raw PTY payload
+ */
+function packRawFrame(sessionName, data) {
+    const nameBytes = Buffer.from(sessionName, 'utf8');
+    const header = Buffer.allocUnsafe(3 + nameBytes.length);
+    header[0] = 0x01;
+    header.writeUInt16BE(nameBytes.length, 1);
+    nameBytes.copy(header, 3);
+    return Buffer.concat([header, data]);
+}
+// ── AsyncMutex (per-session serialized stdin writes) ─────────────────────────
+class AsyncMutex {
+    queue = [];
+    locked = false;
+    async acquire() {
+        return new Promise((resolve) => {
+            const tryLock = () => {
+                if (!this.locked) {
+                    this.locked = true;
+                    resolve(() => this.release());
+                }
+                else {
+                    this.queue.push(tryLock);
+                }
+            };
+            tryLock();
+        });
+    }
+    release() {
+        this.locked = false;
+        const next = this.queue.shift();
+        if (next)
+            next();
+    }
+}
+const sessionMutexes = new Map();
+function getMutex(sessionName) {
+    let mutex = sessionMutexes.get(sessionName);
+    if (!mutex) {
+        mutex = new AsyncMutex();
+        sessionMutexes.set(sessionName, mutex);
+    }
+    return mutex;
+}
+// ── CommandId dedup cache (100 entries / 5 min TTL per session) ──────────────
+class CommandDedup {
+    entries = new Map(); // commandId → timestamp
+    MAX_SIZE = 100;
+    TTL_MS = 5 * 60 * 1000;
+    has(commandId) {
+        const ts = this.entries.get(commandId);
+        if (ts === undefined)
+            return false;
+        if (Date.now() - ts > this.TTL_MS) {
+            this.entries.delete(commandId);
+            return false;
+        }
+        return true;
+    }
+    add(commandId) {
+        if (this.entries.size >= this.MAX_SIZE) {
+            // Evict expired entries first
+            const now = Date.now();
+            for (const [id, ts] of this.entries) {
+                if (now - ts > this.TTL_MS)
+                    this.entries.delete(id);
+            }
+            // If still at max, evict the oldest
+            if (this.entries.size >= this.MAX_SIZE) {
+                const oldest = this.entries.keys().next().value;
+                if (oldest !== undefined)
+                    this.entries.delete(oldest);
+            }
+        }
+        this.entries.set(commandId, Date.now());
+    }
+}
+const sessionDedups = new Map();
+function getDedup(sessionName) {
+    let dedup = sessionDedups.get(sessionName);
+    if (!dedup) {
+        dedup = new CommandDedup();
+        sessionDedups.set(sessionName, dedup);
+    }
+    return dedup;
+}
+function expandTilde(p) {
+    return p.startsWith('~/') ? (0, os_1.homedir)() + p.slice(1) : p === '~' ? (0, os_1.homedir)() : p;
+}
+// Track active terminal subscriptions for proper cleanup
+const activeSubscriptions = new Map();
+let routerCtx = null;
+/** Set the router context for handling inbound chat messages. Must be called before messages arrive. */
+function setRouterContext(ctx) {
+    routerCtx = ctx;
+}
+function handleWebCommand(msg, serverLink) {
+    if (!msg || typeof msg !== 'object')
+        return;
+    const cmd = msg;
+    switch (cmd.type) {
+        case 'inbound':
+            void handleInbound(cmd);
+            break;
+        case 'session.start':
+            void handleStart(cmd, serverLink);
+            break;
+        case 'session.stop':
+            void handleStop(cmd);
+            break;
+        case 'session.restart':
+            void handleRestart(cmd, serverLink);
+            break;
+        case 'session.send':
+            void handleSend(cmd, serverLink);
+            break;
+        case 'session.input':
+            void handleInput(cmd);
+            break;
+        case 'session.resize':
+            void handleResize(cmd);
+            break;
+        case 'get_sessions':
+            handleGetSessions(serverLink);
+            break;
+        case 'terminal.subscribe':
+            handleSubscribe(cmd, serverLink);
+            break;
+        case 'terminal.unsubscribe':
+            handleUnsubscribe(cmd);
+            break;
+        case 'terminal.snapshot_request':
+            handleSnapshotRequest(cmd);
+            break;
+        case 'timeline.replay_request':
+            handleTimelineReplay(cmd, serverLink);
+            break;
+        case 'timeline.history_request':
+            handleTimelineHistory(cmd, serverLink);
+            break;
+        case 'subsession.start':
+            void handleSubSessionStart(cmd, serverLink);
+            break;
+        case 'subsession.stop':
+            void handleSubSessionStop(cmd);
+            break;
+        case 'subsession.rebuild_all':
+            void handleSubSessionRebuildAll(cmd);
+            break;
+        case 'subsession.detect_shells':
+            void handleSubSessionDetectShells(serverLink);
+            break;
+        case 'subsession.read_response':
+            void handleSubSessionReadResponse(cmd, serverLink);
+            break;
+        case 'subsession.set_model':
+            void handleSubSessionSetModel(cmd);
+            break;
+        case 'discussion.start':
+            void handleDiscussionStart(cmd, serverLink);
+            break;
+        case 'discussion.status':
+            handleDiscussionStatus(cmd, serverLink);
+            break;
+        case 'discussion.stop':
+            void handleDiscussionStop(cmd);
+            break;
+        case 'discussion.list':
+            handleDiscussionList(serverLink);
+            break;
+        case 'auth_ok':
+        case 'heartbeat':
+        case 'heartbeat_ack':
+        case 'ping':
+        case 'pong':
+            // Expected internal messages, ignore silently
+            break;
+        default:
+            if (typeof cmd.type === 'string') {
+                logger_js_1.default.warn({ type: cmd.type }, 'Unknown web command type');
+            }
+    }
+}
+async function handleInbound(cmd) {
+    const msg = cmd.msg;
+    if (!msg) {
+        logger_js_1.default.warn('inbound: missing msg payload');
+        return;
+    }
+    if (!routerCtx) {
+        logger_js_1.default.warn('inbound: router context not set, dropping message');
+        return;
+    }
+    try {
+        await (0, message_router_js_1.routeMessage)(msg, routerCtx);
+    }
+    catch (err) {
+        logger_js_1.default.error({ err, platform: msg.platform, channelId: msg.channelId }, 'inbound: routeMessage failed');
+    }
+}
+async function handleStart(cmd, serverLink) {
+    const project = cmd.project;
+    const agentType = cmd.agentType || 'claude-code';
+    const dir = expandTilde(cmd.dir || '~');
+    if (!project) {
+        logger_js_1.default.warn('session.start: missing project name');
+        return;
+    }
+    try {
+        const config = {
+            name: project,
+            dir,
+            brainType: agentType,
+            workerTypes: [],
+        };
+        await (0, session_manager_js_1.startProject)(config);
+        logger_js_1.default.info({ project }, 'Session started via web');
+    }
+    catch (err) {
+        logger_js_1.default.error({ project, err }, 'session.start failed');
+        const message = err instanceof Error ? err.message : String(err);
+        try {
+            serverLink.send({ type: 'session.error', project, message });
+        }
+        catch { /* ignore */ }
+    }
+}
+async function handleRestart(cmd, serverLink) {
+    const project = cmd.project;
+    const fresh = cmd.fresh === true;
+    if (!project) {
+        logger_js_1.default.warn('session.restart: missing project name');
+        return;
+    }
+    const sessions = (0, session_store_js_1.listSessions)(project);
+    if (!sessions.length) {
+        logger_js_1.default.warn({ project }, 'session.restart: no sessions found for project');
+        return;
+    }
+    const brain = sessions.find((s) => s.role === 'brain');
+    if (!brain) {
+        logger_js_1.default.warn({ project }, 'session.restart: no brain session found');
+        return;
+    }
+    try {
+        await (0, session_manager_js_1.stopProject)(project);
+        const config = {
+            name: project,
+            dir: brain.projectDir,
+            brainType: brain.agentType,
+            workerTypes: sessions
+                .filter((s) => s.role !== 'brain')
+                .map((s) => s.agentType),
+            fresh,
+        };
+        await (0, session_manager_js_1.startProject)(config);
+        logger_js_1.default.info({ project, fresh }, 'Session restarted via web');
+    }
+    catch (err) {
+        logger_js_1.default.error({ project, err }, 'session.restart failed');
+        const message = err instanceof Error ? err.message : String(err);
+        try {
+            serverLink.send({ type: 'session.error', project, message });
+        }
+        catch { /* ignore */ }
+    }
+}
+async function handleStop(cmd) {
+    const project = cmd.project;
+    if (!project) {
+        logger_js_1.default.warn('session.stop: missing project name');
+        return;
+    }
+    try {
+        await (0, session_manager_js_1.stopProject)(project);
+        logger_js_1.default.info({ project }, 'Session stopped via web');
+    }
+    catch (err) {
+        logger_js_1.default.error({ project, err }, 'session.stop failed');
+    }
+}
+/**
+ * Send a command to a session, handling `!`-prefixed shell commands:
+ * - claude-code: send `!` first (with delayed-Enter), then send the rest of the command
+ * - codex: strip `!` and send the shell command directly (Codex has no `!` prefix)
+ * - others: send as-is
+ */
+async function sendShellAwareCommand(sessionName, text, agentType) {
+    if (text.startsWith('!')) {
+        const shellCmd = text.slice(1).trimStart();
+        if (agentType === 'codex') {
+            // Codex: just send the shell command without `!`
+            await (0, tmux_js_1.sendKeysDelayedEnter)(sessionName, shellCmd);
+        }
+        else {
+            // claude-code (and others): send `!` first to enter shell mode, then the command
+            await (0, tmux_js_1.sendKeysDelayedEnter)(sessionName, '!');
+            await new Promise((r) => setTimeout(r, 300));
+            await (0, tmux_js_1.sendKeysDelayedEnter)(sessionName, shellCmd);
+        }
+    }
+    else {
+        await (0, tmux_js_1.sendKeysDelayedEnter)(sessionName, text);
+    }
+}
+async function handleSend(cmd, serverLink) {
+    const sessionName = (cmd.sessionName ?? cmd.session);
+    const text = cmd.text;
+    const commandId = cmd.commandId;
+    if (!sessionName || !text) {
+        logger_js_1.default.warn('session.send: missing sessionName or text');
+        return;
+    }
+    // Fallback: legacy clients that don't send commandId get a server-generated one
+    const isLegacy = !commandId;
+    const effectiveId = commandId ?? crypto.randomUUID();
+    if (isLegacy) {
+        logger_js_1.default.warn({ sessionName, effectiveId }, 'session.send: missing commandId — using server-generated fallback');
+    }
+    // Dedup: silently ignore duplicate commandIds
+    const dedup = getDedup(sessionName);
+    if (dedup.has(effectiveId)) {
+        logger_js_1.default.debug({ sessionName, effectiveId }, 'session.send: duplicate commandId, ignored');
+        return;
+    }
+    dedup.add(effectiveId);
+    // Serialized write via per-session mutex
+    const release = await getMutex(sessionName).acquire();
+    // Always use delayed-Enter: Codex TUI has paste-burst detection that treats
+    // rapid character sequences (including trailing \r) as pastes. The small delay
+    // has no visible downside for other agents, so apply it universally.
+    try {
+        const agentType = (0, session_store_js_1.getSession)(sessionName)?.agentType ?? 'unknown';
+        await sendShellAwareCommand(sessionName, text, agentType);
+        timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'user.message', { text });
+        // Emit accepted ack (accepted_legacy for fallback IDs so callers can distinguish)
+        const status = isLegacy ? 'accepted_legacy' : 'accepted';
+        timeline_emitter_js_1.timelineEmitter.emit(sessionName, 'command.ack', { commandId: effectiveId, status });
+        try {
+            serverLink.send({ type: 'command.ack', commandId: effectiveId, status, session: sessionName });
+        }
+        catch { /* not connected */ }
+    }
+    catch (err) {
+        logger_js_1.default.error({ sessionName, err }, 'session.send failed');
+    }
+    finally {
+        release();
+    }
+}
+async function handleInput(cmd) {
+    const sessionName = cmd.sessionName;
+    const data = cmd.data;
+    // session.input SHALL NOT require or process commandId
+    if (!sessionName || data === undefined)
+        return;
+    // Serialized via same per-session mutex (no commandId, no retry)
+    const release = await getMutex(sessionName).acquire();
+    try {
+        await (0, tmux_js_1.sendRawInput)(sessionName, data);
+    }
+    catch (err) {
+        logger_js_1.default.error({ sessionName, err }, 'session.input failed');
+    }
+    finally {
+        release();
+    }
+}
+async function handleResize(cmd) {
+    const sessionName = cmd.sessionName;
+    const cols = cmd.cols;
+    const rows = cmd.rows;
+    if (!sessionName || !cols || !rows)
+        return;
+    try {
+        // Subtract 1 col so tmux is always slightly narrower than the browser terminal.
+        // xterm fitAddon rounds down but container width may have sub-character remainder,
+        // causing tmux output to wrap at a wider width and misalign with xterm's display.
+        await (0, tmux_js_1.resizeSession)(sessionName, Math.max(cols - 1, 40), Math.max(rows, 10));
+        terminal_streamer_js_1.terminalStreamer.invalidateSize(sessionName);
+    }
+    catch (err) {
+        logger_js_1.default.error({ sessionName, cols, rows, err }, 'session.resize failed');
+    }
+}
+function handleGetSessions(serverLink) {
+    const sessions = (0, session_store_js_1.listSessions)()
+        .filter((s) => !s.name.startsWith('deck_sub_'))
+        .map((s) => ({
+        name: s.name,
+        project: s.projectName,
+        role: s.role,
+        agentType: s.agentType,
+        state: s.state,
+    }));
+    try {
+        serverLink.send({ type: 'session_list', sessions });
+    }
+    catch {
+        // not connected
+    }
+}
+function handleSubscribe(cmd, serverLink) {
+    const session = cmd.session;
+    if (!session)
+        return;
+    const subscriber = {
+        sessionName: session,
+        send: (diff) => {
+            try {
+                serverLink.send({ type: 'terminal_update', diff });
+            }
+            catch { /* ignore */ }
+        },
+        sendRaw: (data) => {
+            serverLink.sendBinary(packRawFrame(session, data));
+        },
+        sendControl: (msg) => {
+            try {
+                serverLink.send(msg);
+            }
+            catch { /* ignore */ }
+        },
+        onError: () => {
+            activeSubscriptions.delete(session);
+        },
+    };
+    // Subscribe new subscriber BEFORE removing old one so the pipe never drops to 0
+    // subscribers and unnecessarily stops+restarts (which causes idle→running oscillation
+    // and empty-line snapshot spam).
+    const unsubscribe = terminal_streamer_js_1.terminalStreamer.subscribe(subscriber);
+    const existing = activeSubscriptions.get(session);
+    activeSubscriptions.set(session, { subscriber, unsubscribe });
+    if (existing) {
+        existing.unsubscribe();
+    }
+    logger_js_1.default.debug({ session }, 'Terminal subscribed via web');
+}
+function handleUnsubscribe(cmd) {
+    const session = cmd.session;
+    if (!session)
+        return;
+    const entry = activeSubscriptions.get(session);
+    if (entry) {
+        entry.unsubscribe();
+        activeSubscriptions.delete(session);
+        logger_js_1.default.debug({ session }, 'Terminal unsubscribed via web');
+    }
+}
+function handleSnapshotRequest(cmd) {
+    const sessionName = cmd.sessionName;
+    if (!sessionName)
+        return;
+    terminal_streamer_js_1.terminalStreamer.requestSnapshot(sessionName);
+    logger_js_1.default.debug({ sessionName }, 'Snapshot requested via web');
+}
+function handleTimelineReplay(cmd, serverLink) {
+    const sessionName = cmd.sessionName;
+    const afterSeq = cmd.afterSeq;
+    const requestEpoch = cmd.epoch;
+    const requestId = cmd.requestId;
+    if (!sessionName || afterSeq === undefined || requestEpoch === undefined) {
+        logger_js_1.default.warn('timeline.replay_request: missing fields');
+        return;
+    }
+    if (requestEpoch !== timeline_emitter_js_1.timelineEmitter.epoch) {
+        // Epoch mismatch — serve current epoch events from file store, fallback to all epochs
+        let events = timeline_store_js_1.timelineStore.read(sessionName, { epoch: timeline_emitter_js_1.timelineEmitter.epoch });
+        if (events.length === 0) {
+            events = timeline_store_js_1.timelineStore.read(sessionName, {});
+        }
+        try {
+            serverLink.send({
+                type: 'timeline.replay',
+                sessionName,
+                requestId,
+                events,
+                truncated: false,
+                epoch: timeline_emitter_js_1.timelineEmitter.epoch,
+            });
+        }
+        catch { /* not connected */ }
+        return;
+    }
+    const { events, truncated } = timeline_emitter_js_1.timelineEmitter.replay(sessionName, afterSeq);
+    try {
+        serverLink.send({
+            type: 'timeline.replay',
+            sessionName,
+            requestId,
+            events,
+            truncated,
+            epoch: timeline_emitter_js_1.timelineEmitter.epoch,
+        });
+    }
+    catch { /* not connected */ }
+}
+/** Handle timeline.history_request — browser requesting full session history on open. */
+function handleTimelineHistory(cmd, serverLink) {
+    const sessionName = cmd.sessionName;
+    const requestId = cmd.requestId;
+    const limit = cmd.limit ?? 200;
+    if (!sessionName) {
+        logger_js_1.default.warn('timeline.history_request: missing sessionName');
+        return;
+    }
+    // Read more than requested so dedup doesn't shrink the set too aggressively
+    const readLimit = Math.min(limit * 4, 2000);
+    let events = timeline_store_js_1.timelineStore.read(sessionName, { epoch: timeline_emitter_js_1.timelineEmitter.epoch, limit: readLimit });
+    if (events.length === 0) {
+        events = timeline_store_js_1.timelineStore.read(sessionName, { limit: readLimit });
+    }
+    // Deduplicate consecutive session.state events — keep only the last in each run.
+    // This prevents idle↔running oscillation storms from crowding out user.message events.
+    const deduped = [];
+    for (let i = 0; i < events.length; i++) {
+        const ev = events[i];
+        if (ev.type === 'session.state') {
+            const next = events[i + 1];
+            if (next && next.type === 'session.state')
+                continue; // skip, keep last
+        }
+        deduped.push(ev);
+    }
+    // Trim to requested limit after dedup
+    const trimmed = deduped.length > limit ? deduped.slice(deduped.length - limit) : deduped;
+    try {
+        serverLink.send({
+            type: 'timeline.history',
+            sessionName,
+            requestId,
+            events: trimmed,
+            epoch: timeline_emitter_js_1.timelineEmitter.epoch,
+        });
+    }
+    catch { /* not connected */ }
+}
+// ── Sub-session handlers ──────────────────────────────────────────────────
+async function handleSubSessionStart(cmd, serverLink) {
+    const id = cmd.id;
+    const type = cmd.sessionType;
+    if (!id || !type) {
+        logger_js_1.default.warn('subsession.start: missing id or type');
+        return;
+    }
+    // Resolve a unique Gemini session ID so each sub-session gets its own conversation
+    let geminiSessionId = null;
+    let fileSnapshot;
+    if (type === 'gemini') {
+        // Snapshot existing files BEFORE resolving — used as fallback if resolve fails
+        const { snapshotSessionFiles } = await import('./gemini-watcher.js');
+        fileSnapshot = await snapshotSessionFiles();
+        try {
+            const { GeminiDriver } = await import('../agent/drivers/gemini.js');
+            geminiSessionId = await new GeminiDriver().resolveSessionId(cmd.cwd ?? undefined);
+            logger_js_1.default.info({ id, geminiSessionId }, 'Resolved Gemini session ID for sub-session');
+            // Persist to DB so rebuild can use the exact UUID
+            serverLink.send({ type: 'subsession.update_gemini_id', id, geminiSessionId });
+            fileSnapshot = undefined; // no longer needed
+        }
+        catch (e) {
+            logger_js_1.default.warn({ err: e, id }, 'Failed to resolve Gemini session ID — using snapshot-diff fallback');
+        }
+    }
+    await (0, subsession_manager_js_1.startSubSession)({
+        id,
+        type,
+        shellBin: cmd.shellBin,
+        cwd: cmd.cwd,
+        ccSessionId: cmd.ccSessionId,
+        geminiSessionId,
+        fresh: type === 'gemini' && !geminiSessionId,
+        _fileSnapshot: fileSnapshot,
+        _onGeminiDiscovered: fileSnapshot ? (sessionId) => {
+            logger_js_1.default.info({ id, sessionId }, 'Discovered Gemini session ID via snapshot-diff');
+            try {
+                serverLink.send({ type: 'subsession.update_gemini_id', id, geminiSessionId: sessionId });
+            }
+            catch { /* ignore */ }
+        } : undefined,
+    }).catch((e) => logger_js_1.default.error({ err: e, id }, 'subsession.start failed'));
+}
+async function handleSubSessionStop(cmd) {
+    const sName = cmd.sessionName;
+    if (!sName) {
+        logger_js_1.default.warn('subsession.stop: missing sessionName');
+        return;
+    }
+    await (0, subsession_manager_js_1.stopSubSession)(sName).catch((e) => logger_js_1.default.error({ err: e, sName }, 'subsession.stop failed'));
+}
+async function handleSubSessionRebuildAll(cmd) {
+    const subSessions = cmd.subSessions;
+    if (!Array.isArray(subSessions))
+        return;
+    await (0, subsession_manager_js_1.rebuildSubSessions)(subSessions).catch((e) => logger_js_1.default.error({ err: e }, 'subsession.rebuild_all failed'));
+}
+async function handleSubSessionDetectShells(serverLink) {
+    const shells = await (0, subsession_manager_js_1.detectShells)().catch(() => []);
+    try {
+        serverLink.send({ type: 'subsession.shells', shells });
+    }
+    catch { /* not connected */ }
+}
+async function handleSubSessionSetModel(cmd) {
+    const sessionName = cmd.sessionName;
+    const model = cmd.model;
+    const cwd = cmd.cwd;
+    if (!sessionName || !model) {
+        logger_js_1.default.warn('subsession.set_model: missing sessionName or model');
+        return;
+    }
+    // Extract sub-session id from name (deck_sub_{id})
+    const prefix = 'deck_sub_';
+    const id = sessionName.startsWith(prefix) ? sessionName.slice(prefix.length) : null;
+    if (!id) {
+        logger_js_1.default.warn({ sessionName }, 'subsession.set_model: invalid session name');
+        return;
+    }
+    logger_js_1.default.info({ sessionName, model }, 'Restarting Codex sub-session with new model');
+    await (0, subsession_manager_js_1.stopSubSession)(sessionName).catch(() => { });
+    await (0, subsession_manager_js_1.startSubSession)({ id, type: 'codex', cwd: cwd ?? null, codexModel: model })
+        .catch((e) => logger_js_1.default.error({ err: e, sessionName, model }, 'subsession.set_model restart failed'));
+}
+async function handleSubSessionReadResponse(cmd, serverLink) {
+    const sName = cmd.sessionName;
+    if (!sName)
+        return;
+    const result = await (0, subsession_manager_js_1.readSubSessionResponse)(sName).catch(() => ({ status: 'working' }));
+    try {
+        serverLink.send({ type: 'subsession.response', sessionName: sName, ...result });
+    }
+    catch { /* not connected */ }
+}
+// ── Discussion handlers ────────────────────────────────────────────────────
+async function handleDiscussionStart(cmd, serverLink) {
+    const topic = cmd.topic;
+    const cwd = cmd.cwd;
+    const requestId = cmd.requestId;
+    const rawParticipants = cmd.participants;
+    if (!topic || !rawParticipants || rawParticipants.length < 2) {
+        logger_js_1.default.warn('discussion.start: missing required fields');
+        try {
+            serverLink.send({ type: 'discussion.error', requestId, error: 'missing_fields' });
+        }
+        catch { /* ignore */ }
+        return;
+    }
+    const { startDiscussion } = await import('./discussion-orchestrator.js');
+    const id = Array.from(crypto.getRandomValues(new Uint8Array(8)))
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+    const participants = rawParticipants.map((p) => ({
+        agentType: p.agentType ?? 'claude-code',
+        model: p.model,
+        roleId: p.roleId ?? 'custom',
+        roleLabel: p.roleLabel,
+        rolePrompt: p.rolePrompt,
+        sessionName: p.sessionName,
+    }));
+    try {
+        const d = await startDiscussion({
+            id,
+            serverId: '',
+            topic,
+            cwd: cwd ?? '',
+            participants,
+            maxRounds: cmd.maxRounds ?? 3,
+            verdictIdx: cmd.verdictIdx,
+        }, (msg) => {
+            try {
+                serverLink.send(msg);
+            }
+            catch { /* not connected */ }
+        });
+        try {
+            serverLink.send({
+                type: 'discussion.started',
+                requestId,
+                discussionId: d.id,
+                topic: d.topic,
+                maxRounds: d.maxRounds,
+                filePath: d.filePath,
+                participants: d.participants.map((p) => ({
+                    sessionName: p.sessionName,
+                    roleLabel: p.roleLabel,
+                    agentType: p.agentType,
+                    model: p.model,
+                })),
+            });
+        }
+        catch { /* not connected */ }
+    }
+    catch (err) {
+        logger_js_1.default.error({ err }, 'discussion.start failed');
+        const error = err instanceof Error ? err.message : String(err);
+        try {
+            serverLink.send({ type: 'discussion.error', requestId, error });
+        }
+        catch { /* ignore */ }
+    }
+}
+function handleDiscussionStatus(cmd, serverLink) {
+    const discussionId = cmd.discussionId;
+    if (!discussionId)
+        return;
+    import('./discussion-orchestrator.js').then(({ getDiscussion }) => {
+        const d = getDiscussion(discussionId);
+        if (!d) {
+            try {
+                serverLink.send({ type: 'discussion.error', discussionId, error: 'not_found' });
+            }
+            catch { /* ignore */ }
+            return;
+        }
+        try {
+            serverLink.send({
+                type: 'discussion.update',
+                discussionId: d.id,
+                state: d.state,
+                currentRound: d.currentRound,
+                maxRounds: d.maxRounds,
+                currentSpeaker: d.participants[d.currentSpeakerIdx]?.roleLabel,
+            });
+        }
+        catch { /* not connected */ }
+    }).catch(() => { });
+}
+function handleDiscussionList(serverLink) {
+    import('./discussion-orchestrator.js').then(({ listDiscussions }) => {
+        try {
+            serverLink.send({ type: 'discussion.list', discussions: listDiscussions() });
+        }
+        catch { /* not connected */ }
+    }).catch(() => { });
+}
+async function handleDiscussionStop(cmd) {
+    const discussionId = cmd.discussionId;
+    if (!discussionId)
+        return;
+    const { stopDiscussion } = await import('./discussion-orchestrator.js');
+    await stopDiscussion(discussionId).catch((e) => logger_js_1.default.error({ err: e, discussionId }, 'discussion.stop failed'));
+}
+//# sourceMappingURL=command-handler.js.map