pikiclaw 0.2.70 → 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-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

@@ -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();
@@ -758,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;
@@ -824,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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pikiclaw",
-  "version": "0.2.70",
+  "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": {