@antelopejs/dms-ai 0.1.5 → 0.2.0

package/sidecar/dist/server/routing.js

@@ -1,510 +1,238 @@
-import { randomUUID } from "node:crypto";
-import { EDIT_TOOL_NAMES, extractEditedFilePath, } from "../agent/edit-tracker.js";
-import { effectiveChatMode } from "../agent/effective-mode.js";
-import { buildToolSummary } from "../agent/tool-summary.js";
-import { getBuilderAvailable } from "../builder/capability.js";
-import { PERMISSION_DECISIONS, } from "../constants/permissions.js";
-import { MAX_AUTO_HEAL_ATTEMPTS } from "../constants/safety-net.js";
 import { WS_LOG_PREFIX } from "../constants/ws.js";
-import { EVENT_TYPES, STATUS, } from "../protocol/events.js";
+import { EVENT_TYPES } from "../protocol/events.js";
 import { AnyClientMessage, MESSAGE_TYPES, ROLE, } from "../protocol/messages.js";
-import { getProviderAvailability } from "../providers/registry.js";
-import { collectBuildIssues } from "./safety-net.js";
-import { startTurnProgress } from "./turn-progress.js";
-function buildSnapshotEvent(conversationId, messages) {
-    return {
-        type: EVENT_TYPES.CONVERSATION_SNAPSHOT,
-        conversationId,
-        messages: messages
-            .filter((m) => m.role !== "permission")
-            .map((m) => ({ ...m })),
-    };
-}
-function sendSnapshotIfKnown(socket, ctx, msg) {
-    if (msg.role !== ROLE.CHAT)
-        return;
-    sendSettings(socket, ctx);
-    if (msg.conversationId === undefined)
-        return;
-    sendConversationSnapshot(socket, ctx, msg.conversationId);
-    replayLiveTurn(socket, ctx, msg.conversationId);
-    sendQueueState(socket, ctx, msg.conversationId);
-    resendPendingPermissions(socket, ctx, msg.conversationId);
-    resendPendingQuestions(socket, ctx, msg.conversationId);
-}
-function sendQueueState(socket, ctx, conversationId) {
-    const event = {
-        type: EVENT_TYPES.QUEUE_STATE,
-        conversationId,
-        items: ctx.pendingQueue.get(conversationId),
-    };
+import { mergeSettings } from "../state/settings-store.js";
+import { broadcastConversationList, buildAskQuestionEvent, buildConversationListEvent, buildPermissionRequestEvent, buildSettingsUpdateEvent, buildSnapshotEvent, sendRulesState, } from "./chat-events.js";
+import { handleChangeSetAction } from "./change-set-actions.js";
+import { interruptConversation } from "./permission-events.js";
+import { broadcastQueueState, buildQueueStateEvent, enqueueUserMessage, ensureDraining, lastUserMessage, logFailure, persistUserMessage, runExclusive, runUserTurn, } from "./conversation-runs.js";
+function on(type, handle) {
+    return (socket, msg, ctx) => msg.type === type ? handle(socket, msg, ctx) : undefined;
+}
+function send(socket, event) {
     socket.send(JSON.stringify(event));
 }
-function buildSettingsUpdateEvent(ctx) {
-    return {
-        type: EVENT_TYPES.SETTINGS_UPDATE,
-        settings: ctx.settingsStore.get(),
-        builderAvailable: getBuilderAvailable(),
-        providers: getProviderAvailability(),
-    };
-}
-function sendSettings(socket, ctx) {
-    socket.send(JSON.stringify(buildSettingsUpdateEvent(ctx)));
-}
-function buildRunResumedEvent(conversationId) {
-    return { type: EVENT_TYPES.RUN_RESUMED, conversationId };
-}
 function replayLiveTurn(socket, ctx, conversationId) {
     const events = ctx.liveTurns.replay(conversationId);
     if (events === null)
         return;
-    socket.send(JSON.stringify(buildRunResumedEvent(conversationId)));
-    for (const event of events) {
-        socket.send(JSON.stringify(event));
-    }
-}
-function sendConversationSnapshot(socket, ctx, conversationId) {
-    const conversation = ctx.conversationStore.get(conversationId);
-    if (conversation === null)
-        return;
-    const event = buildSnapshotEvent(conversationId, conversation.messages);
-    socket.send(JSON.stringify(event));
-}
-function resendPendingPermissions(socket, ctx, conversationId) {
-    const pending = ctx.permissionBus.getPendingForConversation(conversationId);
-    for (const request of pending) {
-        sendPermissionRequest(socket, request);
+    send(socket, { type: EVENT_TYPES.RUN_RESUMED, conversationId });
+    for (const event of events)
+        send(socket, event);
+}
+function sendConversationState(socket, ctx, conversationId) {
+    const snapshot = buildSnapshotEvent(ctx, conversationId);
+    if (snapshot !== null)
+        send(socket, snapshot);
+    replayLiveTurn(socket, ctx, conversationId);
+    send(socket, buildQueueStateEvent(ctx, conversationId));
+    send(socket, {
+        type: EVENT_TYPES.CONVERSATION_MODE,
+        ...ctx.conversationModes.describe(conversationId),
+    });
+    send(socket, {
+        type: EVENT_TYPES.RULES_STATE,
+        conversationId,
+        rules: ctx.permissionBus.listRules(conversationId),
+    });
+    for (const request of ctx.permissionBus.getPendingForConversation(conversationId)) {
+        send(socket, buildPermissionRequestEvent(request));
     }
-}
-function resendPendingQuestions(socket, ctx, conversationId) {
-    const pending = ctx.questionBus.getPendingForConversation(conversationId);
-    for (const question of pending) {
-        sendQuestionRequest(socket, question);
+    for (const question of ctx.questionBus.getPendingForConversation(conversationId)) {
+        send(socket, buildAskQuestionEvent(question));
     }
 }
-function registerHostSocketIfHost(socket, msg, ctx) {
-    if (msg.role !== ROLE.HOST)
-        return;
-    ctx.hostSocketRegistry.set(socket);
-}
-function registerChatSocketIfChat(socket, msg, ctx) {
+function sendSnapshotIfKnown(socket, ctx, msg) {
     if (msg.role !== ROLE.CHAT)
         return;
+    send(socket, buildSettingsUpdateEvent(ctx));
     if (msg.conversationId === undefined)
         return;
-    ctx.chatSocketRegistry.set(msg.conversationId, socket);
+    sendConversationState(socket, ctx, msg.conversationId);
 }
-function handleHello(socket, msg, ctx) {
-    if (msg.type !== MESSAGE_TYPES.HELLO)
+function registerSocket(socket, msg, ctx) {
+    if (msg.role === ROLE.HOST) {
+        ctx.hostSocketRegistry.set(socket);
+        return;
+    }
+    if (msg.conversationId === undefined) {
+        ctx.chatSocketRegistry.addChat(socket);
         return;
+    }
+    if (msg.follow === true) {
+        ctx.chatSocketRegistry.follow(msg.conversationId, socket);
+        return;
+    }
+    ctx.chatSocketRegistry.set(msg.conversationId, socket);
+}
+const handleHello = on(MESSAGE_TYPES.HELLO, (socket, msg, ctx) => {
     console.log(`${WS_LOG_PREFIX} hello role=${msg.role}`);
-    registerHostSocketIfHost(socket, msg, ctx);
-    registerChatSocketIfChat(socket, msg, ctx);
+    registerSocket(socket, msg, ctx);
     sendSnapshotIfKnown(socket, ctx, msg);
-}
-function handleEcho(socket, msg) {
-    if (msg.type !== MESSAGE_TYPES.ECHO)
-        return;
+});
+const handleEcho = on(MESSAGE_TYPES.ECHO, (socket, msg) => {
     const reply = {
         type: MESSAGE_TYPES.ECHO_REPLY,
         payload: msg.payload,
         serverTimeMs: Date.now(),
     };
     socket.send(JSON.stringify(reply));
-}
-const RUNNER_EVENT_MAPPERS = {
-    assistant_text: () => null,
-    assistant_text_delta: (ev, cid) => ({
-        type: EVENT_TYPES.ASSISTANT_MESSAGE_CHUNK,
-        conversationId: cid,
-        text: ev.text,
-    }),
-    tool_use: (ev, cid) => ({
-        type: EVENT_TYPES.TOOL_CALL_START,
-        conversationId: cid,
-        callId: ev.callId,
-        toolName: ev.toolName,
-        args: ev.args,
-    }),
-    tool_result: (ev, cid) => ({
-        type: EVENT_TYPES.TOOL_CALL_END,
-        conversationId: cid,
-        callId: ev.callId,
-        status: ev.isError ? STATUS.ERROR : STATUS.SUCCESS,
-        result: ev.result,
-    }),
-    done: (_ev, cid) => ({
-        type: EVENT_TYPES.RUN_DONE,
-        conversationId: cid,
-    }),
-    error: (ev, cid) => ({
-        type: EVENT_TYPES.RUN_ERROR,
-        conversationId: cid,
-        error: ev.message,
-        isRetryable: ev.isRetryable,
-    }),
-    activity: () => null,
-};
-function mapRunnerEvent(ev, conversationId) {
-    const mapper = RUNNER_EVENT_MAPPERS[ev.type];
-    return mapper(ev, conversationId);
-}
-const RUNNER_EVENT_PERSISTERS = {
-    assistant_text: (ev, nowMs) => ({
-        role: "assistant",
-        content: ev.text,
-        timestampMs: nowMs,
-    }),
-    assistant_text_delta: () => null,
-    tool_use: (ev, nowMs) => ({
-        role: "tool_use",
-        content: JSON.stringify(ev.args ?? null),
-        toolName: ev.toolName,
-        callId: ev.callId,
-        timestampMs: nowMs,
-    }),
-    tool_result: (ev, nowMs) => ({
-        role: "tool_result",
-        content: JSON.stringify(ev.result ?? null),
-        callId: ev.callId,
-        status: ev.isError ? STATUS.ERROR : STATUS.SUCCESS,
-        timestampMs: nowMs,
-    }),
-    done: () => null,
-    error: (ev, nowMs) => ({
-        role: "error",
-        content: ev.message,
-        isRetryable: ev.isRetryable,
-        timestampMs: nowMs,
-    }),
-    activity: () => null,
-};
-function persistRunnerEvent(ctx, conversationId, ev) {
-    const persister = RUNNER_EVENT_PERSISTERS[ev.type];
-    const stored = persister(ev, Date.now());
-    if (stored === null)
-        return;
-    ctx.conversationStore.appendMessage(conversationId, stored);
-}
-function isTerminalEvent(ev) {
-    return ev.type === "done" || ev.type === "error";
-}
-function dispatchTurnEvent(ctx, conversationId, ev) {
-    const wireEvent = mapRunnerEvent(ev, conversationId);
-    if (wireEvent === null)
-        return;
-    if (isTerminalEvent(ev)) {
-        ctx.liveTurns.end(conversationId);
-    }
-    else {
-        ctx.liveTurns.append(conversationId, wireEvent);
-    }
-    ctx.chatSocketRegistry.send(conversationId, wireEvent);
-}
-function persistUserMessageContent(ctx, conversationId, content) {
-    ctx.conversationStore.appendMessage(conversationId, {
-        role: "user",
-        content,
-        timestampMs: Date.now(),
-    });
-}
-function toStoredAttachmentMeta(attachments) {
-    if (attachments.length === 0)
-        return undefined;
-    return attachments.map((a) => ({
-        name: a.name,
-        mimeType: a.mimeType,
-        size: a.size,
-    }));
-}
-function persistUserMessage(ctx, msg) {
-    ctx.conversationStore.appendMessage(msg.conversationId, {
-        role: "user",
-        content: msg.content,
-        attachments: toStoredAttachmentMeta(msg.attachments ?? []),
-        timestampMs: Date.now(),
-    });
-}
-function persistPermissionDecision(ctx, conversationId, toolName, decision) {
-    ctx.conversationStore.appendMessage(conversationId, {
-        role: "permission",
-        content: "",
-        toolName,
-        decision: decision === PERMISSION_DECISIONS.DENY ? "denied" : "approved",
-        timestampMs: Date.now(),
-    });
-}
-function recordEditIfAny(ctx, conversationId, ev) {
-    if (ev.type !== "tool_use")
-        return;
-    if (!EDIT_TOOL_NAMES.has(ev.toolName))
-        return;
-    const filePath = extractEditedFilePath(ev.args);
-    if (filePath !== undefined)
-        ctx.editTracker.record(conversationId, filePath);
-}
-function buildRunnerContext(ctx, conversationId, attachments) {
-    return {
-        conversationId,
-        hostProjectRoot: ctx.hostProjectRoot,
-        getCurrentPage: () => ctx.hostState.getCurrentPage(),
-        attachments,
-        permissionBus: ctx.permissionBus,
-        createMcpServer: () => ctx.createMcpServer(conversationId),
-        onPermissionDecision: (toolName, decision) => persistPermissionDecision(ctx, conversationId, toolName, decision),
-        onTokenUsage: (usage) => ctx.conversationStore.addTokenUsage(conversationId, usage),
-    };
-}
-function handleTurnEvent(ctx, conversationId, ev) {
-    recordEditIfAny(ctx, conversationId, ev);
-    persistRunnerEvent(ctx, conversationId, ev);
-    dispatchTurnEvent(ctx, conversationId, ev);
-}
-async function streamTurn(ctx, conversationId, content, attachments) {
-    ctx.liveTurns.begin(conversationId);
-    ctx.conversationStore.markProvider(conversationId, ctx.settingsStore.get().provider);
-    const progress = startTurnProgress({
-        conversationId,
-        send: (event) => ctx.chatSocketRegistry.send(conversationId, event),
-    });
-    try {
-        const stream = ctx.runner.start(content, buildRunnerContext(ctx, conversationId, attachments));
-        for await (const ev of stream) {
-            progress.observe(ev);
-            handleTurnEvent(ctx, conversationId, ev);
-        }
-    }
-    finally {
-        progress.stop();
-        ctx.liveTurns.end(conversationId);
-    }
-}
-async function runSafetyNet(ctx, conversationId, sinceMs, attempt) {
-    if (attempt >= MAX_AUTO_HEAL_ATTEMPTS)
-        return;
-    const editedFiles = ctx.editTracker.getEditedFiles(conversationId);
-    if (editedFiles.length === 0)
-        return;
-    const healPrompt = await collectBuildIssues({
-        editedFiles,
-        knownRoots: [ctx.hostProjectRoot, ...ctx.moduleRoots],
-        logsClient: ctx.logsClient,
-        sinceMs,
-    });
-    if (healPrompt === null)
-        return;
-    ctx.editTracker.clear(conversationId);
-    const nextSinceMs = Date.now();
-    persistUserMessageContent(ctx, conversationId, healPrompt);
-    await streamTurn(ctx, conversationId, healPrompt);
-    await runSafetyNet(ctx, conversationId, nextSinceMs, attempt + 1);
-}
-async function runTurnWithHealing(ctx, conversationId, content, attachments) {
-    ctx.editTracker.clear(conversationId);
-    const sinceMs = Date.now();
-    try {
-        await streamTurn(ctx, conversationId, content, attachments);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.warn(`${WS_LOG_PREFIX} turn setup failed: ${message}`);
-        handleTurnEvent(ctx, conversationId, { type: "error", message });
+});
+const handleActor = on(MESSAGE_TYPES.ACTOR, (_socket, msg, ctx) => {
+    ctx.actor = { userId: msg.userId, name: msg.name };
+});
+function noteAsker(ctx, conversationId) {
+    if (ctx.actor === null)
         return;
-    }
-    try {
-        await runSafetyNet(ctx, conversationId, sinceMs, 0);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.warn(`${WS_LOG_PREFIX} safety net failed: ${message}`);
-    }
-}
-function persistQueuedUserMessage(ctx, conversationId, item) {
-    ctx.conversationStore.appendMessage(conversationId, {
-        role: "user",
-        content: item.content,
-        attachments: toStoredAttachmentMeta(item.attachments ?? []),
-        timestampMs: Date.now(),
-    });
-}
-function sendUserEcho(ctx, conversationId, item) {
-    const event = {
-        type: EVENT_TYPES.USER_MESSAGE_ECHO,
-        conversationId,
-        content: item.content,
-        attachments: toStoredAttachmentMeta(item.attachments ?? []),
-        timestampMs: Date.now(),
-    };
-    ctx.chatSocketRegistry.send(conversationId, event);
-}
-function broadcastQueueState(ctx, conversationId) {
-    const event = {
-        type: EVENT_TYPES.QUEUE_STATE,
-        conversationId,
-        items: ctx.pendingQueue.get(conversationId),
-    };
-    ctx.chatSocketRegistry.send(conversationId, event);
-}
-async function drainConversation(ctx, conversationId) {
-    for (;;) {
-        const next = ctx.pendingQueue.shift(conversationId);
-        if (next === null)
-            return;
-        try {
-            broadcastQueueState(ctx, conversationId);
-            persistQueuedUserMessage(ctx, conversationId, next);
-            sendUserEcho(ctx, conversationId, next);
-            await runTurnWithHealing(ctx, conversationId, next.content, next.attachments);
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.warn(`${WS_LOG_PREFIX} queued turn failed: ${message}`);
-        }
-    }
-}
-async function ensureDraining(ctx, conversationId) {
-    if (!ctx.pendingQueue.tryStartDrain(conversationId))
-        return;
-    try {
-        await drainConversation(ctx, conversationId);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.warn(`${WS_LOG_PREFIX} drain failed: ${message}`);
-    }
-    finally {
-        ctx.pendingQueue.endDrain(conversationId);
-    }
+    ctx.askers.set(conversationId, ctx.actor.name);
 }
-function enqueueUserMessage(ctx, msg) {
-    const queued = {
-        id: randomUUID(),
-        content: msg.content,
-    };
-    if (msg.attachments && msg.attachments.length > 0) {
-        queued.attachments = msg.attachments;
-    }
-    ctx.pendingQueue.enqueue(msg.conversationId, queued);
-    broadcastQueueState(ctx, msg.conversationId);
-}
-async function runUserMessage(_socket, msg, ctx) {
-    if (msg.type !== MESSAGE_TYPES.USER_MESSAGE)
-        return;
+const runUserMessage = on(MESSAGE_TYPES.USER_MESSAGE, async (_s, msg, ctx) => {
+    noteAsker(ctx, msg.conversationId);
     if (!ctx.pendingQueue.tryStartDrain(msg.conversationId)) {
         enqueueUserMessage(ctx, msg);
         void ensureDraining(ctx, msg.conversationId);
         return;
     }
-    try {
-        persistUserMessage(ctx, msg);
-        await runTurnWithHealing(ctx, msg.conversationId, msg.content, msg.attachments);
-        await drainConversation(ctx, msg.conversationId);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.warn(`${WS_LOG_PREFIX} run failed: ${message}`);
-    }
-    finally {
-        ctx.pendingQueue.endDrain(msg.conversationId);
-    }
-}
-function handleQueueEnqueue(_socket, msg, ctx) {
-    if (msg.type !== MESSAGE_TYPES.QUEUE_ENQUEUE)
-        return;
+    await runExclusive(ctx, msg.conversationId, async () => {
+        persistUserMessage(ctx, msg.conversationId, msg);
+        await runUserTurn(ctx, msg.conversationId, msg);
+    });
+});
+const handleRetryTurn = on(MESSAGE_TYPES.RETRY_TURN, async (_s, msg, ctx) => {
+    const last = lastUserMessage(ctx, msg.conversationId);
+    if (last === undefined)
+        return;
+    if (!ctx.pendingQueue.tryStartDrain(msg.conversationId))
+        return;
+    noteAsker(ctx, msg.conversationId);
+    await runExclusive(ctx, msg.conversationId, () => runUserTurn(ctx, msg.conversationId, { content: last.content }));
+});
+const handleQueueEnqueue = on(MESSAGE_TYPES.QUEUE_ENQUEUE, (_s, msg, ctx) => {
+    noteAsker(ctx, msg.conversationId);
     ctx.pendingQueue.enqueue(msg.conversationId, msg.item);
     broadcastQueueState(ctx, msg.conversationId);
     void ensureDraining(ctx, msg.conversationId);
-}
-function handleQueueCancel(_socket, msg, ctx) {
-    if (msg.type !== MESSAGE_TYPES.QUEUE_CANCEL)
-        return;
+});
+const handleQueueCancel = on(MESSAGE_TYPES.QUEUE_CANCEL, (_s, msg, ctx) => {
     ctx.pendingQueue.cancel(msg.conversationId, msg.id);
     broadcastQueueState(ctx, msg.conversationId);
-}
-function handlePermissionResponse(_socket, msg, ctx) {
-    if (msg.type !== MESSAGE_TYPES.PERMISSION_RESPONSE)
-        return;
-    ctx.permissionBus.resolvePermission(msg.requestId, msg.decision);
-}
-function handleQuestionResponse(_socket, msg, ctx) {
-    if (msg.type !== MESSAGE_TYPES.QUESTION_RESPONSE)
-        return;
-    ctx.questionBus.resolveQuestion(msg.requestId, msg.answers);
-}
-function handleInterruptTurn(_socket, msg, ctx) {
-    if (msg.type !== MESSAGE_TYPES.INTERRUPT_TURN)
-        return;
-    for (const pending of ctx.permissionBus.getPendingForConversation(msg.conversationId)) {
-        ctx.permissionBus.resolvePermission(pending.requestId, PERMISSION_DECISIONS.DENY);
-    }
-    ctx.questionBus.cancelConversation(msg.conversationId);
-    ctx.runner.interruptSession(msg.conversationId);
-}
-async function handleHostStateUpdate(_socket, msg, ctx) {
-    if (msg.type !== MESSAGE_TYPES.HOST_STATE_UPDATE)
-        return;
+});
+const handleQueueUpdate = on(MESSAGE_TYPES.QUEUE_UPDATE, (_s, msg, ctx) => {
+    ctx.pendingQueue.update(msg.conversationId, msg.id, msg.content);
+    broadcastQueueState(ctx, msg.conversationId);
+});
+const handleQueueMove = on(MESSAGE_TYPES.QUEUE_MOVE, (_s, msg, ctx) => {
+    ctx.pendingQueue.move(msg.conversationId, msg.id, msg.toIndex);
+    broadcastQueueState(ctx, msg.conversationId);
+});
+const handleQueueClear = on(MESSAGE_TYPES.QUEUE_CLEAR, (_s, msg, ctx) => {
+    ctx.pendingQueue.clear(msg.conversationId);
+    broadcastQueueState(ctx, msg.conversationId);
+});
+const handlePermissionResponse = on(MESSAGE_TYPES.PERMISSION_RESPONSE, (_s, msg, ctx) => {
+    ctx.permissionBus.resolvePermission({
+        requestId: msg.requestId,
+        decision: msg.decision,
+        rule: msg.rule,
+        feedback: msg.feedback,
+        keepData: msg.keepData,
+        actor: ctx.actor?.name,
+    });
+});
+const handleRevokeRule = on(MESSAGE_TYPES.REVOKE_RULE, (_s, msg, ctx) => {
+    if (ctx.permissionBus.revokeRule(msg.conversationId, msg.ruleId))
+        return;
+    sendRulesState(ctx, msg.conversationId);
+});
+const handleQuestionResponse = on(MESSAGE_TYPES.QUESTION_RESPONSE, (_s, msg, ctx) => {
+    ctx.questionBus.resolveQuestion(msg.requestId, {
+        answers: msg.answers,
+        skipped: msg.skipped ?? [],
+    });
+});
+const handleInterruptTurn = on(MESSAGE_TYPES.INTERRUPT_TURN, (_s, msg, ctx) => {
+    interruptConversation(ctx, msg.conversationId);
+});
+const handleStopAutoFix = on(MESSAGE_TYPES.STOP_AUTOFIX, (_s, msg, ctx) => {
+    ctx.turns.stopAutoFix(msg.conversationId);
+    if (ctx.turns.get(msg.conversationId)?.isAutoFix !== true)
+        return;
+    interruptConversation(ctx, msg.conversationId);
+});
+const handleSetConversationMode = on(MESSAGE_TYPES.SET_CONVERSATION_MODE, (_s, msg, ctx) => {
+    ctx.conversationModes.update(msg.conversationId, {
+        mode: msg.mode,
+        generationMode: msg.generationMode,
+        fullAuto: msg.fullAuto,
+    });
+});
+const handleLeaveConversation = on(MESSAGE_TYPES.LEAVE_CONVERSATION, (_s, msg, ctx) => {
+    ctx.conversationModes.leave(msg.conversationId);
+});
+const handleHostStateUpdate = on(MESSAGE_TYPES.HOST_STATE_UPDATE, async (_s, msg, ctx) => {
     await ctx.hostState.setCurrentPage(msg.currentPage);
-}
-function handleHostNavigationComplete(_socket, msg, ctx) {
-    if (msg.type !== MESSAGE_TYPES.HOST_NAVIGATION_COMPLETE)
-        return;
+});
+const handleHostNavigationComplete = on(MESSAGE_TYPES.HOST_NAVIGATION_COMPLETE, (_s, msg, ctx) => {
     ctx.navigationCompleter.complete(msg.path);
-}
-function buildConversationListEvent(ctx) {
-    return {
-        type: EVENT_TYPES.CONVERSATION_LIST,
-        conversations: ctx.conversationStore.list(),
-    };
-}
-function sendConversationList(socket, ctx) {
-    socket.send(JSON.stringify(buildConversationListEvent(ctx)));
-}
-function handleListConversations(socket, msg, ctx) {
-    if (msg.type !== MESSAGE_TYPES.LIST_CONVERSATIONS)
-        return;
-    sendConversationList(socket, ctx);
-}
-function handleDeleteConversation(socket, msg, ctx) {
-    if (msg.type !== MESSAGE_TYPES.DELETE_CONVERSATION)
-        return;
-    ctx.conversationStore.delete(msg.conversationId);
-    ctx.permissionBus.forgetConversation(msg.conversationId);
-    ctx.questionBus.cancelConversation(msg.conversationId);
-    ctx.editTracker.clear(msg.conversationId);
-    void ctx.runner.disposeSession(msg.conversationId);
-    ctx.liveTurns.end(msg.conversationId);
-    ctx.pendingQueue.clear(msg.conversationId);
-    sendConversationList(socket, ctx);
-}
+});
+const handleListConversations = on(MESSAGE_TYPES.LIST_CONVERSATIONS, (socket, _msg, ctx) => {
+    send(socket, buildConversationListEvent(ctx));
+});
+function forgetConversation(ctx, conversationId) {
+    ctx.conversationStore.delete(conversationId);
+    ctx.permissionBus.forgetConversation(conversationId);
+    ctx.questionBus.cancelConversation(conversationId);
+    ctx.editTracker.clear(conversationId);
+    ctx.conversationModes.forget(conversationId);
+    ctx.callAudit.forget(conversationId);
+    ctx.callLedger.forget(conversationId);
+    ctx.askers.delete(conversationId);
+    void ctx.runner.disposeSession(conversationId);
+    ctx.liveTurns.end(conversationId);
+    ctx.pendingQueue.clear(conversationId);
+}
+const handleDeleteConversation = on(MESSAGE_TYPES.DELETE_CONVERSATION, (socket, msg, ctx) => {
+    forgetConversation(ctx, msg.conversationId);
+    send(socket, buildConversationListEvent(ctx));
+    broadcastConversationList(ctx);
+});
 export function applySettings(deps, next) {
     deps.settingsStore.set(next);
-    deps.permissionBus.setAutoApprove(effectiveChatMode(next) === "auto");
     deps.runner.applySettings(next);
-    deps.chatSocketRegistry.broadcast({
-        type: EVENT_TYPES.SETTINGS_UPDATE,
-        settings: next,
-        builderAvailable: getBuilderAvailable(),
-        providers: getProviderAvailability(),
+    deps.chatSocketRegistry.broadcast(buildSettingsUpdateEvent(deps));
+}
+function applySettingsPatch(deps, patch) {
+    const next = mergeSettings(deps.settingsStore.get(), patch);
+    applySettings(deps, next);
+    return next;
+}
+const handleSetSettings = on(MESSAGE_TYPES.SET_SETTINGS, (_s, msg, ctx) => {
+    const { type: _type, ...patch } = msg;
+    applySettingsPatch(ctx, patch);
+});
+const handleChangeSet = on(MESSAGE_TYPES.CHANGE_SET_ACTION, async (socket, msg, ctx) => {
+    await handleChangeSetAction(ctx, msg, ctx.actor?.name).catch((err) => {
+        logFailure("change set action failed", err);
+        send(socket, {
+            type: EVENT_TYPES.RUN_ERROR,
+            conversationId: msg.conversationId ?? "",
+            error: err instanceof Error ? err.message : String(err),
+        });
     });
-}
-function handleSetSettings(_socket, msg, ctx) {
-    if (msg.type !== MESSAGE_TYPES.SET_SETTINGS)
-        return;
-    applySettings(ctx, {
-        provider: msg.provider ?? ctx.settingsStore.get().provider,
-        mode: msg.mode,
-        thinking: msg.thinking,
-        generationMode: msg.generationMode,
-        allowLocalSkills: msg.allowLocalSkills,
-    });
-}
+});
 const MESSAGE_HANDLERS = {
     [MESSAGE_TYPES.HELLO]: handleHello,
     [MESSAGE_TYPES.ECHO]: handleEcho,
+    [MESSAGE_TYPES.ACTOR]: handleActor,
     [MESSAGE_TYPES.USER_MESSAGE]: runUserMessage,
+    [MESSAGE_TYPES.RETRY_TURN]: handleRetryTurn,
     [MESSAGE_TYPES.PERMISSION_RESPONSE]: handlePermissionResponse,
+    [MESSAGE_TYPES.REVOKE_RULE]: handleRevokeRule,
     [MESSAGE_TYPES.QUESTION_RESPONSE]: handleQuestionResponse,
     [MESSAGE_TYPES.INTERRUPT_TURN]: handleInterruptTurn,
+    [MESSAGE_TYPES.STOP_AUTOFIX]: handleStopAutoFix,
+    [MESSAGE_TYPES.SET_CONVERSATION_MODE]: handleSetConversationMode,
+    [MESSAGE_TYPES.LEAVE_CONVERSATION]: handleLeaveConversation,
     [MESSAGE_TYPES.HOST_STATE_UPDATE]: handleHostStateUpdate,
     [MESSAGE_TYPES.HOST_NAVIGATION_COMPLETE]: handleHostNavigationComplete,
     [MESSAGE_TYPES.LIST_CONVERSATIONS]: handleListConversations,
@@ -512,6 +240,10 @@ const MESSAGE_HANDLERS = {
     [MESSAGE_TYPES.SET_SETTINGS]: handleSetSettings,
     [MESSAGE_TYPES.QUEUE_ENQUEUE]: handleQueueEnqueue,
     [MESSAGE_TYPES.QUEUE_CANCEL]: handleQueueCancel,
+    [MESSAGE_TYPES.QUEUE_UPDATE]: handleQueueUpdate,
+    [MESSAGE_TYPES.QUEUE_MOVE]: handleQueueMove,
+    [MESSAGE_TYPES.QUEUE_CLEAR]: handleQueueClear,
+    [MESSAGE_TYPES.CHANGE_SET_ACTION]: handleChangeSet,
 };
 function parseMessage(raw) {
     try {
@@ -536,50 +268,7 @@ export function dispatchMessage(socket, raw, ctx) {
         return;
     void handler(socket, msg, ctx);
 }
-function buildPermissionRequestEvent(event) {
-    return {
-        type: EVENT_TYPES.PERMISSION_REQUEST,
-        conversationId: event.conversationId,
-        requestId: event.requestId,
-        toolName: event.toolName,
-        args: event.args,
-        summary: buildToolSummary(event.toolName, event.args),
-    };
-}
-function sendPermissionRequest(socket, event) {
-    const wireEvent = buildPermissionRequestEvent(event);
-    socket.send(JSON.stringify(wireEvent));
-}
-function buildAskQuestionEvent(event) {
-    return {
-        type: EVENT_TYPES.ASK_QUESTION,
-        conversationId: event.conversationId,
-        requestId: event.requestId,
-        questions: event.questions,
-    };
-}
-function sendQuestionRequest(socket, event) {
-    const wireEvent = buildAskQuestionEvent(event);
-    socket.send(JSON.stringify(wireEvent));
-}
 export function buildConnectionContext(config) {
-    return {
-        hostProjectRoot: config.hostProjectRoot,
-        runner: config.runner,
-        conversationStore: config.conversationStore,
-        permissionBus: config.permissionBus,
-        questionBus: config.questionBus,
-        createMcpServer: config.createMcpServer,
-        editTracker: config.editTracker,
-        logsClient: config.logsClient,
-        moduleRoots: config.moduleRoots,
-        hostState: config.hostState,
-        hostSocketRegistry: config.hostSocketRegistry,
-        chatSocketRegistry: config.chatSocketRegistry,
-        navigationCompleter: config.navigationCompleter,
-        liveTurns: config.liveTurns,
-        pendingQueue: config.pendingQueue,
-        settingsStore: config.settingsStore,
-    };
+    return { ...config, actor: null };
 }
 //# sourceMappingURL=routing.js.map