pikiclaw 0.3.17 → 0.3.18

package/dist/agent/drivers/codex.js

@@ -432,36 +432,43 @@ function overlayCodexManagedPreview(workdir, sessionId, richMessages) {
     };
     return merged;
 }
-function buildCodexInteractionRequest(method, params, requestId) {
+function toAgentInteraction(method, params, requestId) {
     if (method === 'item/tool/requestUserInput') {
-        const questions = Array.isArray(params?.questions) ? params.questions : [];
+        const raw = Array.isArray(params?.questions) ? params.questions : [];
+        const questions = raw
+            .map((q) => ({
+            id: String(q?.id || ''),
+            header: String(q?.header || '') || 'Question',
+            prompt: String(q?.question || ''),
+            options: Array.isArray(q?.options)
+                ? q.options.map((o) => ({
+                    label: String(o?.label || ''),
+                    description: String(o?.description || ''),
+                    value: String(o?.label || ''),
+                }))
+                : null,
+            allowFreeform: !!q?.isOther || !Array.isArray(q?.options) || !q.options.length,
+            secret: !!q?.isSecret,
+            allowEmpty: true,
+        }))
+            .filter((q) => q.id && q.prompt);
         return {
-            kind: 'requestUserInput',
-            requestId,
-            threadId: String(params?.threadId || ''),
-            turnId: String(params?.turnId || ''),
-            itemId: String(params?.itemId || ''),
-            questions: questions.map((question) => ({
-                id: String(question?.id || ''),
-                header: String(question?.header || ''),
-                question: String(question?.question || ''),
-                isOther: !!question?.isOther,
-                isSecret: !!question?.isSecret,
-                options: Array.isArray(question?.options)
-                    ? question.options.map((option) => ({
-                        label: String(option?.label || ''),
-                        description: String(option?.description || ''),
-                    }))
-                    : null,
-            })).filter((question) => question.id && question.question),
+            kind: 'user-input',
+            id: requestId,
+            title: 'User Input Required',
+            hint: 'Use the buttons when available. Reply with text when prompted.',
+            questions,
+            resolveWith: (answers) => ({
+                answers: Object.fromEntries(Object.entries(answers).map(([id, vals]) => [id, { answers: vals }])),
+            }),
         };
     }
     return null;
 }
-function defaultCodexInteractionResponse(request) {
+function defaultAgentInteractionResponse(interaction) {
     const answers = {};
-    for (const question of request.questions)
-        answers[question.id] = { answers: [] };
+    for (const q of interaction.questions)
+        answers[q.id] = { answers: [] };
     return { answers };
 }
 function defaultCodexServerRequestResponse(method) {
@@ -836,22 +843,22 @@ function handleTurnPlanUpdated(params, s, emit) {
 // Stream request handler (extracted from doCodexStream)
 // ---------------------------------------------------------------------------
 async function handleCodexRequest(method, params, requestId, s, opts, emit) {
-    const interaction = buildCodexInteractionRequest(method, params, requestId);
+    const interaction = toAgentInteraction(method, params, requestId);
     if (!interaction)
         return defaultCodexServerRequestResponse(method);
-    pushRecentActivity(s.recentNarrative, interaction.kind === 'requestUserInput' ? 'Waiting for user input' : 'Waiting for approval');
+    pushRecentActivity(s.recentNarrative, interaction.kind === 'user-input' ? 'Waiting for user input' : 'Waiting for approval');
     emit();
     try {
-        if (opts.onCodexInteractionRequest) {
-            const response = await opts.onCodexInteractionRequest(interaction);
-            return response ?? defaultCodexInteractionResponse(interaction);
+        if (opts.onInteraction) {
+            const response = await opts.onInteraction(interaction);
+            return response ?? defaultAgentInteractionResponse(interaction);
         }
     }
     catch (error) {
         pushRecentActivity(s.recentFailures, `Human input failed: ${shortValue(error?.message || error, 120)}`, 4);
         emit();
     }
-    return defaultCodexInteractionResponse(interaction);
+    return defaultAgentInteractionResponse(interaction);
 }
 // ---------------------------------------------------------------------------
 // Stream via app-server

package/dist/bot/bot.js

@@ -279,6 +279,26 @@ export class Bot {
                 }
                 break;
             }
+            case 'interaction': {
+                const snap = this.streamSnapshots.get(sessionKey);
+                if (snap) {
+                    const list = snap.interactions || [];
+                    list.push(event.interaction);
+                    snap.interactions = list;
+                    snap.updatedAt = now;
+                }
+                break;
+            }
+            case 'interaction-resolved': {
+                const snap = this.streamSnapshots.get(sessionKey);
+                if (snap?.interactions) {
+                    snap.interactions = snap.interactions.filter(i => i.promptId !== event.promptId);
+                    if (!snap.interactions.length)
+                        delete snap.interactions;
+                    snap.updatedAt = now;
+                }
+                break;
+            }
         }
         // Push to dashboard SSE — throttle text events, push everything else immediately
         try {
@@ -903,6 +923,7 @@ export class Bot {
         this.humanLoopPrompts.delete(promptId);
         this.removeHumanLoopPromptFromChat(prompt.chatId, promptId);
         prompt.resolve(buildHumanLoopResponse(prompt));
+        this.emitInteractionResolved(prompt.taskId, promptId);
         return prompt;
     }
     clearHumanLoopPrompt(promptId, error) {
@@ -913,8 +934,14 @@ export class Bot {
         this.removeHumanLoopPromptFromChat(prompt.chatId, promptId);
         if (error)
             prompt.reject(error);
+        this.emitInteractionResolved(prompt.taskId, promptId);
         return prompt;
     }
+    emitInteractionResolved(taskId, promptId) {
+        const task = this.activeTasks.get(taskId);
+        if (task)
+            this.emitStream(task.sessionKey, { type: 'interaction-resolved', promptId });
+    }
     humanLoopSelectOption(promptId, optionValue, opts = {}) {
         const prompt = this.humanLoopPrompts.get(promptId) || null;
         if (!prompt)
@@ -963,6 +990,79 @@ export class Bot {
         else
             this.humanLoopPromptIdsByChat.delete(chatKey);
     }
+    /**
+     * Create an interaction handler that bridges agent requests to the human-loop
+     * state machine and pushes SSE events to the dashboard.
+     *
+     * IM channel subclasses override `renderInteractionPrompt()` to render
+     * buttons/cards in their native UI.  Dashboard clients receive the
+     * `interaction` SSE event and respond via REST.
+     */
+    createInteractionHandler(chatId, taskId, sessionKey) {
+        return async (request) => {
+            const active = this.beginHumanLoopPrompt({
+                taskId,
+                chatId,
+                title: request.title,
+                hint: request.hint,
+                questions: request.questions,
+                resolveWith: request.resolveWith,
+            });
+            const interactionSnapshot = {
+                promptId: active.prompt.promptId,
+                kind: request.kind,
+                title: request.title,
+                hint: request.hint,
+                questions: request.questions,
+            };
+            this.emitStream(sessionKey, { type: 'interaction', taskId, interaction: interactionSnapshot });
+            try {
+                await this.renderInteractionPrompt(active.prompt, chatId);
+            }
+            catch (error) {
+                this.humanLoopCancel(active.prompt.promptId, error?.message || 'Failed to send prompt.');
+                throw error;
+            }
+            return active.result;
+        };
+    }
+    /**
+     * Render an interaction prompt in the IM channel.
+     * Override in channel subclasses (Telegram, Feishu, etc.).
+     * Dashboard-only sessions (chatId='dashboard') are a no-op by default.
+     */
+    async renderInteractionPrompt(_prompt, _chatId) {
+        // Default: no-op (dashboard-only sessions use SSE events instead)
+    }
+    // ---- Public interaction API (used by dashboard routes) --------------------
+    /** Respond to a pending interaction prompt with a selected option. */
+    interactionSelectOption(promptId, optionValue, opts) {
+        return this.humanLoopSelectOption(promptId, optionValue, opts);
+    }
+    /** Submit freeform text to a pending interaction prompt. */
+    interactionSubmitText(promptId, text) {
+        const prompt = this.humanLoopPrompt(promptId);
+        if (!prompt)
+            return null;
+        if (!isHumanLoopAwaitingText(prompt))
+            return null;
+        const result = setHumanLoopText(prompt, text);
+        if (result.completed)
+            this.resolveHumanLoopPrompt(prompt.promptId);
+        return { prompt, ...result };
+    }
+    /** Skip the current question in a pending interaction prompt. */
+    interactionSkip(promptId) {
+        return this.humanLoopSkip(promptId);
+    }
+    /** Cancel a pending interaction prompt. */
+    interactionCancel(promptId, reason = 'Cancelled from dashboard.') {
+        return this.humanLoopCancel(promptId, reason);
+    }
+    /** Get a specific interaction prompt by ID. */
+    interactionPrompt(promptId) {
+        return this.humanLoopPrompt(promptId);
+    }
     selectedSession(chatId) {
         return this.getSelectedSession(this.chat(chatId));
     }
@@ -1003,7 +1103,7 @@ export class Bot {
                 const result = await this.runStream(prompt, session, attachments, (text, thinking, activity, meta, plan) => {
                     opts.onText?.(text, thinking, activity, meta, plan);
                     this.emitStream(currentSessionKey(), { type: 'text', text, thinking, activity, plan });
-                }, undefined, undefined, abortController.signal);
+                }, undefined, undefined, abortController.signal, this.createInteractionHandler(opts.chatId ?? 'dashboard', taskId, currentSessionKey()));
                 this.emitStream(currentSessionKey(), {
                     type: 'done',
                     taskId,
@@ -1272,7 +1372,7 @@ export class Bot {
         if (!opts.initial)
             this.onManagedConfigChange(config, opts);
     }
-    async runStream(prompt, cs, attachments, onText, systemPrompt, mcpSendFile, abortSignal, onCodexInteractionRequest, onSteerReady, onCodexTurnReady) {
+    async runStream(prompt, cs, attachments, onText, systemPrompt, mcpSendFile, abortSignal, onInteraction, onSteerReady, onCodexTurnReady) {
         const resolvedModel = cs.modelId || this.modelForAgent(cs.agent);
         const agentConfig = this.agentConfigs[cs.agent] || {};
         const resolvedThinkingEffort = ('thinkingEffort' in cs && typeof cs.thinkingEffort === 'string' && cs.thinkingEffort.trim())
@@ -1359,7 +1459,7 @@ export class Bot {
             // MCP bridge
             mcpSendFile,
             abortSignal,
-            onCodexInteractionRequest,
+            onInteraction,
             onSteerReady,
             onCodexTurnReady,
         };

package/dist/channels/feishu/bot.js

@@ -17,9 +17,8 @@ import { SKILL_CMD_PREFIX, } from '../../bot/menu.js';
 import { getStartData, getSessionsPageData, getModelsListData, getSessionTurnPreviewData, getStatusDataAsync, getHostDataSync, resolveSkillPrompt, } from '../../bot/commands.js';
 import { buildAgentsCommandView, buildModelsCommandView, buildModeCommandView, buildSessionsCommandView, buildSkillsCommandView, decodeCommandAction, executeCommandAction, } from '../../bot/command-ui.js';
 import { LivePreview } from '../telegram/live-preview.js';
-import { formatActiveTaskRestartError, getActiveTaskCount, registerProcessRuntime, requestProcessRestart, } from '../../core/process-control.js';
+import { registerProcessRuntime, requestProcessRestart, } from '../../core/process-control.js';
 import { feishuPreviewRenderer, buildInitialPreviewMarkdown, buildHumanLoopPromptMarkdown, buildFinalReplyRender, renderCommandNotice, renderCommandSelectionCard, renderSessionTurnMarkdown, renderStart, renderStatus, renderHost, buildSwitchWorkdirCard, resolveFeishuRegisteredPath, } from './render.js';
-import { buildCodexHumanLoopPrompt } from '../../bot/human-loop-codex.js';
 import { currentHumanLoopQuestion, humanLoopOptionSelected } from '../../bot/human-loop.js';
 import { FeishuChannel } from './channel.js';
 import { splitText, supportsChannelCapability } from '../base.js';
@@ -384,11 +383,6 @@ export class FeishuBot extends Bot {
         await ctx.channel.sendCard(ctx.chatId, view);
     }
     async cmdRestart(ctx) {
-        const activeTasks = getActiveTaskCount();
-        if (activeTasks > 0) {
-            await ctx.reply(`⚠ ${formatActiveTaskRestartError(activeTasks)}`);
-            return;
-        }
         await ctx.reply('**Restarting pikiclaw...**\n\nPulling latest version. The bot will be back shortly.');
         void requestProcessRestart({ log: msg => this.log(msg) });
     }
@@ -474,27 +468,12 @@ export class FeishuBot extends Bot {
             keyboard: { rows: [] },
         }).catch(() => { });
     }
-    createCodexHumanLoopHandler(ctx, taskId) {
-        return async (request) => {
-            const blueprint = buildCodexHumanLoopPrompt(request);
-            const active = this.beginHumanLoopPrompt({
-                taskId,
-                chatId: ctx.chatId,
-                ...blueprint,
-            });
-            try {
-                const sent = await ctx.reply(buildHumanLoopPromptMarkdown(active.prompt), {
-                    keyboard: this.buildHumanLoopKeyboard(active.prompt.promptId),
-                });
-                if (sent)
-                    this.registerHumanLoopMessage(active.prompt.promptId, sent);
-            }
-            catch (error) {
-                this.humanLoopCancel(active.prompt.promptId, error?.message || 'Failed to send prompt.');
-                throw error;
-            }
-            return active.result;
-        };
+    async renderInteractionPrompt(prompt, chatId) {
+        const sent = await this.channel.send(chatId, buildHumanLoopPromptMarkdown(prompt), {
+            keyboard: this.buildHumanLoopKeyboard(prompt.promptId),
+        });
+        if (sent)
+            this.registerHumanLoopMessage(prompt.promptId, sent);
     }
     async safeSetMessageReaction(chatId, messageId, reactions) {
         if (!supportsChannelCapability(this.channel, 'messageReactions'))
@@ -640,7 +619,7 @@ 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), (steer) => {
+                }, undefined, mcpSendFile, abortController.signal, this.createInteractionHandler(ctx.chatId, taskId, session.key), (steer) => {
                     const currentTask = this.activeTasks.get(taskId);
                     if (!currentTask || currentTask.cancelled || currentTask.status !== 'running')
                         return;

package/dist/channels/telegram/bot.js

@@ -18,9 +18,8 @@ import { getStartData, getStatusDataAsync, getHostDataSync, getSessionTurnPrevie
 import { buildAgentsCommandView, buildModelsCommandView, buildModeCommandView, buildSessionsCommandView, buildSkillsCommandView, decodeCommandAction, executeCommandAction, } from '../../bot/command-ui.js';
 import { buildSwitchWorkdirView, resolveRegisteredPath } from './directory.js';
 import { LivePreview } from './live-preview.js';
-import { formatActiveTaskRestartError, getActiveTaskCount, registerProcessRuntime, buildRestartCommand, requestProcessRestart, } from '../../core/process-control.js';
+import { registerProcessRuntime, buildRestartCommand, requestProcessRestart, } from '../../core/process-control.js';
 import { buildInitialPreviewHtml, buildHumanLoopPromptHtml, buildStreamPreviewHtml, buildFinalReplyRender, escapeHtml, formatMenuLines, formatProviderUsageLines, renderCommandNoticeHtml, renderCommandSelectionHtml, renderCommandSelectionKeyboard, renderSessionTurnHtml, truncateMiddle, } from './render.js';
-import { buildCodexHumanLoopPrompt } from '../../bot/human-loop-codex.js';
 import { currentHumanLoopQuestion, humanLoopOptionSelected } from '../../bot/human-loop.js';
 import { TelegramChannel } from './channel.js';
 import { splitText, supportsChannelCapability } from '../base.js';
@@ -348,11 +347,6 @@ export class TelegramBot extends Bot {
         await this.sendCommandView(ctx, buildModeCommandView(this, ctx.chatId));
     }
     async cmdRestart(ctx) {
-        const activeTasks = getActiveTaskCount();
-        if (activeTasks > 0) {
-            await ctx.reply(`⚠ ${formatActiveTaskRestartError(activeTasks)}`, { parseMode: 'HTML' });
-            return;
-        }
         await ctx.reply(`<b>Restarting pikiclaw...</b>\n\n` +
             `The bot will be back shortly.`, { parseMode: 'HTML' });
         void requestProcessRestart({ log: msg => this.log(msg) });
@@ -418,30 +412,18 @@ export class TelegramBot extends Bot {
             keyboard: { inline_keyboard: [] },
         }).catch(() => { });
     }
-    createCodexHumanLoopHandler(ctx, taskId, messageThreadId) {
-        return async (request) => {
-            const blueprint = buildCodexHumanLoopPrompt(request);
-            const active = this.beginHumanLoopPrompt({
-                taskId,
-                chatId: ctx.chatId,
-                ...blueprint,
-            });
-            try {
-                const sent = await ctx.reply(buildHumanLoopPromptHtml(active.prompt), {
-                    parseMode: 'HTML',
-                    messageThreadId,
-                    keyboard: this.buildHumanLoopKeyboard(active.prompt.promptId),
-                });
-                if (typeof sent === 'number')
-                    this.registerHumanLoopMessage(active.prompt.promptId, sent);
-            }
-            catch (error) {
-                this.humanLoopCancel(active.prompt.promptId, error?.message || 'Failed to send prompt.');
-                throw error;
-            }
-            return active.result;
-        };
+    async renderInteractionPrompt(prompt, chatId) {
+        const messageThreadId = this.interactionThreadIds.get(prompt.taskId);
+        const sent = await this.channel.send(chatId, buildHumanLoopPromptHtml(prompt), {
+            parseMode: 'HTML',
+            messageThreadId,
+            keyboard: this.buildHumanLoopKeyboard(prompt.promptId),
+        });
+        if (typeof sent === 'number')
+            this.registerHumanLoopMessage(prompt.promptId, sent);
     }
+    /** Cache the messageThreadId per task so renderInteractionPrompt can use it. */
+    interactionThreadIds = new Map();
     // ---- streaming bridge -----------------------------------------------------
     async handleMessage(msg, ctx) {
         const text = msg.text.trim();
@@ -581,9 +563,10 @@ export class TelegramBot extends Bot {
                 }
                 // MCP sendFile callback: sends files to IM in real-time during the stream
                 const mcpSendFile = this.createMcpSendFileCallback(ctx, messageThreadId);
+                this.interactionThreadIds.set(taskId, 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), (steer) => {
+                }, undefined, mcpSendFile, abortController.signal, this.createInteractionHandler(ctx.chatId, taskId, session.key), (steer) => {
                     const currentTask = this.activeTasks.get(taskId);
                     if (!currentTask || currentTask.cancelled || currentTask.status !== 'running')
                         return;
@@ -631,6 +614,7 @@ export class TelegramBot extends Bot {
             }
             finally {
                 livePreview?.dispose();
+                this.interactionThreadIds.delete(taskId);
                 this.finishTask(taskId);
                 this.syncSelectedChats(session);
             }

package/dist/channels/weixin/bot.js

@@ -7,7 +7,7 @@ import path from 'node:path';
 import { Bot, buildPrompt, fmtUptime, fmtBytes, normalizeAgent, parseAllowedChatIds, } from '../../bot/bot.js';
 import { BOT_SHUTDOWN_FORCE_EXIT_MS, buildSessionTaskId } from '../../bot/orchestration.js';
 import { shutdownAllDrivers } from '../../agent/driver.js';
-import { formatActiveTaskRestartError, getActiveTaskCount, registerProcessRuntime, requestProcessRestart, } from '../../core/process-control.js';
+import { registerProcessRuntime, requestProcessRestart, } from '../../core/process-control.js';
 import { getStatusDataAsync, getHostDataSync, getAgentsListData, getSkillsListData, getModelsListData, getSessionsPageData, getStartData, } from '../../bot/commands.js';
 import { WeixinChannel } from './channel.js';
 import { getActiveUserConfig } from '../../core/config/user-config.js';
@@ -386,11 +386,6 @@ export class WeixinBot extends Bot {
         await ctx.reply(`Stopped: ${parts.join(', ')}.`);
     }
     async cmdRestart(ctx) {
-        const activeTasks = getActiveTaskCount();
-        if (activeTasks > 0) {
-            await ctx.reply(formatActiveTaskRestartError(activeTasks));
-            return;
-        }
         await ctx.reply('Restarting pikiclaw...');
         void requestProcessRestart({ log: msg => this.log(msg) });
     }

package/dist/core/process-control.js

@@ -87,9 +87,6 @@ export function getActiveTaskCount() {
     }
     return total;
 }
-export function formatActiveTaskRestartError(activeTasks) {
-    return `${activeTasks} task(s) still running. Wait for them to finish or try again.`;
-}
 export function createRestartStateFilePath(ownerPid = process.pid) {
     const dir = path.join(os.tmpdir(), 'pikiclaw');
     fs.mkdirSync(dir, { recursive: true });
@@ -188,15 +185,6 @@ function spawnReplacementProcess(bin, args, env, log) {
     return child;
 }
 export async function requestProcessRestart(opts = {}) {
-    const activeTasks = getActiveTaskCount();
-    if (activeTasks > 0) {
-        return {
-            ok: false,
-            restarting: false,
-            error: formatActiveTaskRestartError(activeTasks),
-            activeTasks,
-        };
-    }
     if (restartInFlight) {
         return {
             ok: true,

package/dist/dashboard/routes/config.js

@@ -12,7 +12,7 @@ import { validateFeishuConfig, validateTelegramConfig, validateWeixinConfig } fr
 import { resolveGuiIntegrationConfig } from '../../agent/mcp/bridge.js';
 import { normalizeWeixinBaseUrl, startWeixinQrLogin, waitForWeixinQrLogin, } from '../../channels/weixin/api.js';
 import { getManagedBrowserStatus, launchManagedBrowserSetup, } from '../../browser-profile.js';
-import { formatActiveTaskRestartError, getActiveTaskCount, requestProcessRestart, } from '../../core/process-control.js';
+import { requestProcessRestart, } from '../../core/process-control.js';
 import { checkPermissions, detectHostTerminalApp, installAppium, isAppiumInstalled, isManagedAppiumRunning, isValidPermissionKey, requestPermission, startManagedAppium, stopManagedAppium, } from '../platform.js';
 import { VERSION } from '../../core/version.js';
 import { runtime } from '../runtime.js';
@@ -258,10 +258,6 @@ app.post('/api/open-preferences', async (c) => {
 });
 // Restart process
 app.post('/api/restart', (c) => {
-    const activeTasks = getActiveTaskCount();
-    if (activeTasks > 0) {
-        return c.json({ ok: false, error: formatActiveTaskRestartError(activeTasks) }, 409);
-    }
     setTimeout(() => {
         void requestProcessRestart({ log: message => runtime.log(message) });
     }, 50);

package/dist/dashboard/routes/sessions.js

@@ -8,7 +8,7 @@ import path from 'node:path';
 import { loadUserConfig } from '../../core/config/user-config.js';
 import { listAgents, listSkills } from '../../agent/index.js';
 import { getSessionStatusForBot } from '../../bot/session-status.js';
-import { cancelSessionTask, getSessionStreamState, queueDashboardSessionTask, steerSessionTask, } from '../session-control.js';
+import { cancelSessionTask, getSessionStreamState, queueDashboardSessionTask, steerSessionTask, interactionSelectOption, interactionSubmitText, interactionSkip, interactionCancel, getInteractionPrompt, } from '../session-control.js';
 import { querySessions, querySessionTail, querySessionMessages, getWorkspaceOverviews, updateSession, linkSessions, buildMigrationContext, exportSession, importSession, loadWorkspaces, addWorkspace, removeWorkspace, updateWorkspace, } from '../../bot/session-hub.js';
 import { DASHBOARD_PAGINATION } from '../../core/constants.js';
 import { runtime } from '../runtime.js';
@@ -505,4 +505,67 @@ app.post('/api/session-hub/session/steer', async (c) => {
         return c.json({ ok: false, error: e.message }, 500);
     }
 });
+// ==========================================================================
+// Interaction prompts (human-in-the-loop)
+// ==========================================================================
+/** GET /api/interaction/:promptId — Get interaction prompt state. */
+app.get('/api/interaction/:promptId', (c) => {
+    const { promptId } = c.req.param();
+    const result = getInteractionPrompt(promptId);
+    return c.json(result, result.ok ? 200 : 503);
+});
+/** POST /api/interaction/:promptId/select — Select an option. */
+app.post('/api/interaction/:promptId/select', async (c) => {
+    try {
+        const { promptId } = c.req.param();
+        const body = await c.req.json();
+        const { value, requestFreeform } = body || {};
+        if (!value && !requestFreeform) {
+            return c.json({ ok: false, error: 'value is required' }, 400);
+        }
+        const result = interactionSelectOption(promptId, value || '__other__', { requestFreeform: !!requestFreeform });
+        return c.json(result, result.ok ? 200 : (result.error === 'Bot is not running' ? 503 : 404));
+    }
+    catch (e) {
+        return c.json({ ok: false, error: e.message }, 500);
+    }
+});
+/** POST /api/interaction/:promptId/text — Submit freeform text. */
+app.post('/api/interaction/:promptId/text', async (c) => {
+    try {
+        const { promptId } = c.req.param();
+        const body = await c.req.json();
+        const { text } = body || {};
+        if (typeof text !== 'string') {
+            return c.json({ ok: false, error: 'text is required' }, 400);
+        }
+        const result = interactionSubmitText(promptId, text);
+        return c.json(result, result.ok ? 200 : (result.error === 'Bot is not running' ? 503 : 404));
+    }
+    catch (e) {
+        return c.json({ ok: false, error: e.message }, 500);
+    }
+});
+/** POST /api/interaction/:promptId/skip — Skip current question. */
+app.post('/api/interaction/:promptId/skip', async (c) => {
+    try {
+        const { promptId } = c.req.param();
+        const result = interactionSkip(promptId);
+        return c.json(result, result.ok ? 200 : (result.error === 'Bot is not running' ? 503 : 404));
+    }
+    catch (e) {
+        return c.json({ ok: false, error: e.message }, 500);
+    }
+});
+/** POST /api/interaction/:promptId/cancel — Cancel interaction prompt. */
+app.post('/api/interaction/:promptId/cancel', async (c) => {
+    try {
+        const { promptId } = c.req.param();
+        const result = interactionCancel(promptId);
+        return c.json(result, result.ok ? 200 : (result.error === 'Bot is not running' ? 503 : 404));
+    }
+    catch (e) {
+        return c.json({ ok: false, error: e.message }, 500);
+    }
+});
 export default app;

package/dist/dashboard/session-control.js

@@ -104,3 +104,62 @@ export async function steerSessionTask(taskId) {
     const result = await bot.steerTask(taskId);
     return { ok: true, steered: result.steered };
 }
+// ---------------------------------------------------------------------------
+// Interaction prompt control (human-in-the-loop)
+// ---------------------------------------------------------------------------
+export function interactionSelectOption(promptId, optionValue, opts) {
+    const bot = runtime.getBotRef();
+    if (!bot)
+        return { ok: false, error: 'Bot is not running' };
+    const result = bot.interactionSelectOption(promptId, optionValue, opts);
+    if (!result)
+        return { ok: false, error: 'Prompt not found or no longer active' };
+    return { ok: true, completed: result.completed, advanced: result.advanced };
+}
+export function interactionSubmitText(promptId, text) {
+    const bot = runtime.getBotRef();
+    if (!bot)
+        return { ok: false, error: 'Bot is not running' };
+    const result = bot.interactionSubmitText(promptId, text);
+    if (!result)
+        return { ok: false, error: 'Prompt not found or not awaiting text' };
+    return { ok: true, completed: result.completed, advanced: result.advanced };
+}
+export function interactionSkip(promptId) {
+    const bot = runtime.getBotRef();
+    if (!bot)
+        return { ok: false, error: 'Bot is not running' };
+    const result = bot.interactionSkip(promptId);
+    if (!result)
+        return { ok: false, error: 'Prompt not found or no longer active' };
+    return { ok: true, completed: result.completed, advanced: result.advanced };
+}
+export function interactionCancel(promptId) {
+    const bot = runtime.getBotRef();
+    if (!bot)
+        return { ok: false, error: 'Bot is not running' };
+    const result = bot.interactionCancel(promptId);
+    if (!result)
+        return { ok: false, error: 'Prompt not found or no longer active' };
+    return { ok: true };
+}
+export function getInteractionPrompt(promptId) {
+    const bot = runtime.getBotRef();
+    if (!bot)
+        return { ok: false, error: 'Bot is not running' };
+    const prompt = bot.interactionPrompt(promptId);
+    if (!prompt)
+        return { ok: true, prompt: null };
+    return {
+        ok: true,
+        prompt: {
+            promptId: prompt.promptId,
+            taskId: prompt.taskId,
+            title: prompt.title,
+            hint: prompt.hint,
+            questions: prompt.questions,
+            currentIndex: prompt.currentIndex,
+            answers: prompt.answers,
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pikiclaw",
-  "version": "0.3.17",
+  "version": "0.3.18",
   "description": "Put the world's smartest AI agents in your pocket. Command local Claude & Gemini via IM. | 让最好用的 IM 变成你电脑上的顶级 Agent 控制台",
   "type": "module",
   "bin": {
@@ -37,7 +37,7 @@
     "test:watch": "vitest"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.0.0"
   },
   "devDependencies": {
     "@tailwindcss/vite": "^4.2.1",

package/dist/bot/human-loop-codex.js

@@ -1,26 +0,0 @@
-/**
- * Maps Codex user-input requests into IM human-loop prompts.
- */
-export function buildCodexHumanLoopPrompt(request) {
-    return {
-        title: 'User Input Required',
-        detail: 'codex',
-        hint: 'Use the buttons when available. Reply with text when prompted.',
-        questions: request.questions.map(question => ({
-            id: question.id,
-            header: question.header || 'Question',
-            prompt: question.question,
-            options: question.options?.map(option => ({
-                label: option.label,
-                description: option.description,
-                value: option.label,
-            })) || null,
-            allowFreeform: question.isOther || !question.options?.length,
-            secret: question.isSecret,
-            allowEmpty: true,
-        })),
-        resolveWith: answers => ({
-            answers: Object.fromEntries(Object.entries(answers).map(([id, values]) => [id, { answers: values }])),
-        }),
-    };
-}