@nordbyte/nordrelay 0.5.2 → 0.7.0

package/dist/bot.js

@@ -11,6 +11,8 @@ import { AuditLogStore } from "./audit-log.js";
 import { formatSessionLabel } from "./bot-ui.js";
 import { BotPreferencesStore, isQuietNow, } from "./bot-preferences.js";
 import { renderAgentUpdateJobAction } from "./channel-actions.js";
+import { ChannelCommandService } from "./channel-command-service.js";
+import { runChannelPeerPrompt } from "./channel-peer-prompt.js";
 import { deliverChannelAction } from "./channel-runtime.js";
 import { agentLabel, agentReasoningLabel, agentReasoningOptions, } from "./agent.js";
 import { getExternalActivityForSession, getExternalSnapshotForSession, } from "./agent-activity.js";
@@ -23,6 +25,7 @@ import { escapeHTML } from "./format.js";
 import { PromptStore, toPromptEnvelope } from "./prompt-store.js";
 import { checkHermesAuthStatus, startHermesLogin, startHermesLogout } from "./hermes-auth.js";
 import { checkOpenClawAuthStatus } from "./openclaw-auth.js";
+import { RemoteRelayClient } from "./peer-client.js";
 import { checkPiAuthStatus } from "./pi-auth.js";
 import { configureRedaction, redactText } from "./redaction.js";
 import { canWriteWithLock, SessionLockStore } from "./session-locks.js";
@@ -45,6 +48,7 @@ import { registerTelegramSupportCommands } from "./telegram-support-command.js";
 import { registerTelegramUpdateCommands } from "./telegram-update-commands.js";
 import { appendWithCap, authHelpText, buildStreamingPreview, capabilitiesOf, filterSessions, formatAgentLaunchProfileLabel, formatAgentSettingScope, formatDurationSeconds, formatError, formatLocalDateTime, formatLockOwner, formatModelButtonLabel, formatRelativeTime, formatTelegramName, formatToolSummaryLine, formatTurnUsageLine, getWorkspaceShortName, idOf, isEmptyArtifactReport, isPromptEnvelopeLike, isQueuedPromptLike, labelOf, orderPinnedSessions, parseFastModeArgument, renderExternalMirrorEvent, renderExternalMirrorStatus, renderPromptFailure, renderTodoList, renderToolEndMessage, renderToolStartMessage, requiresTurnApproval, trimLine, } from "./bot-rendering.js";
 import { UserStore } from "./user-management.js";
+import { WebActivityStore } from "./web-state.js";
 import { evaluateWorkspacePolicy, filterAllowedWorkspaces, renderWorkspacePolicyLine, } from "./workspace-policy.js";
 export { formatToolSummaryLine, formatTurnUsageLine, summarizeToolName } from "./bot-rendering.js";
 export { registerCommands } from "./telegram-command-menu.js";
@@ -54,6 +58,10 @@ const TOOL_OUTPUT_PREVIEW_LIMIT = 500;
 const MAX_AUDIO_FILE_SIZE = 25 * 1024 * 1024;
 const MEDIA_GROUP_FLUSH_MS = 1200;
 const LAUNCH_PROFILES_COMMAND = "/launch_profiles";
+const CLI_ACTIVITY_ACTOR = {
+    channel: "cli",
+    label: "CLI",
+};
 export function createBot(config, registry) {
     configureRedaction(config.telegramRedactPatterns);
     telegramRateLimiter.configure({
@@ -80,11 +88,17 @@ export function createBot(config, registry) {
     const turnProgress = new Map();
     const promptStore = new PromptStore(config.workspace, config.stateBackend);
     const preferencesStore = new BotPreferencesStore(config.workspace, config.stateBackend);
+    const activityStore = new WebActivityStore(config.workspace, config.stateBackend, config.auditMaxEvents);
     const auditLog = new AuditLogStore(config.workspace, config.stateBackend, config.auditMaxEvents);
     const lockStore = new SessionLockStore(config.workspace, config.stateBackend);
     const userStore = new UserStore();
     const contextUsers = new WeakMap();
-    const agentUpdates = new AgentUpdateManager();
+    const agentUpdateActors = new Map();
+    const agentUpdateStates = new Map();
+    const commandService = new ChannelCommandService(config);
+    const agentUpdates = new AgentUpdateManager({
+        onUpdate: (job) => recordTelegramAgentUpdateLifecycle(job),
+    });
     const linkAttempts = new Map();
     const drainingQueues = new Set();
     const externalQueueTimers = new Map();
@@ -228,6 +242,19 @@ export function createBot(config, registry) {
     const startTelegramAgentUpdate = async (ctx, agentId, operation = "update") => {
         try {
             const job = agentUpdates.start(agentId, agentUpdateContext(), operation);
+            const actor = telegramActivityActor(ctx);
+            agentUpdateActors.set(job.id, actor);
+            agentUpdateStates.set(job.id, { status: job.status, needsInput: job.needsInput });
+            appendActivity({
+                source: "telegram",
+                status: "info",
+                type: operation === "install" ? "agent_install_started" : "agent_update_started",
+                threadId: null,
+                workspace: config.workspace,
+                agentId,
+                actor,
+                detail: `${job.method}: ${job.summary}`,
+            });
             const contextKey = contextKeyFromCtx(ctx);
             if (contextKey) {
                 audit({
@@ -235,6 +262,9 @@ export function createBot(config, registry) {
                     status: "ok",
                     contextKey,
                     agentId,
+                    actor,
+                    actorId: getAuthenticatedUser(ctx)?.user.id ?? ctx.from?.id,
+                    actorRole: getUserRole(ctx),
                     description: `${operation} ${agentId}`,
                     detail: job.summary,
                 });
@@ -495,6 +525,26 @@ export function createBot(config, registry) {
         if (snapshot.activity.active) {
             state.turnId = snapshot.activity.turnId;
             state.startedAt = snapshot.activity.startedAt;
+            const turnKey = snapshot.activity.turnId ?? snapshot.activity.startedAt?.toISOString() ?? "unknown";
+            if (state.activityStartedTurnKey !== turnKey) {
+                const info = session.getInfo();
+                appendActivity({
+                    source: "cli",
+                    status: "running",
+                    type: "cli_turn_started",
+                    contextKey,
+                    threadId: snapshot.threadId,
+                    workspace: info.workspace,
+                    agentId: info.agentId,
+                    actor: CLI_ACTIVITY_ACTOR,
+                    prompt: snapshot.latestUserMessage ?? `${snapshot.agentLabel} CLI task`,
+                    detail: `${snapshot.sourceLabel}: ${snapshot.sourcePath}`,
+                });
+                state.activityStartedTurnKey = turnKey;
+                state.activityFinishedTurnKey = undefined;
+                state.activityToolStartLines = [];
+                state.activityToolEndLines = [];
+            }
             if (mirrorMode !== "off") {
                 await sendExternalMirrorTyping(chatId, parsed.messageThreadId, state);
             }
@@ -542,6 +592,43 @@ export function createBot(config, registry) {
                     state.latestMirroredEventLine = event.lineNumber;
                 }
             }
+            const info = session.getInfo();
+            const loggedStartLines = new Set(state.activityToolStartLines ?? []);
+            const loggedEndLines = new Set(state.activityToolEndLines ?? []);
+            for (const event of snapshot.events.filter((event) => event.lineNumber > state.lastLine && event.kind === "tool")) {
+                if (event.status === "started" && !loggedStartLines.has(event.lineNumber)) {
+                    appendActivity({
+                        source: "cli",
+                        status: "running",
+                        type: "cli_tool_started",
+                        contextKey,
+                        threadId: snapshot.threadId,
+                        workspace: info.workspace,
+                        agentId: info.agentId,
+                        actor: CLI_ACTIVITY_ACTOR,
+                        prompt: snapshot.latestUserMessage ?? undefined,
+                        detail: event.toolName ?? "tool",
+                    });
+                    loggedStartLines.add(event.lineNumber);
+                }
+                if ((event.status === "finished" || event.status === "failed") && !loggedEndLines.has(event.lineNumber)) {
+                    appendActivity({
+                        source: "cli",
+                        status: event.status === "failed" ? "failed" : "completed",
+                        type: event.status === "failed" ? "cli_tool_failed" : "cli_tool_completed",
+                        contextKey,
+                        threadId: snapshot.threadId,
+                        workspace: info.workspace,
+                        agentId: info.agentId,
+                        actor: CLI_ACTIVITY_ACTOR,
+                        prompt: snapshot.latestUserMessage ?? undefined,
+                        detail: event.toolName ?? "tool",
+                    });
+                    loggedEndLines.add(event.lineNumber);
+                }
+            }
+            state.activityToolStartLines = [...loggedStartLines].slice(-200);
+            state.activityToolEndLines = [...loggedEndLines].slice(-200);
             state.lastLine = Math.max(state.lastLine, snapshot.lineCount);
             return;
         }
@@ -551,6 +638,25 @@ export function createBot(config, registry) {
         }
         const terminalEvent = [...snapshot.events].reverse().find((event) => event.kind === "task" && event.status && event.status !== "started");
         if (terminalEvent) {
+            const turnKey = terminalEvent.turnId ?? snapshot.activity.turnId ?? state.startedAt?.toString() ?? "unknown";
+            if (state.activityFinishedTurnKey !== turnKey) {
+                const info = session.getInfo();
+                const startedAt = state.startedAt instanceof Date ? state.startedAt : state.startedAt ? new Date(state.startedAt) : snapshot.activity.startedAt;
+                appendActivity({
+                    source: "cli",
+                    status: terminalEvent.status === "aborted" ? "aborted" : terminalEvent.status === "failed" ? "failed" : "completed",
+                    type: "cli_turn_finished",
+                    contextKey,
+                    threadId: snapshot.threadId,
+                    workspace: info.workspace,
+                    agentId: info.agentId,
+                    actor: CLI_ACTIVITY_ACTOR,
+                    prompt: snapshot.latestUserMessage ?? undefined,
+                    detail: `${snapshot.agentLabel} CLI task ${terminalEvent.status ?? "finished"}.`,
+                    durationMs: startedAt && terminalEvent.timestamp ? Math.max(0, terminalEvent.timestamp.getTime() - startedAt.getTime()) : undefined,
+                });
+                state.activityFinishedTurnKey = turnKey;
+            }
             if (mirrorMode !== "off") {
                 const doneText = `${snapshot.agentLabel} CLI task ${terminalEvent.status}.`;
                 if (state.statusMessageId) {
@@ -637,6 +743,18 @@ export function createBot(config, registry) {
         for (const artifact of (persistedReport?.artifacts ?? report.artifacts)) {
             await sendArtifactFileByApi(bot.api, chatId, artifact, messageThreadId);
         }
+        const info = session.getInfo();
+        appendActivity({
+            source: "cli",
+            status: "info",
+            type: "artifacts_sent",
+            contextKey,
+            threadId: info.threadId,
+            workspace: info.workspace,
+            agentId: info.agentId,
+            actor: CLI_ACTIVITY_ACTOR,
+            detail: summary,
+        });
         if (state)
             state.artifactsDeliveredForTurnId = turnId;
     };
@@ -688,9 +806,11 @@ export function createBot(config, registry) {
     };
     const auditContext = (ctx, contextKey, session, patch) => {
         const info = session.getInfo();
+        const authUser = getAuthenticatedUser(ctx);
         audit({
             contextKey,
-            actorId: ctx.from?.id,
+            actor: telegramActivityActor(ctx),
+            actorId: authUser?.user.id ?? ctx.from?.id,
             actorRole: getUserRole(ctx),
             agentId: idOf(info),
             threadId: info.threadId,
@@ -698,10 +818,68 @@ export function createBot(config, registry) {
             ...patch,
         });
     };
+    function telegramActivityActor(ctx) {
+        const user = ctx.from;
+        const authUser = getAuthenticatedUser(ctx);
+        const label = authUser?.user.displayName || formatTelegramName(ctx) || user?.username || (user?.id ? String(user.id) : "Telegram user");
+        return {
+            channel: "telegram",
+            id: authUser?.user.id ?? (user?.id !== undefined ? `telegram:${user.id}` : undefined),
+            label,
+            username: authUser?.user.email ?? user?.username,
+            channelUserId: user?.id !== undefined ? String(user.id) : undefined,
+        };
+    }
+    function appendActivity(input) {
+        return activityStore.append(input);
+    }
+    function appendTelegramActivity(ctx, contextKey, session, input) {
+        const info = session.getInfo();
+        return appendActivity({
+            source: "telegram",
+            contextKey,
+            ...input,
+            threadId: input.threadId ?? info.threadId,
+            workspace: input.workspace ?? info.workspace,
+            agentId: input.agentId ?? idOf(info),
+            actor: input.actor ?? telegramActivityActor(ctx),
+        });
+    }
+    function recordTelegramAgentUpdateLifecycle(job) {
+        const previous = agentUpdateStates.get(job.id);
+        const actor = agentUpdateActors.get(job.id);
+        if (job.needsInput && !previous?.needsInput) {
+            appendActivity({
+                source: "telegram",
+                status: "info",
+                type: "agent_update_input_required",
+                threadId: null,
+                workspace: config.workspace,
+                agentId: job.agentId,
+                actor,
+                detail: `${job.agentLabel} ${job.operation} may require input.`,
+            });
+        }
+        if (job.status !== "running" && previous?.status === "running") {
+            appendActivity({
+                source: "telegram",
+                status: job.status === "completed" ? "completed" : job.status === "cancelled" ? "aborted" : "failed",
+                type: job.operation === "install" ? `agent_install_${job.status}` : `agent_update_${job.status}`,
+                threadId: null,
+                workspace: config.workspace,
+                agentId: job.agentId,
+                actor,
+                detail: job.error ?? `${job.agentLabel} ${job.operation} ${job.status}.`,
+                durationMs: Math.max(0, Date.parse(job.finishedAt ?? job.updatedAt) - Date.parse(job.startedAt)),
+            });
+            agentUpdateActors.delete(job.id);
+        }
+        agentUpdateStates.set(job.id, { status: job.status, needsInput: job.needsInput });
+    }
     const denyIfLocked = async (ctx, contextKey, session) => {
         const lock = lockStore.get(contextKey);
         const isAdmin = isAdminUser(ctx);
-        if (canWriteWithLock(lock, ctx.from?.id, isAdmin)) {
+        if (canWriteWithLock(lock, getAuthenticatedUser(ctx)?.user.id, isAdmin)) {
             return false;
         }
         const owner = formatLockOwner(lock);
@@ -711,6 +889,11 @@ export function createBot(config, registry) {
             status: "denied",
             detail: text,
         });
+        appendTelegramActivity(ctx, contextKey, session, {
+            status: "failed",
+            type: "lock_denied",
+            detail: text,
+        });
         await safeReply(ctx, escapeHTML(text), { fallbackText: text });
         return true;
     };
@@ -803,13 +986,90 @@ export function createBot(config, registry) {
         ].join("\n");
         await safeReply(ctx, html, { fallbackText: plain, replyMarkup: keyboard });
     };
+    const remoteClient = new RemoteRelayClient();
+    const handleRemoteUserPrompt = async (ctx, contextKey, chatId, prompt) => {
+        const targetPeerId = preferencesStore.get(contextKey).targetPeerId ?? undefined;
+        const parsed = parseContextKey(contextKey);
+        const messageThreadId = parsed.messageThreadId;
+        return runChannelPeerPrompt({
+            targetPeerId,
+            contextKey,
+            prompt,
+            remoteClient,
+            editMinIntervalMs: config.telegramEditMinIntervalMs,
+            typingIntervalMs: TYPING_INTERVAL_MS,
+            sendTyping: () => sendChatActionSafe(ctx.api, chatId, "typing", messageThreadId),
+            sendResponse: async (text) => {
+                const message = await sendTextMessage(ctx.api, chatId, escapeHTML(text), {
+                    fallbackText: text,
+                    messageThreadId,
+                });
+                return message.message_id;
+            },
+            editResponse: (messageId, text) => safeEditMessage(bot, chatId, messageId, escapeHTML(text), {
+                fallbackText: text,
+            }),
+            sendTurnStart: (remotePrompt) => safeReply(ctx, `<b>Remote peer working on:</b>\n${escapeHTML(remotePrompt)}`, {
+                fallbackText: `Remote peer working on:\n${remotePrompt}`,
+            }),
+            sendToolStart: (toolName) => safeReply(ctx, `<b>Remote tool:</b> <code>${escapeHTML(toolName)}</code>`, {
+                fallbackText: `Remote tool: ${toolName}`,
+            }),
+            sendQueued: async (queueId) => {
+                const keyboard = queueId ? new InlineKeyboard().text("Cancel queued message", `peer_queue_cancel:${targetPeerId}:${queueId}`) : undefined;
+                await safeReply(ctx, escapeHTML(`Remote prompt queued${queueId ? `: ${queueId}` : ""}.`), {
+                    fallbackText: `Remote prompt queued${queueId ? `: ${queueId}` : ""}.`,
+                    replyMarkup: keyboard,
+                });
+            },
+            sendCompleted: () => safeReply(ctx, escapeHTML("Remote turn completed."), { fallbackText: "Remote turn completed." }),
+            sendFailure: (message) => safeReply(ctx, escapeHTML(`Remote peer failed: ${message}`), {
+                fallbackText: `Remote peer failed: ${message}`,
+            }),
+        });
+    };
+    bot.callbackQuery(/^peer_queue_cancel:([^:]+):([a-z0-9]+)$/, async (ctx) => {
+        const targetPeerId = ctx.match?.[1];
+        const queueId = ctx.match?.[2];
+        const contextKey = contextKeyFromCtx(ctx);
+        if (!targetPeerId || !queueId || !contextKey) {
+            await ctx.answerCallbackQuery();
+            return;
+        }
+        try {
+            await remoteClient.webProxy(targetPeerId, {
+                method: "POST",
+                path: "/api/queue",
+                body: { action: "cancel", id: queueId },
+                contextKey,
+            }, telegramActivityActor(ctx), contextKey);
+            await ctx.answerCallbackQuery({ text: `Cancelled remote queued prompt ${queueId}.` });
+            const chatId = ctx.chat?.id;
+            const messageId = ctx.callbackQuery.message?.message_id;
+            if (chatId && messageId) {
+                await safeEditMessage(bot, chatId, messageId, escapeHTML(`Cancelled remote queued prompt ${queueId}.`), {
+                    fallbackText: `Cancelled remote queued prompt ${queueId}.`,
+                });
+            }
+        }
+        catch (error) {
+            await ctx.answerCallbackQuery({ text: friendlyErrorText(error), show_alert: true });
+        }
+    });
     const handleUserPrompt = async (ctx, contextKey, chatId, session, prompt, options = {}) => {
         if (!canSendSystemMessagesToContext(contextKey)) {
             return;
         }
         const parsed = parseContextKey(contextKey);
         const messageThreadId = parsed.messageThreadId;
-        const envelope = isPromptEnvelopeLike(prompt) ? prompt : toPromptEnvelope(prompt);
+        const rawEnvelope = isPromptEnvelopeLike(prompt) ? prompt : toPromptEnvelope(prompt);
+        const envelope = {
+            ...rawEnvelope,
+            activityActor: rawEnvelope.activityActor ?? telegramActivityActor(ctx),
+        };
+        if (!options.fromQueue && await handleRemoteUserPrompt(ctx, contextKey, chatId, envelope)) {
+            return;
+        }
         if (!options.fromQueue && await denyIfLocked(ctx, contextKey, session)) {
             return;
         }
@@ -840,6 +1100,13 @@ export function createBot(config, registry) {
                 description: item.description,
                 detail: busy.kind,
             });
+            appendTelegramActivity(ctx, contextKey, session, {
+                status: "queued",
+                type: "prompt_queued",
+                prompt: item.description,
+                detail: `Queued prompt ${item.id} at position ${position}; busy=${busy.kind}`,
+                actor: envelope.activityActor,
+            });
             if (busy.kind === "external") {
                 scheduleExternalQueueDrain(ctx, contextKey, chatId, session);
             }
@@ -877,6 +1144,9 @@ export function createBot(config, registry) {
         let lastRenderedPlan = "";
         let planMessageSending = false;
         let lastTurnUsage;
+        let promptStartedAt;
+        const toolActivityNames = new Map();
+        const toolActivityStartedAt = new Map();
         const typingInterval = setInterval(() => {
             void sendChatActionSafe(bot.api, chatId, "typing", messageThreadId).catch(() => { });
         }, TYPING_INTERVAL_MS);
@@ -1080,6 +1350,15 @@ export function createBot(config, registry) {
                 progress.lastTool = toolName;
                 progress.updatedAt = Date.now();
                 progress.toolCounts.set(toolName, (progress.toolCounts.get(toolName) ?? 0) + 1);
+                toolActivityNames.set(toolCallId, toolName);
+                toolActivityStartedAt.set(toolCallId, Date.now());
+                appendTelegramActivity(ctx, contextKey, session, {
+                    status: "running",
+                    type: "tool_started",
+                    prompt: envelope.description,
+                    detail: toolName,
+                    actor: envelope.activityActor,
+                });
                 if (toolVerbosity === "summary") {
                     toolCounts.set(toolName, (toolCounts.get(toolName) ?? 0) + 1);
                     return;
@@ -1127,6 +1406,18 @@ export function createBot(config, registry) {
             onToolEnd: (toolCallId, isError) => {
                 progress.currentTool = undefined;
                 progress.updatedAt = Date.now();
+                const activityToolName = toolActivityNames.get(toolCallId) ?? "tool";
+                const activityStartedAt = toolActivityStartedAt.get(toolCallId);
+                appendTelegramActivity(ctx, contextKey, session, {
+                    status: isError ? "failed" : "completed",
+                    type: isError ? "tool_failed" : "tool_completed",
+                    prompt: envelope.description,
+                    detail: activityToolName,
+                    actor: envelope.activityActor,
+                    durationMs: activityStartedAt ? Date.now() - activityStartedAt : undefined,
+                });
+                toolActivityNames.delete(toolCallId);
+                toolActivityStartedAt.delete(toolCallId);
                 if (toolVerbosity === "none" || toolVerbosity === "summary") {
                     return;
                 }
@@ -1266,11 +1557,25 @@ export function createBot(config, registry) {
                     replyMarkup: createQueuedPromptCancelKeyboard(contextKey, item.id),
                 });
                 await updateQueueStatusMessage(contextKey, `Waiting for ${label} CLI task... ${promptStore.list(contextKey).length} queued.`);
+                appendTelegramActivity(ctx, contextKey, session, {
+                    status: "queued",
+                    type: "prompt_queued",
+                    prompt: item.description,
+                    detail: `Queued prompt ${item.id} at position 1; external ${label} CLI task active`,
+                    actor: envelope.activityActor,
+                });
                 scheduleExternalQueueDrain(ctx, contextKey, chatId, session);
                 turnProgress.delete(contextKey);
                 return;
             }
             promptStore.setLastPrompt(contextKey, envelope);
+            promptStartedAt = Date.now();
+            appendTelegramActivity(ctx, contextKey, session, {
+                status: "running",
+                type: "prompt_started",
+                prompt: envelope.description,
+                actor: envelope.activityActor,
+            });
             auditContext(ctx, contextKey, session, {
                 action: "prompt_started",
                 status: "ok",
@@ -1300,6 +1605,13 @@ export function createBot(config, registry) {
                 status: "ok",
                 description: envelope.description,
             });
+            appendTelegramActivity(ctx, contextKey, session, {
+                status: "completed",
+                type: "prompt_completed",
+                prompt: envelope.description,
+                actor: envelope.activityActor,
+                durationMs: promptStartedAt ? Date.now() - promptStartedAt : undefined,
+            });
         }
         catch (error) {
             progress.status = "failed";
@@ -1310,6 +1622,16 @@ export function createBot(config, registry) {
                 description: envelope.description,
                 detail: progress.error,
             });
+            if (promptStartedAt) {
+                appendTelegramActivity(ctx, contextKey, session, {
+                    status: "failed",
+                    type: "prompt_failed",
+                    prompt: envelope.description,
+                    detail: progress.error,
+                    actor: envelope.activityActor,
+                    durationMs: Date.now() - promptStartedAt,
+                });
+            }
             progress.completedAt = Date.now();
             progress.updatedAt = progress.completedAt;
             stopTyping();
@@ -1400,6 +1722,15 @@ export function createBot(config, registry) {
             source: "turn",
         };
         await deliverArtifactReport(ctx, chatId, report, messageThreadId);
+        const contextKey = contextKeyFromCtx(ctx);
+        const session = contextKey ? registry.get(contextKey) : undefined;
+        if (contextKey && session) {
+            appendTelegramActivity(ctx, contextKey, session, {
+                status: "info",
+                type: "artifacts_sent",
+                detail: formatArtifactSummary(report.artifacts, report.skippedCount, report.omittedCount),
+            });
+        }
         await pruneArtifacts(workspace);
     };
     const deliverArtifactReport = async (ctx, chatId, report, messageThreadId) => {
@@ -1596,6 +1927,11 @@ export function createBot(config, registry) {
         }
         const receivedText = `Received ${stagedFiles.length} media group file${stagedFiles.length === 1 ? "" : "s"}${skippedCount > 0 ? ` (${skippedCount} skipped)` : ""}.`;
         await safeReply(pending.ctx, escapeHTML(receivedText), { fallbackText: receivedText });
+        appendTelegramActivity(pending.ctx, pending.contextKey, pending.session, {
+            status: "info",
+            type: "attachment_staged",
+            detail: receivedText,
+        });
         await sendChatActionSafe(pending.ctx.api, pending.chatId, "typing", pending.messageThreadId).catch(() => { });
         const promptInput = {
             stagedFileInstructions: buildFileInstructions(stagedFiles, outDir),
@@ -1625,6 +1961,8 @@ export function createBot(config, registry) {
         checkAgentAuthStatus,
         isTopicContext,
         replyChannelAction,
+        commandService,
+        preferencesStore,
     });
     registerTelegramAgentCommands({
         bot,
@@ -1641,18 +1979,20 @@ export function createBot(config, registry) {
         startAgentLogout,
         hostLoginCommand,
         hostLogoutCommand,
+        appendActivity: (ctx, input) => appendActivity({
+            source: "telegram",
+            ...input,
+            threadId: input.threadId ?? null,
+            workspace: input.workspace ?? config.workspace,
+            actor: input.actor ?? telegramActivityActor(ctx),
+        }),
     });
     registerTelegramPreferenceCommands({
         bot,
         config,
+        commandService,
         preferencesStore,
         getContextSession,
-        getEffectiveMirrorMode,
-        getEffectiveNotifyMode,
-        getEffectiveQuietHours,
-        getEffectiveVoiceBackend,
-        getEffectiveVoiceLanguage,
-        isVoiceTranscribeOnly,
     });
     registerTelegramDiagnosticsCommands({
         bot,
@@ -1673,6 +2013,7 @@ export function createBot(config, registry) {
         getEffectiveVoiceLanguage,
         isVoiceTranscribeOnly,
         replyChannelAction,
+        commandService,
     });
     registerTelegramOperationalCommands({
         bot,
@@ -1686,10 +2027,34 @@ export function createBot(config, registry) {
         getExternalActivity,
         isAdminUser,
         auditContext,
+        getLockOwner: (ctx) => {
+            const authUser = getAuthenticatedUser(ctx);
+            if (!authUser) {
+                return null;
+            }
+            return {
+                userId: authUser.user.id,
+                label: authUser.user.displayName || authUser.user.email,
+                channel: "telegram",
+                channelUserId: ctx.from?.id !== undefined ? String(ctx.from.id) : undefined,
+            };
+        },
         updateSessionMetadata,
     });
     registerTelegramSupportCommands({ bot, config, auditLog, agentUpdates, getUserRole, audit });
-    registerTelegramUpdateCommands({ bot, agentUpdates, replyChannelAction, startTelegramAgentUpdate });
+    registerTelegramUpdateCommands({
+        bot,
+        agentUpdates,
+        replyChannelAction,
+        startTelegramAgentUpdate,
+        appendActivity: (ctx, input) => appendActivity({
+            source: "telegram",
+            ...input,
+            threadId: input.threadId ?? null,
+            workspace: input.workspace ?? config.workspace,
+            actor: input.actor ?? telegramActivityActor(ctx),
+        }),
+    });
     bot.command("new", async (ctx) => {
         const chatId = ctx.chat?.id;
         if (!chatId) {
@@ -1718,6 +2083,14 @@ export function createBot(config, registry) {
             try {
                 const info = await session.newThread();
                 updateSessionMetadata(contextKey, session);
+                appendTelegramActivity(ctx, contextKey, session, {
+                    status: "info",
+                    type: "session_new",
+                    threadId: info.threadId,
+                    workspace: info.workspace,
+                    agentId: info.agentId,
+                    detail: info.workspace,
+                });
                 const label = isTopicContext(contextKey) ? "New thread created for this topic." : "New thread created.";
                 const policyLine = renderWorkspacePolicyLine(info.workspace, config);
                 const plainText = [label, policyLine, "", renderSessionInfoPlain(info)].filter((line) => line !== undefined).join("\n");
@@ -1755,12 +2128,22 @@ export function createBot(config, registry) {
             if (busy.kind === "external") {
                 const text = `Cannot abort the external ${busy.activity.agentLabel} CLI task from NordRelay. Stop it in the terminal where it is running; queued Telegram messages will wait.`;
                 await safeReply(ctx, escapeHTML(text), { fallbackText: text });
+                appendTelegramActivity(ctx, contextKey, session, {
+                    status: "failed",
+                    type: "prompt_abort_rejected",
+                    detail: text,
+                });
                 return;
             }
             await session.abort();
             await safeReply(ctx, escapeHTML("Aborted current operation"), {
                 fallbackText: "Aborted current operation",
             });
+            appendTelegramActivity(ctx, contextKey, session, {
+                status: "aborted",
+                type: "prompt_aborted",
+                detail: "Abort requested from Telegram.",
+            });
         }
         catch (error) {
             await safeReply(ctx, `<b>Failed:</b> ${escapeHTML(friendlyErrorText(error))}`, {
@@ -1809,6 +2192,8 @@ export function createBot(config, registry) {
         drainQueuedPrompts,
         handleUserPrompt,
         auditContext,
+        activityActor: telegramActivityActor,
+        appendActivity: appendTelegramActivity,
     });
     registerTelegramArtifactCommands({
         bot,
@@ -1816,6 +2201,13 @@ export function createBot(config, registry) {
         getContextSession,
         deliverArtifactReport,
         deliverArtifactReportZip,
+        appendActivity: (ctx, input) => appendActivity({
+            source: "telegram",
+            ...input,
+            threadId: input.threadId ?? null,
+            workspace: input.workspace ?? config.workspace,
+            actor: input.actor ?? telegramActivityActor(ctx),
+        }),
     });
     bot.command("session", async (ctx) => {
         const contextSession = await getContextSession(ctx, { deferThreadStart: true });
@@ -1910,6 +2302,14 @@ export function createBot(config, registry) {
         try {
             const info = session.handback();
             updateSessionMetadata(contextKey, session);
+            appendTelegramActivity(ctx, contextKey, session, {
+                status: "info",
+                type: "handback",
+                threadId: info.threadId,
+                workspace: info.workspace,
+                agentId: idOf(session.getInfo()),
+                detail: info.command ?? info.threadId ?? "handback",
+            });
             if (!info.threadId) {
                 await safeReply(ctx, escapeHTML("This thread has not started yet, so there is no resumable thread ID. Send a message to create one, or use /new to start fresh."), {
                     fallbackText: "This thread has not started yet, so there is no resumable thread ID. Send a message to create one, or use /new to start fresh.",
@@ -2005,6 +2405,14 @@ export function createBot(config, registry) {
         try {
             const info = await session.switchSession(threadId);
             updateSessionMetadata(contextKey, session);
+            appendTelegramActivity(ctx, contextKey, session, {
+                status: "info",
+                type: "session_attach",
+                threadId: info.threadId,
+                workspace: info.workspace,
+                agentId: info.agentId,
+                detail: threadId,
+            });
             const policyLine = renderWorkspacePolicyLine(info.workspace, config);
             const html = ["<b>Attached to thread.</b>", policyLine ? `<i>${escapeHTML(policyLine)}</i>` : undefined, "", renderSessionInfoHTML(info)].filter((line) => line !== undefined).join("\n");
             const plain = ["Attached to thread.", policyLine, "", renderSessionInfoPlain(info)].filter((line) => line !== undefined).join("\n");
@@ -2051,6 +2459,14 @@ export function createBot(config, registry) {
             try {
                 const info = await session.switchSession(threadId);
                 updateSessionMetadata(contextKey, session);
+                appendTelegramActivity(ctx, contextKey, session, {
+                    status: "info",
+                    type: "session_switch",
+                    threadId: info.threadId,
+                    workspace: info.workspace,
+                    agentId: info.agentId,
+                    detail: threadId,
+                });
                 const policyLine = renderWorkspacePolicyLine(info.workspace, config);
                 const html = ["<b>Switched thread.</b>", policyLine ? `<i>${escapeHTML(policyLine)}</i>` : undefined, "", renderSessionInfoHTML(info)].filter((line) => line !== undefined).join("\n");
                 const plain = ["Switched thread.", policyLine, "", renderSessionInfoPlain(info)].filter((line) => line !== undefined).join("\n");
@@ -2137,6 +2553,12 @@ export function createBot(config, registry) {
             return;
         }
         const pinned = registry.pinThread(contextKey, threadId);
+        appendTelegramActivity(ctx, contextKey, session, {
+            status: "info",
+            type: "session_pinned",
+            threadId,
+            detail: threadId,
+        });
         await safeReply(ctx, `<b>Pinned thread:</b> <code>${escapeHTML(threadId)}</code>\n<b>Total pinned:</b> <code>${pinned.length}</code>`, {
             fallbackText: `Pinned thread: ${threadId}\nTotal pinned: ${pinned.length}`,
         });
@@ -2157,6 +2579,12 @@ export function createBot(config, registry) {
             return;
         }
         const pinned = registry.unpinThread(contextKey, threadId);
+        appendTelegramActivity(ctx, contextKey, session, {
+            status: "info",
+            type: "session_unpinned",
+            threadId,
+            detail: threadId,
+        });
         await safeReply(ctx, `<b>Unpinned thread:</b> <code>${escapeHTML(threadId)}</code>\n<b>Total pinned:</b> <code>${pinned.length}</code>`, {
             fallbackText: `Unpinned thread: ${threadId}\nTotal pinned: ${pinned.length}`,
         });
@@ -2272,6 +2700,14 @@ export function createBot(config, registry) {
             const result = session.setFastMode(nextFastMode);
             updateSessionMetadata(contextKey, session);
             const info = session.getInfo();
+            appendTelegramActivity(ctx, contextKey, session, {
+                status: "info",
+                type: "fast_mode_changed",
+                threadId: info.threadId,
+                workspace: info.workspace,
+                agentId: info.agentId,
+                detail: result.enabled ? "on" : "off",
+            });
             const plain = [
                 `Fast mode: ${result.enabled ? "on" : "off"}`,
                 `Launch profile: ${result.profile.label} (${formatLaunchProfileBehavior(result.profile)})`,
@@ -2384,6 +2820,15 @@ export function createBot(config, registry) {
                 });
             }
             const session = registry.get(pending.contextKey);
+            if (session) {
+                appendTelegramActivity(ctx, pending.contextKey, session, {
+                    status: "aborted",
+                    type: "prompt_approval_denied",
+                    prompt: pending.prompt.description,
+                    detail: approvalId,
+                    actor: pending.prompt.activityActor,
+                });
+            }
             if (chatId && session) {
                 void drainQueuedPrompts(ctx, pending.contextKey, chatId, session).catch((error) => {
                     console.error("Failed to drain queue after approval denial:", error);
@@ -2402,6 +2847,13 @@ export function createBot(config, registry) {
                 fallbackText: `Approved prompt ${approvalId}.`,
             });
         }
+        appendTelegramActivity(ctx, pending.contextKey, contextSession.session, {
+            status: "info",
+            type: "prompt_approval_approved",
+            prompt: pending.prompt.description,
+            detail: approvalId,
+            actor: pending.prompt.activityActor,
+        });
         await handleUserPrompt(ctx, pending.contextKey, chatId ?? parseContextKey(pending.contextKey).chatId, contextSession.session, pending.prompt, {
             approved: true,
         });
@@ -2445,6 +2897,14 @@ export function createBot(config, registry) {
         try {
             const info = await session.switchSession(threadId);
             updateSessionMetadata(contextKey, session);
+            appendTelegramActivity(ctx, contextKey, session, {
+                status: "info",
+                type: "session_switch",
+                threadId: info.threadId,
+                workspace: info.workspace,
+                agentId: info.agentId,
+                detail: threadId,
+            });
             const policyLine = renderWorkspacePolicyLine(info.workspace, config);
             const plainText = ["Switched session.", policyLine, "", renderSessionInfoPlain(info)].filter((line) => line !== undefined).join("\n");
             const html = ["<b>Switched session.</b>", policyLine ? `<i>${escapeHTML(policyLine)}</i>` : undefined, "", renderSessionInfoHTML(info)].filter((line) => line !== undefined).join("\n");
@@ -2507,6 +2967,14 @@ export function createBot(config, registry) {
         try {
             const info = await session.newThread(workspace);
             updateSessionMetadata(contextKey, session);
+            appendTelegramActivity(ctx, contextKey, session, {
+                status: "info",
+                type: "session_new",
+                threadId: info.threadId,
+                workspace: info.workspace,
+                agentId: info.agentId,
+                detail: workspace,
+            });
             const label = isTopicContext(contextKey) ? "New thread created for this topic." : "New thread created.";
             const policyLine = renderWorkspacePolicyLine(info.workspace, config);
             const plainText = [label, policyLine, "", renderSessionInfoPlain(info)].filter((line) => line !== undefined).join("\n");
@@ -2602,6 +3070,14 @@ export function createBot(config, registry) {
         session.setLaunchProfile(profile.id);
         updateSessionMetadata(contextKey, session);
         const info = session.getInfo();
+        appendTelegramActivity(ctx, contextKey, session, {
+            status: "info",
+            type: "launch_profile_changed",
+            threadId: info.threadId,
+            workspace: info.workspace,
+            agentId: info.agentId,
+            detail: info.launchProfileLabel,
+        });
         const html = [
             `<b>Launch profile set to</b> <code>${escapeHTML(info.launchProfileLabel)}</code>`,
             `<b>Behavior:</b> <code>${escapeHTML(info.launchProfileBehavior)}</code>`,
@@ -2664,6 +3140,14 @@ export function createBot(config, registry) {
         session.setLaunchProfile(profile.id);
         updateSessionMetadata(contextKey, session);
         const info = session.getInfo();
+        appendTelegramActivity(ctx, contextKey, session, {
+            status: "info",
+            type: "launch_profile_changed",
+            threadId: info.threadId,
+            workspace: info.workspace,
+            agentId: info.agentId,
+            detail: info.launchProfileLabel,
+        });
         await ctx.answerCallbackQuery({ text: `Launch set to ${info.launchProfileLabel}` });
         const html = [
             `<b>Launch profile set to</b> <code>${escapeHTML(info.launchProfileLabel)}</code>`,
@@ -2710,6 +3194,15 @@ export function createBot(config, registry) {
         try {
             const result = await session.setModelForCurrentSession(slug);
             updateSessionMetadata(contextKey, session);
+            const info = session.getInfo();
+            appendTelegramActivity(ctx, contextKey, session, {
+                status: "info",
+                type: "model_changed",
+                threadId: info.threadId,
+                workspace: info.workspace,
+                agentId: info.agentId,
+                detail: result.value,
+            });
             const scope = formatAgentSettingScope(session.getInfo(), result.appliedToActiveThread);
             const html = `<b>Model set to</b> <code>${escapeHTML(result.value)}</code> — ${escapeHTML(scope)}.`;
             const plainText = `Model set to ${result.value} — ${scope}.`;
@@ -2756,6 +3249,15 @@ export function createBot(config, registry) {
         pendingEffortButtons.delete(contextKey);
         const result = await session.setReasoningEffortForCurrentSession(effort);
         updateSessionMetadata(contextKey, session);
+        const info = session.getInfo();
+        appendTelegramActivity(ctx, contextKey, session, {
+            status: "info",
+            type: "reasoning_changed",
+            threadId: info.threadId,
+            workspace: info.workspace,
+            agentId: info.agentId,
+            detail: result.value,
+        });
         const label = agentReasoningLabel(idOf(session.getInfo()));
         const scope = formatAgentSettingScope(session.getInfo(), result.appliedToActiveThread);
         const html = `⚡ ${escapeHTML(label)} set to <code>${escapeHTML(effort)}</code> — ${escapeHTML(scope)}.`;
@@ -2815,12 +3317,24 @@ export function createBot(config, registry) {
             }
             const preview = trimLine(transcript.replace(/\s+/g, " "), 100);
             await safeReply(ctx, `🎙️ <b>Transcribed:</b> ${escapeHTML(preview)} <i>(via ${escapeHTML(result.backend)}, ${formatDurationSeconds(result.durationMs / 1000)})</i>`, { fallbackText: `🎙️ Transcribed: ${preview} (via ${result.backend}, ${formatDurationSeconds(result.durationMs / 1000)})` });
+            appendTelegramActivity(ctx, contextKey, session, {
+                status: "info",
+                type: "voice_transcribed",
+                prompt: preview,
+                detail: result.backend,
+                durationMs: result.durationMs,
+            });
         }
         catch (error) {
             const note = "Voice uses faster-whisper/parakeet locally or OPENAI_API_KEY for cloud transcription, not CODEX_API_KEY.";
             await safeReply(ctx, `<b>Transcription failed:</b>\n${escapeHTML(friendlyErrorText(error))}\n\n<i>${escapeHTML(note)}</i>`, {
                 fallbackText: `Transcription failed:\n${friendlyErrorText(error)}\n\n${note}`,
             });
+            appendTelegramActivity(ctx, contextKey, session, {
+                status: "failed",
+                type: "voice_transcription_failed",
+                detail: friendlyErrorText(error),
+            });
             return;
         }
         finally {
@@ -2915,6 +3429,11 @@ export function createBot(config, registry) {
         if (caption) {
             promptInput.text = caption;
         }
+        appendTelegramActivity(ctx, contextKey, session, {
+            status: "info",
+            type: "attachment_staged",
+            detail: stagedPhoto.safeName,
+        });
         await setReaction(ctx, "👀");
         try {
             await handleUserPrompt(ctx, contextKey, chatId, session, toPromptEnvelope(promptInput, outDir));
@@ -2997,6 +3516,11 @@ export function createBot(config, registry) {
         await safeReply(ctx, `📎 <b>Received:</b> <code>${escapeHTML(stagedFile.safeName)}</code>`, {
             fallbackText: `📎 Received: ${stagedFile.safeName}`,
         });
+        appendTelegramActivity(ctx, contextKey, session, {
+            status: "info",
+            type: "attachment_staged",
+            detail: stagedFile.safeName,
+        });
         // Keep typing visible during the gap between staging and prompt execution
         await sendChatActionSafe(ctx.api, chatId, "typing", ctx.message?.message_thread_id).catch(() => { });
         const outDir = outboxPath(workspace, turnId);