pikiclaw 0.2.70 → 0.2.72

package/README.md

@@ -142,6 +142,7 @@ npx pikiclaw@latest --doctor  # check environment only
 
 - Streaming preview with continuous message updates
 - Session switching, resume, and multi-turn conversations
+- Task queue with **Steer** — interrupt the running task and let a queued message jump ahead
 - Working directory browsing and switching
 - File attachments automatically enter the session workspace
 - Long-task sleep prevention, watchdog, and auto-restart

package/dist/bot-command-ui.js

@@ -134,7 +134,7 @@ export function buildAgentsCommandView(bot, chatId) {
     const actions = data.agents
         .filter(agent => agent.installed)
         .map(agent => ({
-        label: agent.agent,
+        label: agent.version ? `${agent.agent} ${agent.version}` : agent.agent,
         action: { kind: 'agent.switch', agent: agent.agent },
         state: buttonStateFromFlags({ isCurrent: agent.isCurrent }),
         primary: agent.isCurrent,
@@ -143,15 +143,9 @@ export function buildAgentsCommandView(bot, chatId) {
         kind: 'agents',
         title: 'Agents',
         metaLines: [],
-        items: data.agents.map(agent => ({
-            label: agent.agent,
-            detail: agent.installed
-                ? (agent.version ? `Version ${agent.version}` : 'Installed')
-                : 'Not installed',
-            state: buttonStateFromFlags({ isCurrent: agent.isCurrent, unavailable: !agent.installed }),
-        })),
-        helperText: 'Use the controls below to switch agents.',
-        rows: chunkRows(actions, 3),
+        items: [],
+        emptyText: actions.length ? undefined : 'No installed agents.',
+        rows: actions.map(action => [action]),
     };
 }
 const modelsDrafts = new Map();

package/dist/bot-commands.js

@@ -78,7 +78,7 @@ export async function getSessionsPageData(bot, chatId, page, pageSize = 5) {
             runState: status.isRunning ? 'running' : s.runState,
             runDetail: s.runDetail,
         });
-        const title = s.title ? s.title.replace(/\n/g, ' ').slice(0, 10) : sessionKey.slice(0, 10);
+        const title = s.title ? s.title.replace(/\n/g, ' ').slice(0, 20) : sessionKey.slice(0, 20);
         const time = s.createdAt
             ? new Date(s.createdAt).toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit' })
             : '?';

package/dist/bot-feishu-render.js

@@ -179,10 +179,14 @@ export function buildHumanLoopPromptMarkdown(prompt) {
 // ---------------------------------------------------------------------------
 // LivePreview renderer — produces Markdown for Feishu card elements
 // ---------------------------------------------------------------------------
-export function buildInitialPreviewMarkdown(agent, model, effort, waiting = false) {
+export function buildInitialPreviewMarkdown(agent, model, effort, waiting = false, queuePosition = 0) {
     const parts = [];
-    if (waiting)
-        parts.push('Waiting in queue...');
+    if (waiting) {
+        const queueLabel = queuePosition > 0
+            ? `Queued · ${queuePosition} ${queuePosition === 1 ? 'task' : 'tasks'} ahead`
+            : 'Waiting in queue...';
+        parts.push(queueLabel);
+    }
     if (model)
         parts.push(model);
     else

package/dist/bot-feishu.js

@@ -134,7 +134,6 @@ export class FeishuBot extends Bot {
         this.log(`menu: ${commands.length} commands (${skillCount} skills)`);
     }
     afterSwitchWorkdir(_oldPath, _newPath) {
-        this.sessionMessages.clear();
         if (!this.channel)
             return;
         void this.setupMenu().catch(err => this.log(`menu refresh failed: ${err}`));
@@ -187,21 +186,30 @@ export class FeishuBot extends Bot {
         return buildSessionTaskId(session, this.nextTaskId++);
     }
     registerSessionMessage(chatId, messageId, session) {
-        this.sessionMessages.register(chatId, messageId, session, this.workdir);
+        this.sessionMessages.register(chatId, messageId, session, session.workdir);
     }
     registerSessionMessages(chatId, messageIds, session) {
-        this.sessionMessages.registerMany(chatId, messageIds, session, this.workdir);
+        this.sessionMessages.registerMany(chatId, messageIds, session, session.workdir);
     }
     sessionFromMessage(chatId, messageId) {
-        const sessionKey = this.sessionMessages.resolve(chatId, messageId);
-        return this.getSessionRuntimeByKey(sessionKey);
+        const sessionRef = this.sessionMessages.resolve(chatId, messageId);
+        if (!sessionRef)
+            return null;
+        return this.getSessionRuntimeByKey(sessionRef.key, { allowAnyWorkdir: true })
+            || this.hydrateSessionRuntime(sessionRef);
     }
     ensureSession(chatId, title, files) {
         return this.ensureSessionForChat(chatId, title, files);
     }
     resolveIncomingSession(ctx, text, files) {
         const cs = this.chat(ctx.chatId);
-        // TODO: Feishu doesn't expose reply_to in the event easily; for now use active session
+        const replyMessageId = ctx.replyToMessageId || null;
+        const repliedSession = this.sessionFromMessage(ctx.chatId, replyMessageId);
+        if (repliedSession) {
+            this.log(`[resolveSession] reply matched session=${repliedSession.sessionId} chat=${ctx.chatId}`);
+            this.applySessionSelection(cs, repliedSession);
+            return repliedSession;
+        }
         const selected = this.getSelectedSession(cs);
         if (selected)
             return selected;
@@ -257,9 +265,27 @@ export class FeishuBot extends Bot {
         }
     }
     sessionsPageSize = 5;
-    buildStopKeyboard(actionId) {
+    buildStopKeyboard(actionId, opts) {
         if (!actionId)
             return undefined;
+        if (opts?.queued) {
+            return {
+                rows: [{
+                        actions: [
+                            {
+                                tag: 'button',
+                                text: { tag: 'plain_text', content: 'Recall' },
+                                value: { action: `tsk:stop:${actionId}` },
+                            },
+                            {
+                                tag: 'button',
+                                text: { tag: 'plain_text', content: 'Steer' },
+                                value: { action: `tsk:steer:${actionId}` },
+                            },
+                        ],
+                    }],
+            };
+        }
         return {
             rows: [{
                     actions: [{
@@ -509,10 +535,10 @@ export class FeishuBot extends Bot {
                     }
                     const staged = stageSessionFiles({
                         agent: session.agent,
-                        workdir: this.workdir,
+                        workdir: session.workdir,
                         files: msg.files,
                         sessionId: session.sessionId,
-                        title: msg.files[0],
+                        title: undefined,
                     });
                     session.workspacePath = staged.workspacePath;
                     this.syncSelectedChats(session);
@@ -547,15 +573,17 @@ export class FeishuBot extends Bot {
             agent: session.agent,
             sessionKey: session.key,
             prompt,
+            attachments: files,
             startedAt: start,
             sourceMessageId: ctx.messageId,
         });
-        const stopKeyboard = this.buildStopKeyboard(this.actionIdForTask(taskId));
+        const queuePosition = waiting ? this.getQueuePosition(session.key, taskId) : 0;
+        const placeholderKeyboard = this.buildStopKeyboard(this.actionIdForTask(taskId), { queued: waiting });
         const model = session.modelId || this.modelForAgent(session.agent);
         const effort = this.effortForAgent(session.agent);
-        const placeholderId = await this.channel.sendStreamingCard(ctx.chatId, buildInitialPreviewMarkdown(session.agent, model, effort, waiting), {
+        const placeholderId = await this.channel.sendStreamingCard(ctx.chatId, buildInitialPreviewMarkdown(session.agent, model, effort, waiting, queuePosition), {
             replyTo: ctx.messageId || undefined,
-            keyboard: stopKeyboard,
+            keyboard: placeholderKeyboard,
         });
         if (placeholderId) {
             this.registerSessionMessage(ctx.chatId, placeholderId, session);
@@ -563,9 +591,10 @@ export class FeishuBot extends Bot {
         this.registerTaskPlaceholders(taskId, [placeholderId]);
         void this.queueSessionTask(session, async () => {
             let livePreview = null;
+            let task = null;
             const abortController = new AbortController();
             try {
-                const task = this.markTaskRunning(taskId, () => abortController.abort());
+                task = this.markTaskRunning(taskId, () => abortController.abort());
                 if (!task || task.cancelled) {
                     if (placeholderId) {
                         try {
@@ -576,6 +605,14 @@ export class FeishuBot extends Bot {
                     this.log(`[handleMessage] skipped cancelled queued task chat=${ctx.chatId} msg=${ctx.messageId}`);
                     return;
                 }
+                // Task is now running — update keyboard from Recall/Steer to Stop
+                const runningKeyboard = this.buildStopKeyboard(this.actionIdForTask(taskId));
+                if (placeholderId && waiting) {
+                    try {
+                        await this.channel.editMessage(ctx.chatId, placeholderId, buildInitialPreviewMarkdown(session.agent, model, effort, false), { keyboard: runningKeyboard });
+                    }
+                    catch { }
+                }
                 if (placeholderId) {
                     const renderer = this.channel.isStreamingCard(placeholderId)
                         ? feishuStreamingPreviewRenderer
@@ -591,7 +628,7 @@ export class FeishuBot extends Bot {
                         canEditMessages: supportsChannelCapability(this.channel, 'editMessages'),
                         canSendTyping: false,
                         parseMode: 'Markdown',
-                        keyboard: stopKeyboard,
+                        keyboard: runningKeyboard,
                         log: (message) => this.log(message),
                     });
                     livePreview.start();
@@ -600,8 +637,19 @@ export class FeishuBot extends Bot {
                 const mcpSendFile = this.createMcpSendFileCallback(ctx);
                 const result = await this.runStream(prompt, session, files, (nextText, nextThinking, nextActivity = '', meta, plan) => {
                     livePreview?.update(nextText, nextThinking, nextActivity, meta, plan);
-                }, undefined, mcpSendFile, abortController.signal, this.createCodexHumanLoopHandler(ctx, taskId));
+                }, undefined, mcpSendFile, abortController.signal, this.createCodexHumanLoopHandler(ctx, taskId), (steer) => {
+                    const currentTask = this.activeTasks.get(taskId);
+                    if (!currentTask || currentTask.cancelled || currentTask.status !== 'running')
+                        return;
+                    currentTask.steer = steer;
+                });
                 await livePreview?.settle();
+                if (task?.freezePreviewOnAbort && result.stopReason === 'interrupted') {
+                    const frozenMessageIds = await this.freezeSteerHandoffPreview(ctx, placeholderId, livePreview);
+                    this.registerSessionMessages(ctx.chatId, frozenMessageIds, session);
+                    this.log(`[handleMessage] steer handoff preserved previous preview chat=${ctx.chatId} task=${taskId}`);
+                    return;
+                }
                 const finalReplyIds = await this.sendFinalReply(ctx, placeholderId, session.agent, result);
                 this.registerSessionMessages(ctx.chatId, finalReplyIds, session);
                 this.log(`[handleMessage] end chat=${ctx.chatId} agent=${session.agent} ok=${result.ok} session=${result.sessionId || session.sessionId || '(new)'} ` +
@@ -609,6 +657,12 @@ export class FeishuBot extends Bot {
                     `tools=${formatToolLog(result.activity)}`);
             }
             catch (e) {
+                if (task?.freezePreviewOnAbort && abortController.signal.aborted) {
+                    const frozenMessageIds = await this.freezeSteerHandoffPreview(ctx, placeholderId, livePreview);
+                    this.registerSessionMessages(ctx.chatId, frozenMessageIds, session);
+                    this.log(`[handleMessage] steer handoff preserved preview after abort chat=${ctx.chatId} task=${taskId}`);
+                    return;
+                }
                 const msgText = String(e?.message || e || 'Unknown error');
                 this.log(`[handleMessage] end chat=${ctx.chatId} agent=${session.agent} ok=false session=${session.sessionId || '(new)'} ` +
                     `elapsed=${((Date.now() - start) / 1000).toFixed(1)}s error="${msgText.slice(0, 240)}" tools=-`);
@@ -638,6 +692,25 @@ export class FeishuBot extends Bot {
             this.finishTask(taskId);
         });
     }
+    async freezeSteerHandoffPreview(ctx, placeholderId, livePreview) {
+        if (!placeholderId)
+            return [];
+        const previewMarkdown = livePreview?.getRenderedPreview()?.trim() || '';
+        if (!previewMarkdown)
+            return [placeholderId];
+        try {
+            if (this.channel.isStreamingCard(placeholderId)) {
+                await this.channel.endStreaming(placeholderId, 'Steered to a new reply.');
+            }
+            await this.channel.editMessage(ctx.chatId, placeholderId, previewMarkdown, {
+                keyboard: { rows: [] },
+            });
+            return [placeholderId];
+        }
+        catch {
+            return [];
+        }
+    }
     async sendFinalReply(ctx, placeholderId, agent, result) {
         const rendered = buildFinalReplyRender(agent, result);
         const messageIds = [];
@@ -787,6 +860,7 @@ export class FeishuBot extends Bot {
             messageId: ctx.messageId,
             from: ctx.from,
             chatType: 'p2p',
+            replyToMessageId: null,
             reply: (text, opts) => ctx.channel.send(ctx.chatId, text, opts),
             editReply: (msgId, text, opts) => ctx.channel.editMessage(ctx.chatId, msgId, text, opts),
             channel: ctx.channel,
@@ -800,6 +874,8 @@ export class FeishuBot extends Bot {
                 return;
             if (await this.handleTaskStopCallback(data, ctx))
                 return;
+            if (await this.handleTaskSteerCallback(data, ctx))
+                return;
             if (await this.handleSwitchNavigateCallback(data, ctx))
                 return;
             if (await this.handleSwitchSelectCallback(data, ctx))
@@ -877,6 +953,16 @@ export class FeishuBot extends Bot {
         }
         return true;
     }
+    async handleTaskSteerCallback(data, ctx) {
+        if (!data.startsWith('tsk:steer:'))
+            return false;
+        const actionId = data.slice('tsk:steer:'.length).trim();
+        const result = await this.steerTaskByActionId(actionId);
+        if (!result.task)
+            return true;
+        // The queued task will naturally run next after the running task is interrupted
+        return true;
+    }
     async handleSwitchNavigateCallback(data, ctx) {
         if (!data.startsWith('sw:n:'))
             return false;

package/dist/bot-handler.js

@@ -16,10 +16,10 @@ import { stageSessionFiles } from './code-agent.js';
 export async function stageFilesIntoSession(bot, session, files) {
     const staged = stageSessionFiles({
         agent: session.agent,
-        workdir: bot.workdir,
+        workdir: session.workdir,
         files,
         sessionId: session.sessionId,
-        title: files[0],
+        title: undefined,
     });
     session.workspacePath = staged.workspacePath;
     return {

package/dist/bot-orchestration.js

@@ -40,7 +40,15 @@ export class SessionMessageRegistry {
             chatMessages = new Map();
             this.messages.set(chatId, chatMessages);
         }
-        chatMessages.set(messageId, session.key);
+        chatMessages.set(messageId, {
+            key: session.key,
+            workdir: session.workdir,
+            agent: session.agent,
+            sessionId: session.sessionId,
+            workspacePath: session.workspacePath ?? null,
+            codexCumulative: session.codexCumulative,
+            modelId: session.modelId ?? null,
+        });
         while (chatMessages.size > this.maxPerChat) {
             const oldest = chatMessages.keys().next();
             if (oldest.done)

package/dist/bot-telegram-live-preview.js

@@ -104,6 +104,9 @@ export class LivePreview {
     getEditCount() {
         return this.editCount;
     }
+    getRenderedPreview() {
+        return this.lastPreview;
+    }
     stopFeedback() {
         if (this.heartbeatTimer) {
             clearInterval(this.heartbeatTimer);

package/dist/bot-telegram-render.js

@@ -258,10 +258,14 @@ function formatFinalFooterHtml(status, agent, elapsedMs, contextPercent) {
 export function formatProviderUsageLines(usage) {
     return buildProviderUsageLines(usage).map(line => line.bold ? `<b>${escapeHtml(line.text)}</b>` : escapeHtml(line.text));
 }
-export function buildInitialPreviewHtml(agent, waiting = false) {
-    return waiting
-        ? `<i>Waiting in queue...</i>\n\n${formatPreviewFooterHtml(agent, 0)}`
-        : formatPreviewFooterHtml(agent, 0);
+export function buildInitialPreviewHtml(agent, waiting = false, queuePosition = 0) {
+    if (waiting) {
+        const queueLabel = queuePosition > 0
+            ? `Queued · ${queuePosition} ${queuePosition === 1 ? 'task' : 'tasks'} ahead`
+            : 'Waiting in queue...';
+        return `<i>${escapeHtml(queueLabel)}</i>\n\n${formatPreviewFooterHtml(agent, 0)}`;
+    }
+    return formatPreviewFooterHtml(agent, 0);
 }
 export function buildStreamPreviewHtml(input) {
     const data = extractStreamPreviewData(input);

package/dist/bot-telegram.js

@@ -82,7 +82,6 @@ export class TelegramBot extends Bot {
         this.log(`menu: ${commands.length} commands (${skillCount} skills)`);
     }
     afterSwitchWorkdir(_oldPath, _newPath) {
-        this.sessionMessages.clear();
         if (!this.channel)
             return;
         void this.setupMenu().catch(err => this.log(`menu refresh failed after workdir switch: ${err}`));
@@ -159,14 +158,17 @@ export class TelegramBot extends Bot {
         return buildSessionTaskId(session, this.nextTaskId++);
     }
     registerSessionMessage(chatId, messageId, session) {
-        this.sessionMessages.register(chatId, messageId, session, this.workdir);
+        this.sessionMessages.register(chatId, messageId, session, session.workdir);
     }
     registerSessionMessages(chatId, messageIds, session) {
-        this.sessionMessages.registerMany(chatId, messageIds, session, this.workdir);
+        this.sessionMessages.registerMany(chatId, messageIds, session, session.workdir);
     }
     sessionFromMessage(chatId, messageId) {
-        const sessionKey = this.sessionMessages.resolve(chatId, messageId);
-        return this.getSessionRuntimeByKey(sessionKey);
+        const sessionRef = this.sessionMessages.resolve(chatId, messageId);
+        if (!sessionRef)
+            return null;
+        return this.getSessionRuntimeByKey(sessionRef.key, { allowAnyWorkdir: true })
+            || this.hydrateSessionRuntime(sessionRef);
     }
     ensureSession(chatId, title, files) {
         return this.ensureSessionForChat(chatId, title, files);
@@ -178,6 +180,7 @@ export class TelegramBot extends Bot {
             : null;
         const repliedSession = this.sessionFromMessage(ctx.chatId, replyMessageId);
         if (repliedSession) {
+            this.log(`[resolveSession] reply matched session=${repliedSession.sessionId} chat=${ctx.chatId}`);
             this.applySessionSelection(cs, repliedSession);
             return repliedSession;
         }
@@ -262,9 +265,17 @@ export class TelegramBot extends Bot {
         }
     }
     sessionsPageSize = 5;
-    buildStopKeyboard(actionId) {
+    buildStopKeyboard(actionId, opts) {
         if (!actionId)
             return undefined;
+        if (opts?.queued) {
+            return {
+                inline_keyboard: [[
+                        { text: 'Recall', callback_data: `tsk:stop:${actionId}` },
+                        { text: 'Steer', callback_data: `tsk:steer:${actionId}` },
+                    ]],
+            };
+        }
         return {
             inline_keyboard: [[
                     { text: 'Stop', callback_data: `tsk:stop:${actionId}` },
@@ -459,10 +470,10 @@ export class TelegramBot extends Bot {
                     }
                     const staged = stageSessionFiles({
                         agent: session.agent,
-                        workdir: this.workdir,
+                        workdir: session.workdir,
                         files: msg.files,
                         sessionId: session.sessionId,
-                        title: msg.files[0],
+                        title: undefined,
                     });
                     session.workspacePath = staged.workspacePath;
                     this.syncSelectedChats(session);
@@ -498,14 +509,16 @@ export class TelegramBot extends Bot {
             agent: session.agent,
             sessionKey: session.key,
             prompt,
+            attachments: files,
             startedAt: start,
             sourceMessageId: ctx.messageId,
         });
-        const stopKeyboard = this.buildStopKeyboard(this.actionIdForTask(taskId));
         const waiting = this.sessionHasPendingWork(session);
+        const queuePosition = waiting ? this.getQueuePosition(session.key, taskId) : 0;
+        const placeholderKeyboard = this.buildStopKeyboard(this.actionIdForTask(taskId), { queued: waiting });
         let phId = null;
         if (canEditMessages) {
-            const placeholderId = await ctx.reply(buildInitialPreviewHtml(session.agent, waiting), { parseMode: 'HTML', messageThreadId, keyboard: stopKeyboard });
+            const placeholderId = await ctx.reply(buildInitialPreviewHtml(session.agent, waiting, queuePosition), { parseMode: 'HTML', messageThreadId, keyboard: placeholderKeyboard });
             phId = typeof placeholderId === 'number' ? placeholderId : null;
             if (phId != null) {
                 this.registerSessionMessage(ctx.chatId, phId, session);
@@ -521,9 +534,10 @@ export class TelegramBot extends Bot {
         this.registerTaskPlaceholders(taskId, [phId]);
         void this.queueSessionTask(session, async () => {
             let livePreview = null;
+            let task = null;
             const abortController = new AbortController();
             try {
-                const task = this.markTaskRunning(taskId, () => abortController.abort());
+                task = this.markTaskRunning(taskId, () => abortController.abort());
                 if (!task || task.cancelled) {
                     if (phId != null) {
                         try {
@@ -534,6 +548,14 @@ export class TelegramBot extends Bot {
                     this.log(`[handleMessage] skipped cancelled queued task chat=${ctx.chatId} msg=${ctx.messageId}`);
                     return;
                 }
+                // Task is now running — update keyboard from Recall/Steer to Stop
+                const runningKeyboard = this.buildStopKeyboard(this.actionIdForTask(taskId));
+                if (phId != null && waiting) {
+                    try {
+                        await this.channel.editMessage(ctx.chatId, phId, buildInitialPreviewHtml(session.agent, false), { parseMode: 'HTML', keyboard: runningKeyboard });
+                    }
+                    catch { }
+                }
                 if (phId != null || canSendTyping) {
                     livePreview = new LivePreview({
                         agent: session.agent,
@@ -546,7 +568,7 @@ export class TelegramBot extends Bot {
                         canEditMessages,
                         canSendTyping,
                         messageThreadId,
-                        keyboard: stopKeyboard,
+                        keyboard: runningKeyboard,
                         log: (message) => this.log(message),
                     });
                     livePreview.start();
@@ -555,8 +577,19 @@ export class TelegramBot extends Bot {
                 const mcpSendFile = this.createMcpSendFileCallback(ctx, messageThreadId);
                 const result = await this.runStream(prompt, session, files, (nextText, nextThinking, nextActivity = '', meta, plan) => {
                     livePreview?.update(nextText, nextThinking, nextActivity, meta, plan);
-                }, undefined, mcpSendFile, abortController.signal, this.createCodexHumanLoopHandler(ctx, taskId, messageThreadId));
+                }, undefined, mcpSendFile, abortController.signal, this.createCodexHumanLoopHandler(ctx, taskId, messageThreadId), (steer) => {
+                    const currentTask = this.activeTasks.get(taskId);
+                    if (!currentTask || currentTask.cancelled || currentTask.status !== 'running')
+                        return;
+                    currentTask.steer = steer;
+                });
                 await livePreview?.settle();
+                if (task?.freezePreviewOnAbort && result.stopReason === 'interrupted') {
+                    const frozenMessageIds = await this.freezeSteerHandoffPreview(ctx, phId, livePreview);
+                    this.registerSessionMessages(ctx.chatId, frozenMessageIds, session);
+                    this.log(`[handleMessage] steer handoff preserved previous preview chat=${ctx.chatId} task=${taskId}`);
+                    return;
+                }
                 this.log(`[handleMessage] done agent=${session.agent} ok=${result.ok} session=${result.sessionId || '?'} elapsed=${result.elapsedS.toFixed(1)}s edits=${livePreview?.getEditCount() || 0} ` +
                     `tokens=in:${fmtTokens(result.inputTokens)}/cached:${fmtTokens(result.cachedInputTokens)}/out:${fmtTokens(result.outputTokens)}`);
                 this.log(`[handleMessage] response preview: "${result.message.slice(0, 150)}"`);
@@ -565,6 +598,12 @@ export class TelegramBot extends Bot {
                 this.log(`[handleMessage] final reply sent to chat=${ctx.chatId}`);
             }
             catch (e) {
+                if (task?.freezePreviewOnAbort && abortController.signal.aborted) {
+                    const frozenMessageIds = await this.freezeSteerHandoffPreview(ctx, phId, livePreview);
+                    this.registerSessionMessages(ctx.chatId, frozenMessageIds, session);
+                    this.log(`[handleMessage] steer handoff preserved preview after abort chat=${ctx.chatId} task=${taskId}`);
+                    return;
+                }
                 const msgText = String(e?.message || e || 'Unknown error');
                 this.log(`[handleMessage] task failed chat=${ctx.chatId} session=${session.sessionId} error=${msgText}`);
                 const errorHtml = `<b>Error</b>\n\n<code>${escapeHtml(msgText.slice(0, 500))}</code>`;
@@ -594,6 +633,23 @@ export class TelegramBot extends Bot {
             this.finishTask(taskId);
         });
     }
+    async freezeSteerHandoffPreview(ctx, phId, livePreview) {
+        if (phId == null)
+            return [];
+        const previewHtml = livePreview?.getRenderedPreview()?.trim() || '';
+        if (!previewHtml)
+            return [phId];
+        try {
+            await this.channel.editMessage(ctx.chatId, phId, previewHtml, {
+                parseMode: 'HTML',
+                keyboard: { inline_keyboard: [] },
+            });
+            return [phId];
+        }
+        catch {
+            return [];
+        }
+    }
     /** Create an MCP sendFile callback bound to a Telegram chat context. */
     createMcpSendFileCallback(ctx, messageThreadId) {
         return async (filePath, opts) => {
@@ -758,6 +814,22 @@ export class TelegramBot extends Bot {
         await ctx.answerCallback('Nothing to stop.');
         return true;
     }
+    async handleTaskSteerCallback(data, ctx) {
+        if (!data.startsWith('tsk:steer:'))
+            return false;
+        const actionId = data.slice('tsk:steer:'.length).trim();
+        const result = await this.steerTaskByActionId(actionId);
+        if (!result.task) {
+            await ctx.answerCallback('This task already finished.');
+            return true;
+        }
+        if (result.task.status !== 'queued') {
+            await ctx.answerCallback('Task is already running.');
+            return true;
+        }
+        await ctx.answerCallback(result.interrupted ? 'Steering — switching to the queued reply...' : 'No running task to interrupt.');
+        return true;
+    }
     async handleHumanLoopCallback(data, ctx) {
         if (!data.startsWith('hl:'))
             return false;
@@ -824,6 +896,8 @@ export class TelegramBot extends Bot {
             return;
         if (await this.handleTaskStopCallback(data, ctx))
             return;
+        if (await this.handleTaskSteerCallback(data, ctx))
+            return;
         if (await this.handleSwitchNavigateCallback(data, ctx))
             return;
         if (await this.handleSwitchSelectCallback(data, ctx))