discoclaw 1.2.4 → 2.0.0

package/dist/discord/deferred-runner.js

@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto';
 import { ChannelType, PermissionFlagsBits } from 'discord.js';
 import { appendActionResults, buildTieredDiscordActionsPromptSection, executeDiscordActions, parseDiscordActions } from './actions.js';
 import { DiscordTransportClient } from './transport-client.js';
@@ -12,6 +13,7 @@ import { buildPromptSectionEstimates, buildContextFiles, buildOpenTasksSection,
 import { mapRuntimeErrorToUserMessage } from './user-errors.js';
 import { resolveModel } from '../runtime/model-tiers.js';
 import { globalMetrics } from '../observability/metrics.js';
+import { globalTraceStore } from '../observability/trace-store.js';
 import { buildPlanForgeAvailabilityNote } from './plan-forge-availability.js';
 const REQUESTER_DENY_ALL = { __requesterDenyAll: true };
 function getThreadParentId(candidate) {
@@ -78,247 +80,332 @@ function buildDeferredActionFlags(state, depth, maxDepth) {
 export function configureDeferredScheduler(opts) {
     const handleDeferredRun = async (run) => {
         const { action, context } = run;
-        const guild = context.guild;
-        if (!guild) {
-            opts.log?.warn({ flow: 'defer', run, action }, 'defer:missing-guild');
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            opts.status?.handlerError({ sessionKey: 'defer' }, 'deferred run skipped: no guild context');
-            return;
-        }
-        const channel = resolveChannel(guild, action.channel);
-        if (!channel) {
-            opts.log?.warn({ flow: 'defer', run, channel: action.channel }, 'defer:target channel not found');
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            opts.status?.handlerError({ sessionKey: `defer:${action.channel}` }, `deferred run skipped: channel "${action.channel}" not found`);
-            return;
-        }
-        if (opts.state.allowChannelIds?.size) {
-            const parentId = getThreadParentId(channel) ?? '';
-            const allowed = opts.state.allowChannelIds.has(channel.id) ||
-                (parentId && opts.state.allowChannelIds.has(parentId));
-            if (!allowed) {
-                opts.log?.warn({ flow: 'defer', channelId: channel.id }, 'defer:target channel not allowlisted');
+        const traceId = `defer_${randomUUID()}`;
+        const sessionKey = `defer:${action.channel}`;
+        let traceOutcome = 'success';
+        globalTraceStore.startTrace(traceId, sessionKey, 'defer', undefined);
+        try {
+            const guild = context.guild;
+            if (!guild) {
+                opts.log?.warn({ flow: 'defer', run, action }, 'defer:missing-guild');
+                traceOutcome = 'error';
+                globalTraceStore.addEvent(traceId, {
+                    type: 'error',
+                    at: Date.now(),
+                    message: 'deferred run skipped: no guild context',
+                    stage: 'defer_setup',
+                });
                 // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                opts.status?.handlerError({ sessionKey: `defer:${channel.id}` }, `deferred run skipped: channel ${channel.id} not in allowlist`);
+                opts.status?.handlerError({ sessionKey: 'defer' }, 'deferred run skipped: no guild context');
                 return;
             }
-        }
-        const threadParentId = getThreadParentId(channel);
-        const requesterMember = await resolveRequesterMember(context);
-        if (isRequesterDenyAll(requesterMember)
-            || (requesterMember && !requesterCanAccessTargetChannel(channel, requesterMember))) {
-            opts.log?.warn({ flow: 'defer', channelId: channel.id, requesterId: context.requesterId }, 'defer:target channel permission denied');
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            opts.status?.handlerError({ sessionKey: `defer:${channel.id}` }, `deferred run skipped: requester lacks permission for channel ${channel.id}`);
-            return;
-        }
-        const channelCtx = resolveDiscordChannelContext({
-            ctx: opts.discordChannelContext,
-            isDm: false,
-            channelId: channel.id,
-            threadParentId,
-        });
-        const paFiles = await loadWorkspacePaFiles(opts.workspaceCwd, { skip: !!opts.appendSystemPrompt });
-        const contextFiles = buildContextFiles(paFiles, opts.discordChannelContext, channelCtx.contextPath);
-        let inlinedContext = {
-            text: '',
-            sections: [],
-        };
-        if (contextFiles.length > 0) {
+            const channel = resolveChannel(guild, action.channel);
+            if (!channel) {
+                opts.log?.warn({ flow: 'defer', run, channel: action.channel }, 'defer:target channel not found');
+                traceOutcome = 'error';
+                globalTraceStore.addEvent(traceId, {
+                    type: 'error',
+                    at: Date.now(),
+                    message: `target channel "${action.channel}" not found`,
+                    stage: 'defer_setup',
+                });
+                // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                opts.status?.handlerError({ sessionKey: `defer:${action.channel}` }, `deferred run skipped: channel "${action.channel}" not found`);
+                return;
+            }
+            if (opts.state.allowChannelIds?.size) {
+                const parentId = getThreadParentId(channel) ?? '';
+                const allowed = opts.state.allowChannelIds.has(channel.id) ||
+                    (parentId && opts.state.allowChannelIds.has(parentId));
+                if (!allowed) {
+                    opts.log?.warn({ flow: 'defer', channelId: channel.id }, 'defer:target channel not allowlisted');
+                    traceOutcome = 'error';
+                    globalTraceStore.addEvent(traceId, {
+                        type: 'error',
+                        at: Date.now(),
+                        message: `target channel "${action.channel}" not allowlisted`,
+                        stage: 'defer_setup',
+                    });
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                    opts.status?.handlerError({ sessionKey: `defer:${channel.id}` }, `deferred run skipped: channel ${channel.id} not in allowlist`);
+                    return;
+                }
+            }
+            const threadParentId = getThreadParentId(channel);
+            const requesterMember = await resolveRequesterMember(context);
+            if (isRequesterDenyAll(requesterMember)
+                || (requesterMember && !requesterCanAccessTargetChannel(channel, requesterMember))) {
+                opts.log?.warn({ flow: 'defer', channelId: channel.id, requesterId: context.requesterId }, 'defer:target channel permission denied');
+                traceOutcome = 'error';
+                globalTraceStore.addEvent(traceId, {
+                    type: 'error',
+                    at: Date.now(),
+                    message: `requester lacks permission for channel ${channel.id}`,
+                    stage: 'defer_setup',
+                });
+                // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                opts.status?.handlerError({ sessionKey: `defer:${channel.id}` }, `deferred run skipped: requester lacks permission for channel ${channel.id}`);
+                return;
+            }
+            const channelCtx = resolveDiscordChannelContext({
+                ctx: opts.discordChannelContext,
+                isDm: false,
+                channelId: channel.id,
+                threadParentId,
+            });
+            const paFiles = await loadWorkspacePaFiles(opts.workspaceCwd, { skip: !!opts.appendSystemPrompt });
+            const contextFiles = buildContextFiles(paFiles, opts.discordChannelContext, channelCtx.contextPath);
+            let inlinedContext = {
+                text: '',
+                sections: [],
+            };
+            if (contextFiles.length > 0) {
+                try {
+                    inlinedContext = await inlineContextFilesWithMeta(contextFiles, {
+                        required: new Set(opts.discordChannelContext?.paContextFiles ?? []),
+                    });
+                }
+                catch (err) {
+                    opts.log?.warn({ flow: 'defer', channelId: channel.id, err }, 'defer:context inline failed');
+                }
+            }
+            const deferDepth = (context.deferDepth ?? 0) + 1;
+            const deferredActionFlags = buildDeferredActionFlags(opts.state, deferDepth, opts.deferMaxDepth);
+            const openTasksSection = buildOpenTasksSection(opts.state.taskCtx?.store);
+            let actionsReferenceSection = '';
+            let actionSchemaSelection = null;
+            if (opts.state.discordActionsEnabled) {
+                const actionSelection = buildTieredDiscordActionsPromptSection(deferredActionFlags, opts.botDisplayName, {
+                    channelName: channelCtx.channelName,
+                    channelContextPath: channelCtx.contextPath,
+                    isThread: threadParentId !== null,
+                    userText: action.prompt,
+                    canvasWriteBridgeEnabled: opts.state.canvasCtx?.writeBridgeEnabled,
+                    imagegenDefaultModel: opts.state.imagegenCtx ? resolveDefaultModel(opts.state.imagegenCtx) : undefined,
+                });
+                actionsReferenceSection = actionSelection.prompt;
+                actionSchemaSelection = {
+                    includedCategories: actionSelection.includedCategories,
+                    tierBuckets: actionSelection.tierBuckets,
+                    keywordHits: actionSelection.keywordHits,
+                };
+            }
+            const promptSectionEstimates = buildPromptSectionEstimates({
+                contextSections: inlinedContext.sections,
+                channelContextPath: channelCtx.contextPath,
+                openTasksSection,
+                actionsReferenceSection,
+            });
+            opts.log?.info({
+                flow: 'defer',
+                channelId: channel.id,
+                sections: promptSectionEstimates.sections,
+                totalChars: promptSectionEstimates.totalChars,
+                totalEstTokens: promptSectionEstimates.totalEstTokens,
+                actionSchemaSelection,
+            }, 'defer:prompt:section-estimates');
+            const noteLines = [];
+            let effectiveTools = opts.runtimeTools;
             try {
-                inlinedContext = await inlineContextFilesWithMeta(contextFiles, {
-                    required: new Set(opts.discordChannelContext?.paContextFiles ?? []),
+                const toolsInfo = await resolveEffectiveTools({
+                    workspaceCwd: opts.workspaceCwd,
+                    runtimeTools: opts.runtimeTools,
+                    runtimeCapabilities: resolveGroundedToolCapabilities(opts.runtime),
+                    runtimeId: opts.runtime.id,
+                    log: opts.log,
                 });
+                effectiveTools = toolsInfo.effectiveTools;
+                if (toolsInfo.permissionNote)
+                    noteLines.push(`Permission note: ${toolsInfo.permissionNote}`);
+                if (toolsInfo.runtimeCapabilityNote)
+                    noteLines.push(`Runtime capability note: ${toolsInfo.runtimeCapabilityNote}`);
             }
             catch (err) {
-                opts.log?.warn({ flow: 'defer', channelId: channel.id, err }, 'defer:context inline failed');
+                opts.log?.warn({ flow: 'defer', channelId: channel.id, err }, 'defer:resolve effective tools failed');
             }
-        }
-        const deferDepth = (context.deferDepth ?? 0) + 1;
-        const deferredActionFlags = buildDeferredActionFlags(opts.state, deferDepth, opts.deferMaxDepth);
-        const openTasksSection = buildOpenTasksSection(opts.state.taskCtx?.store);
-        let actionsReferenceSection = '';
-        let actionSchemaSelection = null;
-        if (opts.state.discordActionsEnabled) {
-            const actionSelection = buildTieredDiscordActionsPromptSection(deferredActionFlags, opts.botDisplayName, {
-                channelName: channelCtx.channelName,
-                channelContextPath: channelCtx.contextPath,
-                isThread: threadParentId !== null,
-                userText: action.prompt,
-                canvasWriteBridgeEnabled: opts.state.canvasCtx?.writeBridgeEnabled,
-                imagegenDefaultModel: opts.state.imagegenCtx ? resolveDefaultModel(opts.state.imagegenCtx) : undefined,
+            const planForgeAvailabilityNote = buildPlanForgeAvailabilityNote({
+                planCommandsEnabled: opts.state.planCommandsEnabled !== false,
+                forgeCommandsEnabled: opts.state.forgeCommandsEnabled !== false,
+                planActionsEnabled: Boolean(opts.state.discordActionsPlan),
+                forgeActionsEnabled: Boolean(opts.state.discordActionsForge),
             });
-            actionsReferenceSection = actionSelection.prompt;
-            actionSchemaSelection = {
-                includedCategories: actionSelection.includedCategories,
-                tierBuckets: actionSelection.tierBuckets,
-                keywordHits: actionSelection.keywordHits,
-            };
-        }
-        const promptSectionEstimates = buildPromptSectionEstimates({
-            contextSections: inlinedContext.sections,
-            channelContextPath: channelCtx.contextPath,
-            openTasksSection,
-            actionsReferenceSection,
-        });
-        opts.log?.info({
-            flow: 'defer',
-            channelId: channel.id,
-            sections: promptSectionEstimates.sections,
-            totalChars: promptSectionEstimates.totalChars,
-            totalEstTokens: promptSectionEstimates.totalEstTokens,
-            actionSchemaSelection,
-        }, 'defer:prompt:section-estimates');
-        const noteLines = [];
-        let effectiveTools = opts.runtimeTools;
-        try {
-            const toolsInfo = await resolveEffectiveTools({
-                workspaceCwd: opts.workspaceCwd,
-                runtimeTools: opts.runtimeTools,
-                runtimeCapabilities: resolveGroundedToolCapabilities(opts.runtime),
+            if (planForgeAvailabilityNote)
+                noteLines.push(`Runtime capability note: ${planForgeAvailabilityNote}`);
+            const prompt = buildScheduledSelfInvocationPrompt({
+                inlinedContext: inlinedContext.text,
+                openTasksSection,
+                actionsReferenceSection,
+                noteLines,
                 runtimeId: opts.runtime.id,
-                log: opts.log,
+                runtimeCapabilities: opts.runtime.capabilities,
+                runtimeTools: opts.runtimeTools,
+                enableHybridPipeline: opts.state.enableHybridPipeline,
+                invocationNotice: `Deferred follow-up scheduled for <#${channel.id}> (runs at ${fmtTime(run.runsAt)}).`,
+                userMessage: action.prompt,
             });
-            effectiveTools = toolsInfo.effectiveTools;
-            if (toolsInfo.permissionNote)
-                noteLines.push(`Permission note: ${toolsInfo.permissionNote}`);
-            if (toolsInfo.runtimeCapabilityNote)
-                noteLines.push(`Runtime capability note: ${toolsInfo.runtimeCapabilityNote}`);
-        }
-        catch (err) {
-            opts.log?.warn({ flow: 'defer', channelId: channel.id, err }, 'defer:resolve effective tools failed');
-        }
-        const planForgeAvailabilityNote = buildPlanForgeAvailabilityNote({
-            planCommandsEnabled: opts.state.planCommandsEnabled !== false,
-            forgeCommandsEnabled: opts.state.forgeCommandsEnabled !== false,
-            planActionsEnabled: Boolean(opts.state.discordActionsPlan),
-            forgeActionsEnabled: Boolean(opts.state.discordActionsForge),
-        });
-        if (planForgeAvailabilityNote)
-            noteLines.push(`Runtime capability note: ${planForgeAvailabilityNote}`);
-        const prompt = buildScheduledSelfInvocationPrompt({
-            inlinedContext: inlinedContext.text,
-            openTasksSection,
-            actionsReferenceSection,
-            noteLines,
-            runtimeId: opts.runtime.id,
-            runtimeCapabilities: opts.runtime.capabilities,
-            runtimeTools: opts.runtimeTools,
-            enableHybridPipeline: opts.state.enableHybridPipeline,
-            invocationNotice: `Deferred follow-up scheduled for <#${channel.id}> (runs at ${fmtTime(run.runsAt)}).`,
-            userMessage: action.prompt,
-        });
-        const addDirs = [];
-        if (opts.useGroupDirCwd)
-            addDirs.push(opts.workspaceCwd);
-        if (opts.discordChannelContext)
-            addDirs.push(opts.discordChannelContext.contentDir);
-        const uniqueAddDirs = addDirs.length > 0 ? Array.from(new Set(addDirs)) : undefined;
-        const t0 = Date.now();
-        globalMetrics.recordInvokeStart('defer');
-        opts.log?.info({ flow: 'defer', channelId: channel.id }, 'obs.invoke.start');
-        let finalText = '';
-        let deltaText = '';
-        let runtimeError;
-        let invokeResultRecorded = false;
-        try {
-            for await (const evt of opts.runtime.invoke({
-                prompt,
-                model: resolveModel(opts.state.runtimeModel, opts.runtime.id),
-                cwd: opts.workspaceCwd,
-                addDirs: uniqueAddDirs,
-                tools: effectiveTools,
-                timeoutMs: opts.runtimeTimeoutMs,
-            })) {
-                if (evt.type === 'text_final') {
-                    finalText = evt.text;
-                }
-                else if (evt.type === 'text_delta') {
-                    deltaText += evt.text;
+            const addDirs = [];
+            if (opts.useGroupDirCwd)
+                addDirs.push(opts.workspaceCwd);
+            if (opts.discordChannelContext)
+                addDirs.push(opts.discordChannelContext.contentDir);
+            const uniqueAddDirs = addDirs.length > 0 ? Array.from(new Set(addDirs)) : undefined;
+            const t0 = Date.now();
+            globalMetrics.recordInvokeStart('defer');
+            globalTraceStore.addEvent(traceId, {
+                type: 'invoke_start',
+                at: t0,
+                summary: `deferred run for <#${channel.id}>`,
+                promptPreview: action.prompt.slice(0, 220),
+            });
+            opts.log?.info({ flow: 'defer', channelId: channel.id }, 'obs.invoke.start');
+            let finalText = '';
+            let deltaText = '';
+            let runtimeError;
+            let invokeResultRecorded = false;
+            try {
+                for await (const evt of opts.runtime.invoke({
+                    prompt,
+                    model: resolveModel(opts.state.runtimeModel, opts.runtime.id),
+                    cwd: opts.workspaceCwd,
+                    addDirs: uniqueAddDirs,
+                    tools: effectiveTools,
+                    timeoutMs: opts.runtimeTimeoutMs,
+                })) {
+                    if (evt.type === 'text_final') {
+                        finalText = evt.text;
+                    }
+                    else if (evt.type === 'text_delta') {
+                        deltaText += evt.text;
+                    }
+                    else if (evt.type === 'error') {
+                        runtimeError = evt.message;
+                        finalText = mapRuntimeErrorToUserMessage(evt.message);
+                        traceOutcome = 'error';
+                        globalTraceStore.addEvent(traceId, {
+                            type: 'error',
+                            at: Date.now(),
+                            message: evt.message,
+                            stage: 'runtime',
+                        });
+                        globalMetrics.recordInvokeResult('defer', Date.now() - t0, false, evt.message);
+                        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                        opts.status?.runtimeError({ sessionKey: `defer:${channel.id}` }, evt.message);
+                        opts.log?.warn({ flow: 'defer', channelId: channel.id, error: evt.message }, 'obs.invoke.error');
+                        invokeResultRecorded = true;
+                        break;
+                    }
                 }
-                else if (evt.type === 'error') {
-                    runtimeError = evt.message;
-                    finalText = mapRuntimeErrorToUserMessage(evt.message);
-                    globalMetrics.recordInvokeResult('defer', Date.now() - t0, false, evt.message);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                runtimeError ??= msg;
+                finalText = mapRuntimeErrorToUserMessage(msg);
+                traceOutcome = 'error';
+                globalTraceStore.addEvent(traceId, {
+                    type: 'error',
+                    at: Date.now(),
+                    message: msg,
+                    name: err instanceof Error ? err.name : undefined,
+                    stage: 'runtime',
+                    stack: err instanceof Error ? err.stack?.slice(0, 400) : undefined,
+                });
+                if (!invokeResultRecorded) {
+                    globalMetrics.recordInvokeResult('defer', Date.now() - t0, false, msg);
                     // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                    opts.status?.runtimeError({ sessionKey: `defer:${channel.id}` }, evt.message);
-                    opts.log?.warn({ flow: 'defer', channelId: channel.id, error: evt.message }, 'obs.invoke.error');
+                    opts.status?.runtimeError({ sessionKey: `defer:${channel.id}` }, msg);
                     invokeResultRecorded = true;
-                    break;
                 }
+                opts.log?.warn({ flow: 'defer', channelId: channel.id, err }, 'defer:runtime invocation failed');
             }
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            runtimeError ??= msg;
-            finalText = mapRuntimeErrorToUserMessage(msg);
             if (!invokeResultRecorded) {
-                globalMetrics.recordInvokeResult('defer', Date.now() - t0, false, msg);
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                opts.status?.runtimeError({ sessionKey: `defer:${channel.id}` }, msg);
-                invokeResultRecorded = true;
+                globalTraceStore.addEvent(traceId, {
+                    type: 'invoke_end',
+                    at: Date.now(),
+                    ok: true,
+                    summary: `completed in ${Date.now() - t0}ms`,
+                });
+                globalMetrics.recordInvokeResult('defer', Date.now() - t0, true);
+                opts.log?.info({ flow: 'defer', channelId: channel.id, ms: Date.now() - t0, ok: true }, 'obs.invoke.end');
             }
-            opts.log?.warn({ flow: 'defer', channelId: channel.id, err }, 'defer:runtime invocation failed');
-        }
-        if (!invokeResultRecorded) {
-            globalMetrics.recordInvokeResult('defer', Date.now() - t0, true);
-            opts.log?.info({ flow: 'defer', channelId: channel.id, ms: Date.now() - t0, ok: true }, 'obs.invoke.end');
-        }
-        const processedText = finalText || deltaText || '';
-        const parsed = parseDiscordActions(processedText, deferredActionFlags);
-        const actCtx = {
-            guild,
-            client: context.client,
-            channelId: channel.id,
-            messageId: `defer-${Date.now()}`,
-            requesterId: context.requesterId,
-            threadParentId,
-            deferScheduler: context.deferScheduler,
-            deferDepth,
-            transport: new DiscordTransportClient(guild, context.client),
-            confirmation: {
-                mode: 'automated',
-            },
-        };
-        let actionResults = [];
-        if (parsed.actions.length > 0) {
-            actionResults = await executeDiscordActions(parsed.actions, actCtx, opts.log, {
-                taskCtx: opts.state.taskCtx,
-                cronCtx: opts.state.cronCtx,
-                forgeCtx: opts.state.forgeCtx,
-                planCtx: opts.state.planCtx,
-                memoryCtx: opts.state.memoryCtx,
-                configCtx: opts.state.configCtx,
-                canvasCtx: opts.state.canvasCtx,
-                imagegenCtx: opts.state.imagegenCtx,
-                voiceCtx: opts.state.voiceCtx,
-                spawnCtx: opts.state.spawnCtx,
-            });
-            for (let i = 0; i < actionResults.length; i++) {
-                const result = actionResults[i];
-                globalMetrics.recordActionResult(result.ok);
-                opts.log?.info({ flow: 'defer', channelId: channel.id, ok: result.ok }, 'obs.action.result');
-                if (!result.ok) {
-                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                    opts.status?.actionFailed(parsed.actions[i].type, result.error);
+            const processedText = finalText || deltaText || '';
+            const parsed = parseDiscordActions(processedText, deferredActionFlags);
+            const actCtx = {
+                guild,
+                client: context.client,
+                channelId: channel.id,
+                messageId: `defer-${Date.now()}`,
+                requesterId: context.requesterId,
+                threadParentId,
+                deferScheduler: context.deferScheduler,
+                deferDepth,
+                transport: new DiscordTransportClient(guild, context.client),
+                confirmation: {
+                    mode: 'automated',
+                },
+            };
+            let actionResults = [];
+            if (parsed.actions.length > 0) {
+                actionResults = await executeDiscordActions(parsed.actions, actCtx, opts.log, {
+                    taskCtx: opts.state.taskCtx,
+                    cronCtx: opts.state.cronCtx,
+                    forgeCtx: opts.state.forgeCtx,
+                    planCtx: opts.state.planCtx,
+                    memoryCtx: opts.state.memoryCtx,
+                    configCtx: opts.state.configCtx,
+                    canvasCtx: opts.state.canvasCtx,
+                    imagegenCtx: opts.state.imagegenCtx,
+                    voiceCtx: opts.state.voiceCtx,
+                    spawnCtx: opts.state.spawnCtx,
+                });
+                for (let i = 0; i < actionResults.length; i++) {
+                    const result = actionResults[i];
+                    globalMetrics.recordActionResult(result.ok);
+                    globalTraceStore.addEvent(traceId, {
+                        type: 'action_result',
+                        at: Date.now(),
+                        action: parsed.actions[i].type,
+                        ok: result.ok,
+                        detail: result.ok ? undefined : ('error' in result ? result.error : undefined),
+                    });
+                    opts.log?.info({ flow: 'defer', channelId: channel.id, ok: result.ok }, 'obs.action.result');
+                    if (!result.ok) {
+                        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                        opts.status?.actionFailed(parsed.actions[i].type, result.error);
+                    }
                 }
             }
-        }
-        let outgoingText = appendActionResults(parsed.cleanText.trim(), parsed.actions, actionResults);
-        outgoingText = appendUnavailableActionTypesNotice(outgoingText, parsed.strippedUnrecognizedTypes).trim();
-        outgoingText = appendParseFailureNotice(outgoingText, parsed.parseFailures).trim();
-        if (!outgoingText && runtimeError) {
-            outgoingText = runtimeError;
-        }
-        if (!outgoingText) {
-            opts.log?.warn({ flow: 'defer', channelId: channel.id }, 'defer:empty output, nothing to send');
-            return;
-        }
-        try {
-            await channel.send({ content: outgoingText, allowedMentions: NO_MENTIONS });
+            let outgoingText = appendActionResults(parsed.cleanText.trim(), parsed.actions, actionResults);
+            outgoingText = appendUnavailableActionTypesNotice(outgoingText, parsed.strippedUnrecognizedTypes).trim();
+            outgoingText = appendParseFailureNotice(outgoingText, parsed.parseFailures).trim();
+            if (!outgoingText && runtimeError) {
+                outgoingText = runtimeError;
+            }
+            if (!outgoingText) {
+                opts.log?.warn({ flow: 'defer', channelId: channel.id }, 'defer:empty output, nothing to send');
+                return;
+            }
+            try {
+                await channel.send({ content: outgoingText, allowedMentions: NO_MENTIONS });
+            }
+            catch (err) {
+                opts.log?.warn({ flow: 'defer', channelId: channel.id, err }, 'defer:failed to post follow-up');
+            }
         }
         catch (err) {
-            opts.log?.warn({ flow: 'defer', channelId: channel.id, err }, 'defer:failed to post follow-up');
+            const msg = err instanceof Error ? err.message : String(err);
+            traceOutcome = 'error';
+            globalTraceStore.addEvent(traceId, {
+                type: 'error',
+                at: Date.now(),
+                message: msg,
+                name: err instanceof Error ? err.name : undefined,
+                stage: 'defer_flow',
+                stack: err instanceof Error ? err.stack?.slice(0, 400) : undefined,
+            });
+            opts.log?.error({ flow: 'defer', err }, 'defer:handler failed');
+        }
+        finally {
+            globalTraceStore.endTrace(traceId, traceOutcome);
         }
     };
     const deferScheduler = new DeferSchedulerImpl({

package/dist/discord/help-command.js

@@ -23,7 +23,7 @@ export function handleHelpCommand() {
         '- `!update` — check for or apply code updates; `!update help` for details',
         '- `!restart` — restart the discoclaw service; `!restart help` for details',
         '- `!stop` — abort all active AI streams and cancel any running forge',
-        '- `!voice status` — show voice subsystem status (STT/TTS providers, connections)',
+        '- `!voice status` — show Gemini Live voice status and active connections',
         '- `!help` — this message',
     ].join('\n');
 }