pikiclaw 0.2.69 → 0.2.71

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

@@ -31,6 +31,12 @@ export function encodeCommandAction(action) {
             return `mod:${action.modelId}`;
         case 'effort.set':
             return `eff:${action.effort}`;
+        case 'models.select.model':
+            return `md:${action.modelId}`;
+        case 'models.select.effort':
+            return `ed:${action.effort}`;
+        case 'models.confirm':
+            return 'mc';
         case 'skill.run':
             return `skr:${action.command}`;
     }
@@ -70,6 +76,20 @@ export function decodeCommandAction(data) {
             return null;
         return { kind: 'effort.set', effort };
     }
+    if (data.startsWith('md:')) {
+        const modelId = data.slice(3);
+        if (!modelId)
+            return null;
+        return { kind: 'models.select.model', modelId };
+    }
+    if (data.startsWith('ed:')) {
+        const effort = data.slice(3);
+        if (!effort)
+            return null;
+        return { kind: 'models.select.effort', effort };
+    }
+    if (data === 'mc')
+        return { kind: 'models.confirm' };
     if (data.startsWith('skr:')) {
         const command = data.slice(4);
         if (!command)
@@ -134,24 +154,57 @@ export function buildAgentsCommandView(bot, chatId) {
         rows: chunkRows(actions, 3),
     };
 }
-export async function buildModelsCommandView(bot, chatId) {
+const modelsDrafts = new Map();
+async function initModelsDraft(bot, chatId) {
     const data = await getModelsListData(bot, chatId);
-    const models = [...data.models].sort((a, b) => Number(b.isCurrent) - Number(a.isCurrent));
+    const draft = { modelId: data.currentModel, effort: data.effort?.current ?? null };
+    modelsDrafts.set(String(chatId), draft);
+    return draft;
+}
+export async function buildModelsCommandView(bot, chatId, draft) {
+    const data = await getModelsListData(bot, chatId);
+    // Initialize draft from current state or use the provided one
+    const d = draft ?? {
+        modelId: data.currentModel,
+        effort: data.effort?.current ?? null,
+    };
+    modelsDrafts.set(String(chatId), d);
+    const isSelected = (modelId) => modelMatchesSelection(data.agent, modelId, d.modelId);
+    const models = [...data.models].sort((a, b) => Number(isSelected(b.id)) - Number(isSelected(a.id)));
     const modelButtons = models.map(model => ({
         label: model.alias || model.id,
-        action: { kind: 'model.switch', modelId: model.id },
-        state: buttonStateFromFlags({ isCurrent: model.isCurrent }),
-        primary: model.isCurrent,
+        action: { kind: 'models.select.model', modelId: model.id },
+        state: buttonStateFromFlags({ isCurrent: isSelected(model.id) }),
+        primary: isSelected(model.id),
     }));
-    const rows = chunkRows(modelButtons, modelButtons.some(button => button.label.length > 14) ? 1 : 2);
+    const rows = chunkRows(modelButtons, 1);
     if (data.effort) {
-        rows.push(data.effort.levels.map(level => ({
+        const effortButtons = data.effort.levels.map(level => ({
             label: level.label,
-            action: { kind: 'effort.set', effort: level.id },
-            state: buttonStateFromFlags({ isCurrent: level.isCurrent }),
-            primary: level.isCurrent,
-        })));
+            action: { kind: 'models.select.effort', effort: level.id },
+            state: buttonStateFromFlags({ isCurrent: level.id === d.effort }),
+            primary: level.id === d.effort,
+        }));
+        // Section label — clicking it is harmless (triggers confirm, which is noop if nothing changed)
+        rows.push([{
+                label: '— Thinking Effort —',
+                action: { kind: 'models.confirm' },
+                state: 'default',
+                primary: false,
+            }]);
+        // ≤3 levels fit in one row; 4+ split into rows of 2 to avoid Feishu truncation
+        rows.push(...chunkRows(effortButtons, effortButtons.length <= 3 ? effortButtons.length : 2));
     }
+    // Detect whether draft differs from current live values
+    const modelChanged = !modelMatchesSelection(data.agent, d.modelId, data.currentModel);
+    const effortChanged = !!(data.effort && d.effort !== data.effort.current);
+    const hasChanges = modelChanged || effortChanged;
+    rows.push([{
+            label: hasChanges ? '✓ Apply' : '✓ OK',
+            action: { kind: 'models.confirm' },
+            state: 'default',
+            primary: hasChanges,
+        }]);
     return {
         kind: 'models',
         title: 'Models',
@@ -159,15 +212,15 @@ export async function buildModelsCommandView(bot, chatId) {
         metaLines: [
             ...(data.sources.length ? [`Source: ${data.sources.join(', ')}`] : []),
             ...(data.note ? [data.note] : []),
-            ...(data.effort ? [`Thinking Effort: ${data.effort.current}`] : []),
+            ...(data.effort ? [`Thinking Effort: ${d.effort}`] : []),
         ],
         items: models.map(model => ({
             label: model.alias || model.id,
             detail: model.alias ? model.id : null,
-            state: buttonStateFromFlags({ isCurrent: model.isCurrent }),
+            state: buttonStateFromFlags({ isCurrent: isSelected(model.id) }),
         })),
         emptyText: 'No discoverable models found.',
-        helperText: data.models.length ? 'Use the controls below to switch models.' : null,
+        helperText: data.models.length ? 'Select model and effort, then tap Apply.' : null,
         rows,
     };
 }
@@ -286,6 +339,51 @@ export async function executeCommandAction(bot, chatId, action, opts = {}) {
                 },
             };
         }
+        case 'models.select.model': {
+            const draft = modelsDrafts.get(String(chatId)) ?? await initModelsDraft(bot, chatId);
+            draft.modelId = action.modelId;
+            return { kind: 'view', view: await buildModelsCommandView(bot, chatId, draft), callbackText: '' };
+        }
+        case 'models.select.effort': {
+            const draft = modelsDrafts.get(String(chatId)) ?? await initModelsDraft(bot, chatId);
+            draft.effort = action.effort;
+            return { kind: 'view', view: await buildModelsCommandView(bot, chatId, draft), callbackText: '' };
+        }
+        case 'models.confirm': {
+            const chat = bot.chat(chatId);
+            const draft = modelsDrafts.get(String(chatId));
+            modelsDrafts.delete(String(chatId));
+            if (!draft)
+                return { kind: 'noop', message: 'No changes' };
+            const currentModel = bot.modelForAgent(chat.agent);
+            const currentEffort = bot.effortForAgent(chat.agent);
+            const modelChanged = !modelMatchesSelection(chat.agent, draft.modelId, currentModel);
+            const effortChanged = draft.effort != null && draft.effort !== currentEffort;
+            if (!modelChanged && !effortChanged) {
+                return { kind: 'noop', message: 'No changes' };
+            }
+            const parts = [];
+            if (modelChanged) {
+                bot.switchModelForChat(chatId, draft.modelId);
+                parts.push(`Model: ${draft.modelId}`);
+            }
+            if (effortChanged) {
+                bot.switchEffortForChat(chatId, draft.effort);
+                parts.push(`Effort: ${draft.effort}`);
+            }
+            return {
+                kind: 'notice',
+                callbackText: parts.join(', '),
+                notice: {
+                    title: 'Configuration Updated',
+                    value: parts.join('\n'),
+                    detail: modelChanged
+                        ? `${chat.agent} · session reset`
+                        : `${chat.agent} · takes effect on next message`,
+                    valueMode: 'plain',
+                },
+            };
+        }
         case 'skill.run': {
             const resolved = resolveSkillPrompt(bot, chatId, action.command, '');
             if (!resolved)

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

@@ -100,6 +100,29 @@ export function renderCommandSelectionCard(view) {
         rows: view.rows.map(row => ({ actions: row.map(actionButton) })),
     };
 }
+/**
+ * Strip code-fence markers (``` / ~~~) from text that is not meant to be
+ * rendered as full markdown (thinking, activity).  Truncation by
+ * extractThinkingTail can leave stray fences that open unwanted code blocks.
+ */
+function stripCodeFences(text) {
+    return text.replace(/^(`{3,}|~{3,}).*$/gm, '');
+}
+/**
+ * Ensure code fences in markdown text are balanced.  If an odd number of
+ * fence markers is detected, append a closing fence so partial code blocks
+ * do not swallow the rest of the card.
+ */
+function ensureBalancedCodeFences(text) {
+    let inCode = false;
+    for (const line of text.split('\n')) {
+        const trimmed = line.trimStart();
+        if (trimmed.startsWith('```') || trimmed.startsWith('~~~')) {
+            inCode = !inCode;
+        }
+    }
+    return inCode ? text + '\n```' : text;
+}
 function escapeFeishuMarkdownText(text) {
     return text.replace(/([\\`*_{}[\]()#+\-.!|>~])/g, '\\$1');
 }
@@ -156,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
@@ -172,19 +199,19 @@ function buildPreviewMarkdown(input, options) {
     const data = extractStreamPreviewData(input);
     const parts = [];
     if (data.planDisplay) {
-        parts.push(`**Plan**\n${data.planDisplay}`);
+        parts.push(`**Plan**\n${stripCodeFences(data.planDisplay)}`);
     }
     if (data.activityDisplay) {
-        parts.push(`**Activity**\n${trimActivityForPreview(data.activityDisplay, data.maxActivity)}`);
+        parts.push(`**Activity**\n${stripCodeFences(trimActivityForPreview(data.activityDisplay, data.maxActivity))}`);
     }
     if (data.thinkDisplay && !data.display) {
-        parts.push(`**${data.label}**\n${data.thinkDisplay}`);
+        parts.push(`**${data.label}**\n${stripCodeFences(data.thinkDisplay)}`);
     }
     else if (data.display) {
         if (data.rawThinking) {
-            parts.push(`**${data.label}**\n${data.thinkSnippet}`);
+            parts.push(`**${data.label}**\n${stripCodeFences(data.thinkSnippet)}`);
         }
-        parts.push(data.preview);
+        parts.push(ensureBalancedCodeFences(data.preview));
     }
     if (options?.includeFooter !== false) {
         parts.push(formatPreviewFooter(input.agent, input.elapsedMs, input.meta ?? null));
@@ -213,21 +240,21 @@ export function buildFinalReplyRender(agent, result) {
     let activityText = '';
     let activityNoteText = '';
     if (data.activityNarrative) {
-        activityText = `**Activity**\n${data.activityNarrative}\n\n`;
+        activityText = `**Activity**\n${stripCodeFences(data.activityNarrative)}\n\n`;
     }
     if (data.activityCommandSummary) {
         activityNoteText = `*${data.activityCommandSummary}*\n\n`;
     }
     let thinkingText = '';
     if (data.thinkingDisplay) {
-        thinkingText = `**${data.thinkLabel}**\n${data.thinkingDisplay}\n\n`;
+        thinkingText = `**${data.thinkLabel}**\n${stripCodeFences(data.thinkingDisplay)}\n\n`;
     }
     let statusText = '';
     if (data.statusLines) {
         statusText = `**⚠ Incomplete Response**\n${data.statusLines.join('\n')}\n\n`;
     }
     const headerText = `${activityText}${activityNoteText}${statusText}${thinkingText}`;
-    const bodyText = data.bodyMessage;
+    const bodyText = ensureBalancedCodeFences(data.bodyMessage);
     return {
         fullText: `${headerText}${bodyText}${footerText}`,
         headerText,
@@ -583,6 +610,10 @@ function normalizeFeishuMarkdown(lines) {
         pendingBlankLine = false;
         out.push(line);
     }
+    // Safety: close any unclosed code block so it doesn't swallow the rest of
+    // a Feishu card element (e.g. truncated body text ending mid-fence).
+    if (inCodeBlock)
+        out.push('```');
     return out.join('\n');
 }
 export function adaptMarkdownForFeishu(markdown) {

package/dist/bot-feishu.js

@@ -201,7 +201,13 @@ export class FeishuBot extends Bot {
     }
     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 +263,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: [{
@@ -512,7 +536,7 @@ export class FeishuBot extends Bot {
                         workdir: this.workdir,
                         files: msg.files,
                         sessionId: session.sessionId,
-                        title: msg.files[0],
+                        title: undefined,
                     });
                     session.workspacePath = staged.workspacePath;
                     this.syncSelectedChats(session);
@@ -550,12 +574,13 @@ export class FeishuBot extends Bot {
             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);
@@ -576,6 +601,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 +624,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();
@@ -787,6 +820,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 +834,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 +913,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 = 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

@@ -19,7 +19,7 @@ export async function stageFilesIntoSession(bot, session, files) {
         workdir: bot.workdir,
         files,
         sessionId: session.sessionId,
-        title: files[0],
+        title: undefined,
     });
     session.workspacePath = staged.workspacePath;
     return {

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

@@ -178,6 +178,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 +263,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}` },
@@ -462,7 +471,7 @@ export class TelegramBot extends Bot {
                         workdir: this.workdir,
                         files: msg.files,
                         sessionId: session.sessionId,
-                        title: msg.files[0],
+                        title: undefined,
                     });
                     session.workspacePath = staged.workspacePath;
                     this.syncSelectedChats(session);
@@ -501,11 +510,12 @@ export class TelegramBot extends Bot {
             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);
@@ -534,6 +544,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 +564,7 @@ export class TelegramBot extends Bot {
                         canEditMessages,
                         canSendTyping,
                         messageThreadId,
-                        keyboard: stopKeyboard,
+                        keyboard: runningKeyboard,
                         log: (message) => this.log(message),
                     });
                     livePreview.start();
@@ -651,7 +669,8 @@ export class TelegramBot extends Bot {
             finalMsgId = await replacePreview(rendered.fullHtml);
         }
         else {
-            const maxFirst = 3900 - rendered.headerHtml.length - rendered.footerHtml.length;
+            // Split: header on first message, footer on last message
+            const maxFirst = 3900 - rendered.headerHtml.length;
             let firstBody;
             let remaining;
             if (maxFirst > 200) {
@@ -665,14 +684,29 @@ export class TelegramBot extends Bot {
                 firstBody = '';
                 remaining = rendered.bodyHtml;
             }
-            const firstHtml = `${rendered.headerHtml}${firstBody}${rendered.footerHtml}`;
-            finalMsgId = await replacePreview(firstHtml);
             if (remaining.trim()) {
+                // Multi-message: header on first, footer on last
+                const firstHtml = `${rendered.headerHtml}${firstBody}`;
+                finalMsgId = await replacePreview(firstHtml);
                 const chunks = splitText(remaining, 3800);
-                for (const chunk of chunks) {
-                    remember(await sendFinalText(chunk, finalMsgId ?? phId ?? ctx.messageId));
+                for (let i = 0; i < chunks.length; i++) {
+                    const isLast = i === chunks.length - 1;
+                    const chunkText = isLast ? `${chunks[i]}${rendered.footerHtml}` : chunks[i];
+                    remember(await sendFinalText(chunkText, finalMsgId ?? phId ?? ctx.messageId));
+                }
+                // Safety: re-clear the Stop keyboard on the placeholder in case the first edit silently failed
+                if (phId != null) {
+                    try {
+                        await this.channel.editMessage(ctx.chatId, phId, firstHtml || '(done)', { parseMode: 'HTML', keyboard: { inline_keyboard: [] } });
+                    }
+                    catch { }
                 }
             }
+            else {
+                // Body fits on first message; only footer pushes it over — keep together
+                const firstHtml = `${rendered.headerHtml}${firstBody}${rendered.footerHtml}`;
+                finalMsgId = await replacePreview(firstHtml);
+            }
         }
         return { primaryMessageId: finalMsgId, messageIds };
     }
@@ -742,6 +776,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 = 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 — interrupting current task...' : 'No running task to interrupt.');
+        return true;
+    }
     async handleHumanLoopCallback(data, ctx) {
         if (!data.startsWith('hl:'))
             return false;
@@ -808,6 +858,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))

package/dist/bot.js

@@ -617,7 +617,7 @@ export class Bot {
             workdir: this.workdir,
             files: [],
             sessionId: null,
-            title: title || files[0] || 'New session',
+            title: title || 'New session',
         });
         const runtime = this.upsertSessionRuntime({
             agent: cs.agent,
@@ -767,6 +767,61 @@ export class Bot {
         }
         return { task, interrupted: false, cancelled: false };
     }
+    /**
+     * Steer: interrupt the running task so a queued task (identified by actionId) runs next.
+     * Returns { task, interrupted } where task is the queued task and interrupted indicates
+     * whether a running task was aborted.
+     */
+    steerTaskByActionId(actionId) {
+        const taskId = this.taskKeysByActionId.get(String(actionId));
+        if (!taskId)
+            return { task: null, interrupted: false };
+        const task = this.activeTasks.get(taskId) || null;
+        if (!task || task.status !== 'queued')
+            return { task, interrupted: false };
+        const interrupted = this.interruptRunningTask(task.sessionKey);
+        return { task, interrupted };
+    }
+    /**
+     * Interrupt only the currently running task for a session, leaving queued tasks intact.
+     * Used by the "Steer" action to let a queued task run next.
+     */
+    interruptRunningTask(sessionKey) {
+        const session = this.getSessionRuntimeByKey(sessionKey, { allowAnyWorkdir: true });
+        if (!session)
+            return false;
+        for (const taskId of session.runningTaskIds) {
+            const task = this.activeTasks.get(taskId);
+            if (!task || task.status !== 'running')
+                continue;
+            try {
+                task.abort?.();
+            }
+            catch { }
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Return the number of tasks ahead of the given task in its session queue.
+     * Counts running + queued (non-cancelled) tasks that were started before this one.
+     */
+    getQueuePosition(sessionKey, taskId) {
+        const session = this.getSessionRuntimeByKey(sessionKey, { allowAnyWorkdir: true });
+        if (!session)
+            return 0;
+        let ahead = 0;
+        for (const otherId of session.runningTaskIds) {
+            if (otherId === taskId)
+                continue;
+            const other = this.activeTasks.get(otherId);
+            if (!other || other.cancelled)
+                continue;
+            if (other.status === 'running' || other.status === 'queued')
+                ahead++;
+        }
+        return ahead;
+    }
     sourceMessageKey(chatId, sourceMessageId) {
         return `${String(chatId)}:${String(sourceMessageId)}`;
     }

package/dist/channel-feishu.js

@@ -423,7 +423,8 @@ class FeishuChannel extends Channel {
             this._log(`[recv] skipped: not mentioned in group ${chatId}`);
             return;
         }
-        const ctx = this._makeCtx(chatId, messageId, from, chatType, event);
+        const parentId = typeof msg.parent_id === 'string' && msg.parent_id ? msg.parent_id : null;
+        const ctx = this._makeCtx(chatId, messageId, from, chatType, event, parentId);
         // Parse message content
         let text = '';
         const files = [];
@@ -1031,12 +1032,13 @@ class FeishuChannel extends Channel {
     // ========================================================================
     // Internal helpers
     // ========================================================================
-    _makeCtx(chatId, messageId, from, chatType, raw) {
+    _makeCtx(chatId, messageId, from, chatType, raw, replyToMessageId) {
         return {
             chatId,
             messageId,
             from,
             chatType,
+            replyToMessageId: replyToMessageId || null,
             reply: (text, opts) => this.send(chatId, text, { ...opts, replyTo: messageId || opts?.replyTo }),
             editReply: (msgId, text, opts) => this.editMessage(chatId, msgId, text, opts),
             channel: this,

package/dist/cli.js

@@ -299,10 +299,15 @@ Docs: https://github.com/xiaotonng/pikiclaw
  */
 function persistWorkdir(args, userConfig) {
     if (!process.env.PIKICLAW_DAEMON_CHILD) {
-        const cliWorkdir = path.resolve(args.workdir || '.');
-        if (userConfig.workdir !== cliWorkdir) {
-            updateUserConfig({ workdir: cliWorkdir });
-            return loadUserConfig();
+        // Only overwrite persisted workdir when the user explicitly passed -w.
+        // Falling back to cwd when no flag is given can clobber a valid saved
+        // workdir with a temp directory (e.g. after a non-daemon restart).
+        if (args.workdir) {
+            const cliWorkdir = path.resolve(args.workdir);
+            if (userConfig.workdir !== cliWorkdir) {
+                updateUserConfig({ workdir: cliWorkdir });
+                return loadUserConfig();
+            }
         }
     }
     return userConfig;

package/dist/code-agent.js

@@ -748,8 +748,7 @@ export function stageSessionFiles(opts) {
     const importedFiles = importFilesIntoWorkspace(session.workspacePath, opts.files);
     if (importedFiles.length) {
         session.record.stagedFiles = dedupeStrings([...session.record.stagedFiles, ...importedFiles]);
-        if (!session.record.title)
-            session.record.title = importedFiles[0];
+        /* title will be set when the first text prompt arrives */
         saveSessionRecord(opts.workdir, session.record);
     }
     return { sessionId: session.sessionId, workspacePath: session.workspacePath, importedFiles };
@@ -890,7 +889,7 @@ function prepareStreamOpts(opts) {
     const stagedFiles = [...session.record.stagedFiles];
     session.record.stagedFiles = [];
     if (!session.record.title)
-        session.record.title = summarizePromptTitle(opts.prompt) || importedFiles[0] || null;
+        session.record.title = summarizePromptTitle(opts.prompt) || null;
     setSessionRunState(session.record, 'running', null);
     saveSessionRecord(opts.workdir, session.record);
     const attachmentPaths = attachmentRelPaths.map(relPath => path.join(session.workspacePath, relPath));

package/dist/driver-claude.js

@@ -223,9 +223,10 @@ function getNativeClaudeSessions(workdir) {
         const filePath = path.join(projectDir, entry.name);
         try {
             const stat = fs.statSync(filePath);
-            // Read first few KB to extract title and model from first user/assistant messages
+            // Read enough bytes to get past the system_prompt line (can be 20KB+) and
+            // reach the first user/assistant events for title and model extraction.
             const fd = fs.openSync(filePath, 'r');
-            const buf = Buffer.alloc(8192);
+            const buf = Buffer.alloc(65536);
             const bytesRead = fs.readSync(fd, buf, 0, buf.length, 0);
             fs.closeSync(fd);
             const head = buf.toString('utf8', 0, bytesRead);

package/dist/process-control.js

@@ -168,6 +168,7 @@ function spawnReplacementProcess(bin, args, env, log) {
         stdio: 'inherit',
         detached: true,
         env,
+        cwd: process.cwd(),
     });
     child.unref();
     log?.(`restart: new process spawned (PID ${child.pid})`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pikiclaw",
-  "version": "0.2.69",
+  "version": "0.2.71",
   "description": "Put the world's smartest AI agents in your pocket. Command local Claude & Gemini via IM. | 让最好用的 IM 变成你电脑上的顶级 Agent 控制台",
   "type": "module",
   "bin": {