@bbigbang/core 0.1.0

package/dist/web/workspaceMemoryHints.js

@@ -0,0 +1,143 @@
+import { channelMemoryNotePath } from './channelMemoryNotes.js';
+const BEIJING_DATE_FORMATTER = new Intl.DateTimeFormat('en-CA', {
+    timeZone: 'Asia/Shanghai',
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+});
+function getBeijingDateParts(input) {
+    const parts = BEIJING_DATE_FORMATTER.formatToParts(input);
+    const getPart = (type) => Number(parts.find((part) => part.type === type)?.value);
+    const year = getPart('year');
+    const month = getPart('month');
+    const day = getPart('day');
+    const date = `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
+    return { year, month, day, date };
+}
+/** Returns ISO 8601 week string and Beijing date string for the current moment. */
+export function getCurrentISOWeek() {
+    const today = getBeijingDateParts(new Date());
+    const beijingDate = new Date(Date.UTC(today.year, today.month - 1, today.day));
+    // Shift to Thursday of the ISO week to determine the week's year and number
+    const d = new Date(beijingDate);
+    const dayNum = d.getUTCDay() || 7;
+    d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+    const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+    const weekNo = Math.ceil((((d.getTime() - yearStart.getTime()) / 86_400_000) + 1) / 7);
+    const week = `${d.getUTCFullYear()}-W${String(weekNo).padStart(2, '0')}`;
+    return { week, date: today.date };
+}
+export function isThreadTarget(target) {
+    if (target.startsWith('dm:@')) {
+        return target.split(':').length >= 3;
+    }
+    if (target.startsWith('#')) {
+        return target.split(':').length >= 2;
+    }
+    return false;
+}
+export function buildWorkspaceMemoryHints(params) {
+    const hints = ['MEMORY.md'];
+    if (params.channelName && params.includeChannelNote !== false) {
+        hints.push(channelMemoryNotePath(params.channelName));
+    }
+    if (params.includeTaskNotes) {
+        hints.push('notes/tasks.md');
+    }
+    if (params.includeWorkLog) {
+        hints.push(params.currentWeek ? `notes/work-log/${params.currentWeek}.md` : 'notes/work-log/');
+    }
+    return Array.from(new Set(hints));
+}
+export function resolveChannelTaskBoardPresencePolicy(params) {
+    const threadSurface = isThreadTarget(params.target);
+    if (params.includeOpenTasks) {
+        return { activationMode: 'full', renderMode: 'full' };
+    }
+    return {
+        activationMode: threadSurface ? 'off' : 'count',
+        renderMode: params.hasBoundTask || threadSurface ? 'off' : 'hint',
+    };
+}
+export function resolveDirectTaskThreadPresencePolicy(params) {
+    const threadSurface = isThreadTarget(params.target);
+    if (params.includeDmActiveTaskThreads) {
+        return { activationMode: 'full', renderMode: 'full' };
+    }
+    return {
+        activationMode: threadSurface ? 'off' : 'count',
+        renderMode: threadSurface ? 'off' : 'hint',
+    };
+}
+export function buildDefaultChannelMemoryHints(params) {
+    return buildWorkspaceMemoryHints({
+        channelName: params.channelName,
+        includeTaskNotes: Boolean(params.forceTaskNotes || params.hasBoundTask),
+        includeWorkLog: Boolean(params.forceWorkLog),
+        currentWeek: params.currentWeek,
+    });
+}
+export function buildDefaultDirectMemoryHints(params) {
+    return buildWorkspaceMemoryHints({
+        includeChannelNote: false,
+        includeTaskNotes: Boolean(params.forceTaskNotes || params.threadRootId),
+        includeWorkLog: Boolean(params.forceWorkLog),
+        currentWeek: params.currentWeek,
+    });
+}
+export function buildWorkspaceMemoryHintSection(memoryHints, today) {
+    const hints = (memoryHints ?? []).map((hint) => hint.trim()).filter(Boolean);
+    if (hints.length === 0)
+        return '';
+    return [
+        '[Workspace memory to check if you need it]',
+        ...(today ? [`Today: ${today.week} (${today.date} Beijing / UTC+8)`] : []),
+        ...hints,
+    ].join('\n');
+}
+export function buildWorkspaceMemoryReminder(memoryHints, today) {
+    const hints = (memoryHints ?? []).map((hint) => hint.trim()).filter(Boolean);
+    const summary = hints.length > 0 ? hints.join(', ') : 'MEMORY.md';
+    const todayLine = today ? `Today: ${today.week} (${today.date} Beijing / UTC+8)\n` : '';
+    return `${todayLine}This work spans multiple turns. Check workspace memory if you need it (${summary}) before deeper history lookup.`;
+}
+export function buildActiveProjectSection(params) {
+    if (!params)
+        return '';
+    return [
+        '[Active project]',
+        `name: ${params.name}`,
+        `backend: ${params.backendType}`,
+        `root: ${params.rootPath}`,
+        params.backendType === 'shared_mount'
+            ? 'This project root may be shared across multiple machines; use workspace/git/terminal actions against this project root.'
+            : 'This is a node-local project root attached to the current conversation context.',
+    ].join('\n');
+}
+export function combinePromptSections(parts) {
+    return parts
+        .map((part) => part?.trim() ?? '')
+        .filter(Boolean)
+        .join('\n\n');
+}
+export function shouldIncludeParticipantsInActivationContext(params) {
+    if (params.hasBoundTask)
+        return true;
+    if (isThreadTarget(params.target))
+        return true;
+    if (params.reason === 'agent_mention')
+        return true;
+    return (params.participantsCount ?? 0) > 1;
+}
+export function shouldIncludeOpenTaskBoardSummary(params) {
+    void params;
+    // Root-surface task context is now carried as a light presence hint by default.
+    // Keep the detailed board summary opt-in only.
+    return false;
+}
+export function shouldIncludeDmContextSnapshot(params) {
+    void params.target;
+    // The full DM snapshot is no longer a default activation payload. Only explicit
+    // recovery flows should opt back into it.
+    return Boolean(params.includeRecoverySnapshot);
+}

package/dist/web/workspaceToolPromptGuidance.js

@@ -0,0 +1,30 @@
+export function buildWorkspaceToolGuidancePromptSection(options) {
+    if (options?.layoutPlan) {
+        return [
+            '[Workspace tool guidance]',
+            'Workspace-tool layout planning mode is enabled for this chat conversation.',
+            'Before designing the tool, run bigbang panel components and use the mounted workspace-tool-builder skill to define the action/status/view contract, including any explicit view.summary and view.parameterForm layout.',
+            'Do not write the tool bundle or run bigbang tool publish in this run. Send a compact chat wireframe and wait for the user to confirm in a later turn.',
+            'The wireframe must cover: tool purpose, actions and execution modes, status data source, fields/filter/sort labels, view.summary overview, RowTemplateGrid Columns layout for the visible view, parameterForm layout for grouped controls, action button placement, and an explicit confirmation prompt.',
+            'Use the mounted ui-panel skill only as the source of truth for view.template and controlled primitives syntax. Do not guess props, template nodes, dataset fields, media slot shapes, or action keys.',
+        ].join('\n');
+    }
+    return [
+        '[Workspace tool guidance]',
+        'Workspace-tool mode is enabled for this chat conversation.',
+        'This slash command requires a published Workspace Tool. Do not satisfy it by only writing a script, describing a bundle, or sending ordinary text.',
+        'Use the mounted workspace-tool-builder skill for the end-to-end tool workflow: define actions/status/view, write the bundle under .agent-tools/<slug>/, run bigbang tool validate --manifest-path <path> to check the manifest before publishing, and then run bigbang tool publish after validation passes.',
+        'After bigbang tool publish returns successfully, immediately send one normal visible final reply that confirms what was created or updated. The platform will automatically attach any newly published tool to that next visible agent message; you may also pass `bigbang message send --kind final --tool-id <tool_id>`.',
+        'The platform rejects a /tool final that has not published or attached a Workspace Tool; if publishing is impossible, send final with `--slash-command-failed "<reason>"`.',
+        'Registered tool maintainer agents can republish the same slug only from the owner agent\'s same node/workspace; cross-workspace republish is rejected to avoid implicit execution-owner transfer.',
+        'Do not inspect MEMORY.md, notes/tasks.md, or other workspace files after a successful publish unless the user explicitly asks for that extra analysis.',
+        'Use the mounted ui-panel skill only as the source of truth for view.template, view.summary, view.parameterForm, and controlled primitives syntax. Do not use bigbang panel create, bigbang panel patch, or bigbang panel read-rows to publish a workspace tool.',
+        'Workspace Tool actions must declare the intended interaction mode when it is not the default: omit mode or use mode="platform_exec" for direct command execution, and use mode="notify_agent" only when the button should send a structured request to the owner maintenance chat instead of running a command.',
+        'platform_exec actions already leave non-waking audit notes in the existing owner maintenance chat; do not duplicate them with notify_agent unless the agent must actively handle the request.',
+        'For status, monitoring, dashboard, or tool-control views, prefer view.summary for display-only overview facts and RowTemplateGrid Columns/Grid/Stack for the visible view instead of stacking every field vertically in one Card. Do not put ActionBar, Button, FileUpload, or parameter inputs in view.summary. When the user wants grouped or multi-column controls, express them through view.parameterForm instead of relying on the platform auto-generated paramsSchema form.',
+        'Status actions must write a flat JSON object to stdout whose keys exactly match view.fields[].name. The platform parses this object and maps each value to the corresponding field declaration; nested objects or extra keys are ignored.',
+        'actions[].paramsSchema is the canonical execution contract; view.parameterForm is the layout layer for those params. Parameter controls must bind with tool_action.<actionId>.<paramName> names. Supported paramsSchema.input types are: text, textarea, number, checkbox, select, multiselect, tags, date, and file. Tool FileUpload is supported only for platform_exec action params and is materialized into bounded run-scoped workspace upload refs.',
+        'For persistent start/restart actions, set maxRunSeconds when there is a safe upper bound; set idleTimeoutSeconds when a silent stdout period should be treated as stale.',
+        'Use manifest env.condaEnv, env.vars, and env.cwd for shared execution setup instead of repeating conda/env/cd boilerplate in every action command.',
+    ].join('\n');
+}

package/dist/web/wsHandler.js

@@ -0,0 +1,397 @@
+import { log } from '@bbigbang/runtime-acp';
+import { iterateParsedNodeEvents } from '../nodeEventHistory.js';
+import { buildPrimaryDmTaskRootUpdateEventForThreadConversation } from './dmTaskThreadStatusProjection.js';
+// Active WebSocket connections per conversation
+const connectionsByConversation = new Map();
+/** Broadcast a ServerEvent to all connected clients for a conversation */
+export function broadcast(conversationId, event) {
+    const sockets = connectionsByConversation.get(conversationId);
+    if (!sockets)
+        return;
+    const data = JSON.stringify(event);
+    for (const ws of sockets) {
+        if (ws.readyState === ws.OPEN) {
+            ws.send(data);
+        }
+    }
+}
+function stripPromptAttachmentNote(text) {
+    const fileIdx = text.indexOf('\n\n[Attached file');
+    if (fileIdx >= 0)
+        return text.slice(0, fileIdx);
+    const imageIdx = text.indexOf('\n\n[Attached image');
+    return imageIdx >= 0 ? text.slice(0, imageIdx) : text;
+}
+/** Handle a new WebSocket connection for a conversation */
+export function handleWebSocket(socket, conversationId, manager, senderName, broadcastStatus, resolvePromptAttachments) {
+    // Register this connection
+    let sockets = connectionsByConversation.get(conversationId);
+    if (!sockets) {
+        sockets = new Set();
+        connectionsByConversation.set(conversationId, sockets);
+    }
+    sockets.add(socket);
+    // Verify conversation exists
+    const conv = manager.getConversation(conversationId);
+    if (!conv) {
+        const errEvent = { type: 'error', message: 'Conversation not found' };
+        socket.send(JSON.stringify(errEvent));
+        socket.close();
+        return;
+    }
+    // Send current status
+    const statusEvent = {
+        type: 'conversation.status',
+        conversationId,
+        status: conv.status,
+    };
+    socket.send(JSON.stringify(statusEvent));
+    // 回放历史消息
+    replayHistory(socket, conversationId, manager);
+    // Signal history replay complete (client can now expect live events)
+    const historyDone = { type: 'history.complete' };
+    socket.send(JSON.stringify(historyDone));
+    // Handle incoming messages
+    socket.on('message', (raw) => {
+        let event;
+        try {
+            event = JSON.parse(String(raw));
+        }
+        catch {
+            const errEvent = { type: 'error', message: 'Invalid JSON' };
+            socket.send(JSON.stringify(errEvent));
+            return;
+        }
+        handleClientEvent(conversationId, event, manager, senderName, broadcastStatus, resolvePromptAttachments).catch((err) => {
+            log.warn('WebSocket client event error', err);
+            broadcast(conversationId, { type: 'error', message: String(err?.message ?? err) });
+        });
+    });
+    // Clean up on close
+    socket.on('close', () => {
+        sockets.delete(socket);
+        if (sockets.size === 0) {
+            connectionsByConversation.delete(conversationId);
+        }
+    });
+}
+/** 从 DB 读取历史 runs/events，回放为 ServerEvent 发送给客户端 */
+function replayHistory(socket, conversationId, manager) {
+    const db = manager.getDb();
+    const row = db
+        .prepare('SELECT session_key as sessionKey, status FROM conversations WHERE id = ?')
+        .get(conversationId);
+    if (!row)
+        return;
+    // 获取所有 runs，按时间正序
+    const runs = db
+        .prepare(`SELECT run_id as runId, prompt_text as promptText, stop_reason as stopReason, ended_at as endedAt, started_at as startedAt
+              , error
+       FROM runs WHERE session_key = ? ORDER BY started_at ASC`)
+        .all(row.sessionKey);
+    const send = (event) => {
+        if (socket.readyState === socket.OPEN) {
+            socket.send(JSON.stringify(event));
+        }
+    };
+    for (const run of runs) {
+        // 发送用户消息
+        send({ type: 'history.user_message', text: run.promptText });
+        // 发送 turn
+        const turnId = `replay-${run.runId}`;
+        send({ type: 'turn.begin', turnId, startedAt: run.startedAt, promptText: run.promptText });
+        // 读取 node/event（remote runs）— 直接回放 ServerEvent
+        let replayedNodeEvent = false;
+        for (const evt of iterateParsedNodeEvents(db, {
+            runId: run.runId,
+            types: ['content.delta', 'activity.delta', 'tool.call', 'tool.result', 'thinking.delta', 'plan.update', 'task.update', 'run.usage', 'run.steer.result'],
+        })) {
+            const parsed = evt.event;
+            if (!parsed)
+                continue;
+            replayedNodeEvent = true;
+            if (parsed.type === 'tool.call') {
+                send({ ...parsed, startedAt: parsed.startedAt ?? evt.createdAt });
+            }
+            else if (parsed.type === 'tool.result') {
+                send({ ...parsed, endedAt: parsed.endedAt ?? evt.createdAt });
+            }
+            else if (parsed.type === 'run.usage') {
+                send({ ...parsed, createdAt: parsed.createdAt ?? evt.createdAt });
+            }
+            else if (parsed.type === 'run.steer.result') {
+                send({ ...parsed, createdAt: parsed.createdAt ?? evt.createdAt });
+            }
+            else {
+                send(parsed);
+            }
+        }
+        if (!replayedNodeEvent) {
+            // 本地 run：读取 session/update 事件并重新合并
+            const events = db
+                .prepare(`SELECT payload_json as payloadJson, created_at as createdAt FROM events
+           WHERE run_id = ? AND method = 'session/update'
+           ORDER BY seq ASC`)
+                .all(run.runId);
+            let agentText = '';
+            let thinkingText = '';
+            const toolCalls = new Map();
+            for (const evt of events) {
+                try {
+                    const payload = JSON.parse(evt.payloadJson);
+                    const update = payload?.update;
+                    if (!update)
+                        continue;
+                    if (update.sessionUpdate === 'agent_message_chunk') {
+                        agentText += update.content?.text ?? '';
+                    }
+                    if (update.sessionUpdate === 'agent_thought_chunk') {
+                        thinkingText += update.content?.text ?? '';
+                    }
+                    if (update.sessionUpdate === 'tool_call') {
+                        const toolCallId = extractToolCallIdFromUpdate(update) ?? '';
+                        const name = String(update.title ?? toolCallId ?? 'tool');
+                        toolCalls.set(toolCallId, { name, startedAt: evt.createdAt });
+                    }
+                    if (update.sessionUpdate === 'tool_call_update') {
+                        const toolCallId = extractToolCallIdFromUpdate(update) ?? '';
+                        const existing = toolCalls.get(toolCallId);
+                        const status = `${update.status ?? update.state ?? update.outcome ?? ''}`.toLowerCase();
+                        if (status.includes('done') ||
+                            status.includes('complete') ||
+                            status.includes('success') ||
+                            status.includes('error') ||
+                            status.includes('fail') ||
+                            status.includes('cancel')) {
+                            if (existing) {
+                                existing.output = update.output ?? status;
+                                existing.error = status.includes('error') || status.includes('fail');
+                                existing.status = status.includes('cancel')
+                                    ? 'cancelled'
+                                    : existing.error
+                                        ? 'failed'
+                                        : 'completed';
+                                existing.endedAt = evt.createdAt;
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // 跳过解析失败的事件
+                }
+            }
+            if (agentText) {
+                send({ type: 'content.delta', text: agentText });
+            }
+            if (thinkingText) {
+                send({ type: 'thinking.delta', text: thinkingText });
+            }
+            for (const [toolCallId, tc] of toolCalls) {
+                send({ type: 'tool.call', toolCallId, name: tc.name, input: null, startedAt: tc.startedAt });
+                if (tc.output !== undefined) {
+                    send({
+                        type: 'tool.result',
+                        toolCallId,
+                        output: tc.output,
+                        error: tc.error,
+                        status: tc.status,
+                        endedAt: tc.endedAt,
+                    });
+                }
+            }
+        }
+        if (run.endedAt === null) {
+            const approvalEvent = getReplayablePendingApprovalRequest(db, run.runId);
+            if (approvalEvent) {
+                if (row.status !== 'awaiting_approval') {
+                    send({ type: 'conversation.status', conversationId, status: 'awaiting_approval' });
+                }
+                send(approvalEvent);
+            }
+        }
+        if (run.endedAt !== null) {
+            send({
+                type: 'turn.end',
+                turnId,
+                stopReason: run.error ? 'error' : (run.stopReason ?? 'end_turn'),
+                endedAt: run.endedAt,
+                error: run.error ?? undefined,
+            });
+        }
+    }
+    // 补发还在队列中（未被处理）的用户消息，避免刷新后消失
+    const queued = db
+        .prepare(`SELECT prompt_text as promptText, created_at as createdAt
+       FROM conversation_prompt_queue
+	       WHERE conversation_id = ?
+	         AND record_as_user_message = 1
+	         AND COALESCE(dispatch_kind, '') != 'legacy_unknown'
+	         AND (
+           client_message_id IS NULL
+           OR NOT EXISTS (
+             SELECT 1
+             FROM channel_messages cm
+             WHERE cm.message_id = conversation_prompt_queue.client_message_id
+           )
+         )
+       ORDER BY created_at ASC`)
+        .all(conversationId);
+    for (const q of queued) {
+        send({ type: 'history.user_message', text: q.promptText });
+    }
+}
+function getReplayablePendingApprovalRequest(db, runId) {
+    const approvalRow = db.prepare(`SELECT approval.payload_json as payloadJson
+     FROM events approval
+     WHERE approval.run_id = ?
+       AND approval.method = 'node/event'
+       AND json_valid(approval.payload_json)
+       AND json_extract(approval.payload_json, '$.type') = 'approval.request'
+       AND NOT EXISTS (
+         SELECT 1
+         FROM events later
+         WHERE later.run_id = approval.run_id
+           AND later.seq > approval.seq
+           AND json_valid(later.payload_json)
+           AND (
+             (
+               later.method = 'approval/response'
+               AND json_extract(later.payload_json, '$.type') = 'approval.response'
+               AND json_extract(later.payload_json, '$.requestId') = json_extract(approval.payload_json, '$.requestId')
+             )
+             OR (
+               later.method = 'node/event'
+               AND json_extract(later.payload_json, '$.type') IN (
+                 'content.delta',
+                 'activity.delta',
+                 'thinking.delta',
+                 'tool.call',
+                 'tool.result',
+                 'plan.update',
+                 'plan.phase',
+                 'task.update',
+                 'runtime.compact'
+               )
+             )
+           )
+       )
+     ORDER BY approval.seq DESC
+     LIMIT 1`).get(runId);
+    if (!approvalRow)
+        return null;
+    try {
+        const approvalEvent = JSON.parse(approvalRow.payloadJson);
+        return approvalEvent.type === 'approval.request' ? approvalEvent : null;
+    }
+    catch {
+        // Ignore malformed persisted approval events; live approval flow is unaffected.
+        return null;
+    }
+}
+function persistApprovalResponseMarker(db, conversationId, requestId, decision, selectedActionId) {
+    const row = db.prepare(`SELECT runs.run_id as runId
+     FROM runs
+     JOIN conversations ON conversations.session_key = runs.session_key
+     WHERE conversations.id = ?
+       AND runs.ended_at IS NULL
+       AND EXISTS (
+         SELECT 1
+         FROM events
+         WHERE events.run_id = runs.run_id
+           AND events.method = 'node/event'
+           AND json_valid(events.payload_json)
+           AND json_extract(events.payload_json, '$.type') = 'approval.request'
+           AND json_extract(events.payload_json, '$.requestId') = ?
+       )
+     ORDER BY runs.started_at DESC
+     LIMIT 1`).get(conversationId, requestId);
+    if (!row)
+        return;
+    const seqRow = db.prepare(`SELECT COALESCE(MAX(seq), 0) + 1 as nextSeq
+     FROM events
+     WHERE run_id = ?`).get(row.runId);
+    const payload = {
+        type: 'approval.response',
+        requestId,
+        decision,
+        ...(selectedActionId ? { selectedActionId } : {}),
+    };
+    db.prepare(`INSERT OR IGNORE INTO events(run_id, seq, method, payload_json, created_at)
+     VALUES(?, ?, 'approval/response', ?, ?)`).run(row.runId, seqRow?.nextSeq ?? 1, JSON.stringify(payload), Date.now());
+}
+/** 从 update 中提取 toolCallId */
+function extractToolCallIdFromUpdate(update) {
+    return update?.toolCallId ?? update?.tool_call_id ?? update?.callId ?? update?.call_id ?? null;
+}
+async function handleClientEvent(conversationId, event, manager, senderName, broadcastStatus, resolvePromptAttachments) {
+    switch (event.type) {
+        case 'prompt': {
+            const conv = manager.getConversation(conversationId);
+            if (!conv?.nodeId) {
+                broadcast(conversationId, { type: 'error', message: 'No agent node assigned. Connect an agent-node first.' });
+                break;
+            }
+            log.info('[ws] prompt → remote node', { conversationId, nodeId: conv.nodeId });
+            try {
+                const promptAttachments = resolvePromptAttachments?.(event.text, event.attachments) ?? { ids: [], refs: [] };
+                const promptText = promptAttachments.ids.length > 0 ? stripPromptAttachmentNote(event.text) : event.text;
+                const result = await manager.submitPrompt(conversationId, promptText, {
+                    senderName,
+                    attachments: promptAttachments.refs,
+                    attachmentIds: promptAttachments.ids,
+                    runtimeOverrides: event.runtimeOverrides,
+                });
+                if (result.queued) {
+                    if (broadcastStatus) {
+                        broadcastStatus(conversationId, 'queued');
+                    }
+                    else {
+                        broadcast(conversationId, { type: 'conversation.status', conversationId, status: 'queued' });
+                    }
+                }
+            }
+            catch (error) {
+                broadcast(conversationId, { type: 'error', message: String(error?.message ?? error) });
+                if (broadcastStatus) {
+                    broadcastStatus(conversationId, 'idle');
+                }
+                else {
+                    broadcast(conversationId, { type: 'conversation.status', conversationId, status: 'idle' });
+                }
+            }
+            // turn.end and idle status come from nodeWsHandler on run.end
+            break;
+        }
+        case 'approval.response': {
+            const result = await manager.handleApproval(conversationId, event.requestId, event.decision, event.selectedActionId, event.responseText, event.answers);
+            if (!result.ok) {
+                broadcast(conversationId, { type: 'error', message: result.message });
+            }
+            else if (broadcastStatus) {
+                persistApprovalResponseMarker(manager.getDb(), conversationId, event.requestId, event.decision, event.selectedActionId);
+                const primaryDmTaskRootUpdate = buildPrimaryDmTaskRootUpdateEventForThreadConversation(manager.getDb(), conversationId, 'active');
+                if (primaryDmTaskRootUpdate) {
+                    broadcast(primaryDmTaskRootUpdate.conversationId, primaryDmTaskRootUpdate.event);
+                }
+                broadcastStatus(conversationId, 'active');
+            }
+            else {
+                persistApprovalResponseMarker(manager.getDb(), conversationId, event.requestId, event.decision, event.selectedActionId);
+                const primaryDmTaskRootUpdate = buildPrimaryDmTaskRootUpdateEventForThreadConversation(manager.getDb(), conversationId, 'active');
+                if (primaryDmTaskRootUpdate) {
+                    broadcast(primaryDmTaskRootUpdate.conversationId, primaryDmTaskRootUpdate.event);
+                }
+                broadcast(conversationId, { type: 'conversation.status', conversationId, status: 'active' });
+            }
+            break;
+        }
+        case 'cancel':
+            {
+                const result = manager.cancelConversationRun(conversationId);
+                if (!result.ok) {
+                    broadcast(conversationId, { type: 'error', message: result.message });
+                }
+            }
+            break;
+    }
+}