pikiclaw 0.2.71 → 0.2.72

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-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,14 +186,17 @@ 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);
@@ -533,7 +535,7 @@ export class FeishuBot extends Bot {
                     }
                     const staged = stageSessionFiles({
                         agent: session.agent,
-                        workdir: this.workdir,
+                        workdir: session.workdir,
                         files: msg.files,
                         sessionId: session.sessionId,
                         title: undefined,
@@ -571,6 +573,7 @@ export class FeishuBot extends Bot {
             agent: session.agent,
             sessionKey: session.key,
             prompt,
+            attachments: files,
             startedAt: start,
             sourceMessageId: ctx.messageId,
         });
@@ -588,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 {
@@ -633,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)'} ` +
@@ -642,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=-`);
@@ -671,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 = [];
@@ -917,7 +957,7 @@ export class FeishuBot extends Bot {
         if (!data.startsWith('tsk:steer:'))
             return false;
         const actionId = data.slice('tsk:steer:'.length).trim();
-        const result = this.steerTaskByActionId(actionId);
+        const result = await this.steerTaskByActionId(actionId);
         if (!result.task)
             return true;
         // The queued task will naturally run next after the running task is interrupted

package/dist/bot-handler.js

@@ -16,7 +16,7 @@ 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: undefined,

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.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);
@@ -468,7 +470,7 @@ export class TelegramBot extends Bot {
                     }
                     const staged = stageSessionFiles({
                         agent: session.agent,
-                        workdir: this.workdir,
+                        workdir: session.workdir,
                         files: msg.files,
                         sessionId: session.sessionId,
                         title: undefined,
@@ -507,6 +509,7 @@ export class TelegramBot extends Bot {
             agent: session.agent,
             sessionKey: session.key,
             prompt,
+            attachments: files,
             startedAt: start,
             sourceMessageId: ctx.messageId,
         });
@@ -531,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 {
@@ -573,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)}"`);
@@ -583,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>`;
@@ -612,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) => {
@@ -780,7 +818,7 @@ export class TelegramBot extends Bot {
         if (!data.startsWith('tsk:steer:'))
             return false;
         const actionId = data.slice('tsk:steer:'.length).trim();
-        const result = this.steerTaskByActionId(actionId);
+        const result = await this.steerTaskByActionId(actionId);
         if (!result.task) {
             await ctx.answerCallback('This task already finished.');
             return true;
@@ -789,7 +827,7 @@ export class TelegramBot extends Bot {
             await ctx.answerCallback('Task is already running.');
             return true;
         }
-        await ctx.answerCallback(result.interrupted ? 'Steering — interrupting current task...' : 'No running task to interrupt.');
+        await ctx.answerCallback(result.interrupted ? 'Steering — switching to the queued reply...' : 'No running task to interrupt.');
         return true;
     }
     async handleHumanLoopCallback(data, ctx) {

package/dist/bot.js

@@ -538,7 +538,19 @@ export class Bot {
         return runtime;
     }
     getSelectedSession(cs) {
-        return this.getSessionRuntimeByKey(cs.activeSessionKey);
+        return this.getSessionRuntimeByKey(cs.activeSessionKey, { allowAnyWorkdir: true });
+    }
+    hydrateSessionRuntime(session) {
+        if (!session.sessionId)
+            return null;
+        return this.upsertSessionRuntime({
+            agent: session.agent,
+            sessionId: session.sessionId,
+            workdir: session.workdir || this.workdir,
+            workspacePath: session.workspacePath ?? null,
+            codexCumulative: session.codexCumulative,
+            modelId: session.modelId ?? null,
+        });
     }
     upsertSessionRuntime(session) {
         const workdir = path.resolve(session.workdir || this.workdir);
@@ -570,6 +582,7 @@ export class Bot {
         return runtime;
     }
     applySessionSelection(cs, session) {
+        const previousSessionKey = cs.activeSessionKey ?? null;
         cs.activeSessionKey = session?.key ?? null;
         if (session) {
             cs.agent = session.agent;
@@ -577,12 +590,16 @@ export class Bot {
             cs.workspacePath = session.workspacePath;
             cs.codexCumulative = session.codexCumulative;
             cs.modelId = session.modelId ?? null;
+            if (previousSessionKey && previousSessionKey !== session.key)
+                this.maybeEvictSessionRuntime(previousSessionKey);
             return;
         }
         cs.sessionId = null;
         cs.workspacePath = null;
         cs.codexCumulative = undefined;
         cs.modelId = null;
+        if (previousSessionKey)
+            this.maybeEvictSessionRuntime(previousSessionKey);
     }
     resetChatConversation(cs) {
         this.applySessionSelection(cs, null);
@@ -592,12 +609,17 @@ export class Bot {
             this.applySessionSelection(cs, null);
             return;
         }
-        const runtime = this.upsertSessionRuntime({
+        const runtime = this.hydrateSessionRuntime({
             agent: session.agent,
             sessionId: session.sessionId,
+            workdir: 'workdir' in session ? session.workdir : null,
             workspacePath: session.workspacePath ?? null,
             modelId: session.model ?? null,
         });
+        if (!runtime) {
+            this.applySessionSelection(cs, null);
+            return;
+        }
         this.applySessionSelection(cs, runtime);
     }
     syncSelectedChats(session) {
@@ -607,6 +629,27 @@ export class Bot {
             this.applySessionSelection(cs, session);
         }
     }
+    isSessionSelected(sessionKey) {
+        if (!sessionKey)
+            return false;
+        for (const [, cs] of this.chats) {
+            if (cs.activeSessionKey === sessionKey)
+                return true;
+        }
+        return false;
+    }
+    maybeEvictSessionRuntime(sessionKey) {
+        const session = this.getSessionRuntimeByKey(sessionKey, { allowAnyWorkdir: true });
+        if (!session)
+            return;
+        if (session.runningTaskIds.size)
+            return;
+        if (session.workdir === this.workdir)
+            return;
+        if (this.isSessionSelected(session.key))
+            return;
+        this.sessionStates.delete(session.key);
+    }
     ensureSessionForChat(chatId, title, files) {
         const cs = this.chat(chatId);
         const selected = this.getSelectedSession(cs);
@@ -661,9 +704,7 @@ export class Bot {
         if (!session)
             return;
         session.runningTaskIds.delete(taskId);
-        if (!session.runningTaskIds.size && session.workdir !== this.workdir) {
-            this.sessionStates.delete(session.key);
-        }
+        this.maybeEvictSessionRuntime(session.key);
     }
     runningTaskForSession(sessionKey) {
         const session = this.getSessionRuntimeByKey(sessionKey, { allowAnyWorkdir: true });
@@ -687,6 +728,8 @@ export class Bot {
             return task;
         task.status = 'running';
         task.abort = abort || null;
+        task.steer = null;
+        task.freezePreviewOnAbort = false;
         return task;
     }
     registerTaskPlaceholders(taskId, messageIds) {
@@ -768,25 +811,25 @@ 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.
+     * Steer hands off to the queued task's own placeholder card. Interrupt the
+     * active task so the queued task can run next and the current preview can be
+     * frozen in place instead of being rewritten as an error.
      */
-    steerTaskByActionId(actionId) {
+    async steerTaskByActionId(actionId) {
         const taskId = this.taskKeysByActionId.get(String(actionId));
         if (!taskId)
-            return { task: null, interrupted: false };
+            return { task: null, interrupted: false, steered: 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 };
+            return { task, interrupted: false, steered: false };
+        const interrupted = this.interruptRunningTask(task.sessionKey, { freezePreview: true });
+        return { task, interrupted, steered: false };
     }
     /**
      * 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) {
+    interruptRunningTask(sessionKey, opts = {}) {
         const session = this.getSessionRuntimeByKey(sessionKey, { allowAnyWorkdir: true });
         if (!session)
             return false;
@@ -794,6 +837,7 @@ export class Bot {
             const task = this.activeTasks.get(taskId);
             if (!task || task.status !== 'running')
                 continue;
+            task.freezePreviewOnAbort = !!opts.freezePreview;
             try {
                 task.abort?.();
             }
@@ -995,8 +1039,8 @@ export class Bot {
     fetchSessions(agent) {
         return getSessions({ agent, workdir: this.workdir });
     }
-    fetchSessionTail(agent, sessionId, limit) {
-        return getSessionTail({ agent, sessionId, workdir: this.workdir, limit });
+    fetchSessionTail(agent, sessionId, limit, workdir = this.workdir) {
+        return getSessionTail({ agent, sessionId, workdir, limit });
     }
     fetchAgents(options = {}) {
         return listAgents(options);
@@ -1048,7 +1092,7 @@ export class Bot {
         return {
             version: VERSION, uptime: Date.now() - this.startedAt,
             memRss: mem.rss, memHeap: mem.heapUsed, pid: process.pid,
-            workdir: this.workdir, agent: cs.agent, model, sessionId: cs.sessionId,
+            workdir: selectedSession?.workdir || this.workdir, agent: cs.agent, model, sessionId: cs.sessionId,
             workspacePath: cs.workspacePath ?? null,
             running: fallbackTask, activeTasksCount: this.activeTasks.size, stats: this.stats,
             usage: getUsage({ agent: cs.agent, model }),
@@ -1143,12 +1187,15 @@ export class Bot {
         if (!opts.initial)
             this.onManagedConfigChange(config, opts);
     }
-    async runStream(prompt, cs, attachments, onText, systemPrompt, mcpSendFile, abortSignal, onCodexInteractionRequest) {
+    async runStream(prompt, cs, attachments, onText, systemPrompt, mcpSendFile, abortSignal, onCodexInteractionRequest, onSteerReady, onCodexTurnReady) {
         const resolvedModel = cs.modelId || this.modelForAgent(cs.agent);
         const agentConfig = this.agentConfigs[cs.agent] || {};
         const extraArgs = agentConfig.extraArgs || [];
         const browserEnabled = resolveGuiIntegrationConfig(getActiveUserConfig()).browserEnabled;
-        this.log(`[runStream] agent=${cs.agent} session=${cs.sessionId || '(new)'} workdir=${this.workdir} timeout=${this.runTimeout}s attachments=${attachments.length}`);
+        const sessionWorkdir = 'workdir' in cs && typeof cs.workdir === 'string' && cs.workdir
+            ? path.resolve(cs.workdir)
+            : this.workdir;
+        this.log(`[runStream] agent=${cs.agent} session=${cs.sessionId || '(new)'} workdir=${sessionWorkdir} timeout=${this.runTimeout}s attachments=${attachments.length}`);
         this.log(`[runStream] ${cs.agent} config: model=${resolvedModel} extraArgs=[${extraArgs.join(' ')}]`);
         const isFirstTurnOfSession = !cs.sessionId || isPendingSessionId(cs.sessionId);
         const mcpSystemPrompt = mcpSendFile
@@ -1158,7 +1205,7 @@ export class Bot {
             ? appendExtraPrompt(systemPrompt, mcpSystemPrompt)
             : undefined;
         const opts = {
-            agent: cs.agent, prompt, workdir: this.workdir, timeout: this.runTimeout,
+            agent: cs.agent, prompt, workdir: sessionWorkdir, timeout: this.runTimeout,
             sessionId: cs.sessionId, model: null,
             thinkingEffort: agentConfig.reasoningEffort || 'high', onText,
             attachments: attachments.length ? attachments : undefined,
@@ -1183,6 +1230,8 @@ export class Bot {
             mcpSendFile,
             abortSignal,
             onCodexInteractionRequest,
+            onSteerReady,
+            onCodexTurnReady,
         };
         const result = await doStream(opts);
         this.stats.totalTurns++;

package/dist/driver-claude.js

@@ -3,16 +3,18 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
-import { execSync } from 'node:child_process';
+import { execSync, spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
 import { registerDriver } from './agent-driver.js';
 import { 
 // shared helpers
-run, agentLog, detectAgentBin, pushRecentActivity, summarizeClaudeToolUse, summarizeClaudeToolResult, IMAGE_EXTS, mimeForExt, listPikiclawSessions, mergeManagedAndNativeSessions, readTailLines, stripInjectedPrompts, roundPercent, modelFamily, normalizeClaudeModelId, emptyUsage, normalizeUsageStatus, } from './code-agent.js';
-import { SESSION_RUNNING_THRESHOLD_MS } from './constants.js';
+Q, run, agentLog, detectAgentBin, buildStreamPreviewMeta, pushRecentActivity, summarizeClaudeToolUse, summarizeClaudeToolResult, joinErrorMessages, IMAGE_EXTS, mimeForExt, listPikiclawSessions, mergeManagedAndNativeSessions, readTailLines, stripInjectedPrompts, roundPercent, modelFamily, normalizeClaudeModelId, emptyUsage, normalizeUsageStatus, } from './code-agent.js';
+import { AGENT_STREAM_HARD_KILL_GRACE_MS, SESSION_RUNNING_THRESHOLD_MS } from './constants.js';
+import { terminateProcessTree } from './process-control.js';
 // ---------------------------------------------------------------------------
 // Multimodal stdin
 // ---------------------------------------------------------------------------
-function buildClaudeMultimodalStdin(prompt, attachments) {
+function buildClaudeUserMessage(prompt, attachments) {
     const content = [];
     for (const filePath of attachments) {
         const ext = path.extname(filePath).toLowerCase();
@@ -35,6 +37,10 @@ function buildClaudeMultimodalStdin(prompt, attachments) {
     content.push({ type: 'text', text: prompt });
     return JSON.stringify({ type: 'user', message: { role: 'user', content } }) + '\n';
 }
+function claudeUsesStreamJsonInput(o) {
+    return !!o.attachments?.length || !!o.onSteerReady;
+}
+const CLAUDE_STEER_IDLE_CLOSE_MS = 1200;
 // ---------------------------------------------------------------------------
 // Command & parser
 // ---------------------------------------------------------------------------
@@ -47,9 +53,12 @@ function claudeCmd(o) {
         args.push('--permission-mode', o.claudePermissionMode);
     if (o.sessionId)
         args.push('--resume', o.sessionId);
-    if (o.attachments?.length) {
+    if (claudeUsesStreamJsonInput(o)) {
         args.push('--input-format', 'stream-json');
-        o._stdinOverride = buildClaudeMultimodalStdin(o.prompt, o.attachments);
+        if (o.onSteerReady)
+            args.push('--replay-user-messages');
+        if (o.attachments?.length)
+            o._stdinOverride = buildClaudeUserMessage(o.prompt, o.attachments);
     }
     if (o.thinkingEffort)
         args.push('--effort', o.thinkingEffort);
@@ -183,14 +192,304 @@ function claudeParse(ev, s) {
         }
     }
 }
+function createClaudeStreamState(opts) {
+    return {
+        sessionId: opts.sessionId,
+        text: '',
+        thinking: '',
+        msgs: [],
+        thinkParts: [],
+        model: opts.model,
+        thinkingEffort: opts.thinkingEffort,
+        errors: null,
+        inputTokens: null,
+        outputTokens: null,
+        cachedInputTokens: null,
+        cacheCreationInputTokens: null,
+        contextWindow: null,
+        contextUsedTokens: null,
+        codexCumulative: null,
+        stopReason: null,
+        activity: '',
+        recentActivity: [],
+        claudeToolsById: new Map(),
+        seenClaudeToolIds: new Set(),
+    };
+}
+function resetClaudeTurnState(s, note) {
+    s.text = '';
+    s.thinking = '';
+    s.msgs = [];
+    s.thinkParts = [];
+    s.errors = null;
+    s.inputTokens = null;
+    s.outputTokens = null;
+    s.cachedInputTokens = null;
+    s.cacheCreationInputTokens = null;
+    s.contextUsedTokens = null;
+    s.stopReason = null;
+    s.activity = '';
+    s.recentActivity = [];
+    s.claudeToolsById = new Map();
+    s.seenClaudeToolIds = new Set();
+    if (note) {
+        pushRecentActivity(s.recentActivity, note);
+        s.activity = s.recentActivity.join('\n');
+    }
+}
+async function doClaudeInteractiveStream(opts) {
+    const start = Date.now();
+    const deadline = start + opts.timeout * 1000;
+    let stderr = '';
+    let lineCount = 0;
+    let timedOut = false;
+    let interrupted = false;
+    let stdinClosed = false;
+    let steerQueued = false;
+    let awaitingSteeredResponseStart = false;
+    let idleCloseTimer = null;
+    const s = createClaudeStreamState(opts);
+    const cmd = claudeCmd(opts);
+    const shellCmd = cmd.map(Q).join(' ');
+    agentLog(`[spawn] full command: cd ${Q(opts.workdir)} && ${shellCmd}`);
+    agentLog(`[spawn] timeout: ${opts.timeout}s session: ${opts.sessionId || '(new)'}`);
+    agentLog(`[spawn] prompt (stdin): "${opts.prompt.slice(0, 300)}${opts.prompt.length > 300 ? '…' : ''}"`);
+    const spawnEnv = { ...process.env, ...(opts.extraEnv || {}) };
+    delete spawnEnv.CLAUDECODE;
+    const proc = spawn(shellCmd, {
+        cwd: opts.workdir,
+        env: spawnEnv,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        shell: true,
+        detached: process.platform !== 'win32',
+    });
+    agentLog(`[spawn] pid=${proc.pid}`);
+    const closeInput = () => {
+        if (idleCloseTimer) {
+            clearTimeout(idleCloseTimer);
+            idleCloseTimer = null;
+        }
+        if (stdinClosed)
+            return;
+        stdinClosed = true;
+        try {
+            proc.stdin?.end();
+        }
+        catch { }
+    };
+    const emit = () => {
+        opts.onText(s.text, s.thinking, s.activity, buildStreamPreviewMeta(s), null);
+    };
+    const abortStream = () => {
+        if (interrupted || proc.killed)
+            return;
+        interrupted = true;
+        s.stopReason = 'interrupted';
+        closeInput();
+        agentLog(`[abort] user interrupt, killing process tree pid=${proc.pid}`);
+        terminateProcessTree(proc, { signal: 'SIGTERM', forceSignal: 'SIGKILL', forceAfterMs: 5000 });
+    };
+    if (opts.abortSignal?.aborted)
+        abortStream();
+    opts.abortSignal?.addEventListener('abort', abortStream, { once: true });
+    const scheduleIdleClose = () => {
+        if (idleCloseTimer)
+            clearTimeout(idleCloseTimer);
+        idleCloseTimer = setTimeout(() => {
+            idleCloseTimer = null;
+            if (stdinClosed || interrupted || timedOut || proc.killed || proc.exitCode != null)
+                return;
+            agentLog(`[stdin] closing Claude input after ${CLAUDE_STEER_IDLE_CLOSE_MS}ms idle result window`);
+            closeInput();
+        }, CLAUDE_STEER_IDLE_CLOSE_MS);
+    };
+    const startsClaudeFollowup = (ev) => {
+        const evType = ev?.type || '';
+        if (evType === 'assistant')
+            return true;
+        if (evType !== 'stream_event')
+            return false;
+        const innerType = ev?.event?.type || '';
+        return innerType === 'message_start' || innerType === 'content_block_delta';
+    };
+    const sendInput = (prompt, attachments = [], note, kind = 'steer') => {
+        if (stdinClosed || interrupted || timedOut || proc.killed || proc.exitCode != null)
+            return false;
+        try {
+            proc.stdin?.write(buildClaudeUserMessage(prompt, attachments));
+            if (kind === 'steer') {
+                steerQueued = true;
+                if (idleCloseTimer) {
+                    clearTimeout(idleCloseTimer);
+                    idleCloseTimer = null;
+                }
+            }
+            if (note) {
+                pushRecentActivity(s.recentActivity, note);
+                s.activity = s.recentActivity.join('\n');
+                emit();
+            }
+            return true;
+        }
+        catch (error) {
+            agentLog(`[stdin] failed to write Claude input: ${error?.message || error}`);
+            return false;
+        }
+    };
+    if (!sendInput(opts.prompt, opts.attachments || [], undefined, 'initial')) {
+        closeInput();
+    }
+    try {
+        opts.onSteerReady?.(async (prompt, attachments = []) => {
+            if (!sendInput(prompt, attachments, 'Queued steer input', 'steer'))
+                return false;
+            return true;
+        });
+    }
+    catch (error) {
+        agentLog(`[stdin] onSteerReady error: ${error?.message || error}`);
+    }
+    proc.stderr?.on('data', (c) => {
+        const chunk = c.toString();
+        stderr += chunk;
+        agentLog(`[stderr] ${chunk.trim().slice(0, 200)}`);
+    });
+    const rl = createInterface({ input: proc.stdout, crlfDelay: Infinity });
+    rl.on('line', raw => {
+        if (Date.now() > deadline) {
+            timedOut = true;
+            s.stopReason = 'timeout';
+            closeInput();
+            agentLog('[timeout] deadline exceeded, killing process tree');
+            terminateProcessTree(proc, { signal: 'SIGKILL' });
+            return;
+        }
+        const line = raw.trim();
+        if (!line || line[0] !== '{')
+            return;
+        lineCount++;
+        try {
+            const ev = JSON.parse(line);
+            const evType = ev.type || '?';
+            if (evType !== 'result' && idleCloseTimer) {
+                clearTimeout(idleCloseTimer);
+                idleCloseTimer = null;
+            }
+            if (awaitingSteeredResponseStart && startsClaudeFollowup(ev)) {
+                awaitingSteeredResponseStart = false;
+                steerQueued = false;
+                resetClaudeTurnState(s);
+            }
+            if (evType === 'system' || evType === 'result' || evType === 'assistant') {
+                agentLog(`[event] type=${evType} session=${ev.session_id || s.sessionId || '?'} model=${ev.model || s.model || '?'}`);
+            }
+            if (evType === 'stream_event') {
+                const inner = ev.event || {};
+                if (inner.type === 'message_start' || inner.type === 'message_delta') {
+                    agentLog(`[event] stream_event/${inner.type} session=${ev.session_id || s.sessionId || '?'}`);
+                }
+            }
+            claudeParse(ev, s);
+            if (evType === 'result') {
+                const hasError = !!ev.is_error || (Array.isArray(ev.errors) && ev.errors.length > 0);
+                if (hasError) {
+                    awaitingSteeredResponseStart = false;
+                    steerQueued = false;
+                    closeInput();
+                }
+                else if (steerQueued) {
+                    awaitingSteeredResponseStart = true;
+                    scheduleIdleClose();
+                }
+                else {
+                    closeInput();
+                }
+            }
+            emit();
+        }
+        catch { }
+    });
+    const hardTimer = setTimeout(() => {
+        timedOut = true;
+        s.stopReason = 'timeout';
+        closeInput();
+        agentLog(`[timeout] hard deadline reached (${opts.timeout}s), killing process tree pid=${proc.pid}`);
+        terminateProcessTree(proc, { signal: 'SIGTERM', forceSignal: 'SIGKILL', forceAfterMs: 5000 });
+    }, opts.timeout * 1000 + AGENT_STREAM_HARD_KILL_GRACE_MS);
+    const [procOk, code] = await new Promise(resolve => {
+        proc.on('close', code => {
+            clearTimeout(hardTimer);
+            if (idleCloseTimer) {
+                clearTimeout(idleCloseTimer);
+                idleCloseTimer = null;
+            }
+            agentLog(`[exit] code=${code} lines_parsed=${lineCount}`);
+            resolve([code === 0, code]);
+        });
+        proc.on('error', e => {
+            clearTimeout(hardTimer);
+            if (idleCloseTimer) {
+                clearTimeout(idleCloseTimer);
+                idleCloseTimer = null;
+            }
+            agentLog(`[error] ${e.message}`);
+            stderr += e.message;
+            resolve([false, -1]);
+        });
+    });
+    opts.abortSignal?.removeEventListener('abort', abortStream);
+    if (!s.text.trim() && s.msgs.length)
+        s.text = s.msgs.join('\n\n');
+    if (!s.thinking.trim() && s.thinkParts.length)
+        s.thinking = s.thinkParts.join('\n\n');
+    const errorText = joinErrorMessages(s.errors);
+    const ok = procOk && !s.errors && !timedOut && !interrupted;
+    const error = errorText
+        || (interrupted ? 'Interrupted by user.' : null)
+        || (timedOut ? `Timed out after ${opts.timeout}s before the agent reported completion.` : null)
+        || (!procOk ? (stderr.trim() || `Failed (exit=${code}).`) : null);
+    const incomplete = !ok || s.stopReason === 'max_tokens' || s.stopReason === 'timeout';
+    const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+    agentLog(`[result] ok=${ok && !s.errors} elapsed=${elapsed}s text=${s.text.length}chars thinking=${s.thinking.length}chars session=${s.sessionId || '?'}`);
+    if (errorText)
+        agentLog(`[result] errors: ${errorText}`);
+    if (s.stopReason)
+        agentLog(`[result] stop_reason=${s.stopReason}`);
+    if (stderr.trim() && !procOk)
+        agentLog(`[result] stderr: ${stderr.trim().slice(0, 300)}`);
+    return {
+        ok,
+        sessionId: s.sessionId,
+        workspacePath: null,
+        model: s.model,
+        thinkingEffort: s.thinkingEffort,
+        message: s.text.trim() || errorText || (procOk ? '(no textual response)' : `Failed (exit=${code}).\n\n${stderr.trim() || '(no output)'}`),
+        thinking: s.thinking.trim() || null,
+        elapsedS: (Date.now() - start) / 1000,
+        inputTokens: s.inputTokens,
+        outputTokens: s.outputTokens,
+        cachedInputTokens: s.cachedInputTokens,
+        cacheCreationInputTokens: s.cacheCreationInputTokens,
+        contextWindow: s.contextWindow,
+        contextUsedTokens: s.contextUsedTokens,
+        contextPercent: roundPercent((s.contextUsedTokens || 0) / (s.contextWindow || 0)),
+        codexCumulative: null,
+        error,
+        stopReason: s.stopReason,
+        incomplete,
+        activity: s.activity.trim() || null,
+    };
+}
 // ---------------------------------------------------------------------------
 // Stream
 // ---------------------------------------------------------------------------
 export async function doClaudeStream(opts) {
-    const result = await run(claudeCmd(opts), opts, claudeParse);
+    const result = opts.onSteerReady
+        ? await doClaudeInteractiveStream(opts)
+        : await run(claudeCmd(opts), opts, claudeParse);
     const retryText = `${result.error || ''}\n${result.message}`;
     if (!result.ok && opts.sessionId && /no conversation found/i.test(retryText)) {
-        return run(claudeCmd({ ...opts, sessionId: null }), { ...opts, sessionId: null }, claudeParse);
+        return doClaudeStream({ ...opts, sessionId: null });
     }
     return result;
 }

package/dist/driver-codex.js

@@ -95,7 +95,15 @@ export class CodexAppServer {
                 }
             });
             proc.on('error', () => { clearTimeout(timer); this.ready = false; resolve(false); });
-            proc.on('close', () => { this.ready = false; this.proc = null; });
+            proc.on('close', () => {
+                this.ready = false;
+                this.proc = null;
+                // Resolve any pending RPC calls so callers don't hang forever
+                for (const [id, cb] of this.pending) {
+                    cb({ error: { message: 'process exited before responding' } });
+                }
+                this.pending.clear();
+            });
             this.call('initialize', { clientInfo: { name: 'pikiclaw', version: '0.2.0' } })
                 .then(resp => {
                 clearTimeout(timer);
@@ -111,14 +119,24 @@ export class CodexAppServer {
                 .catch(() => { clearTimeout(timer); resolve(false); });
         });
     }
-    call(method, params) {
+    call(method, params, timeoutMs) {
         return new Promise((resolve) => {
             if (!this.proc || this.proc.killed) {
                 resolve({ error: { message: 'not connected' } });
                 return;
             }
             const id = this.nextId++;
-            this.pending.set(id, resolve);
+            const wrappedResolve = (result) => {
+                if (timer)
+                    clearTimeout(timer);
+                this.pending.delete(id);
+                resolve(result);
+            };
+            const timer = timeoutMs ? setTimeout(() => {
+                this.pending.delete(id);
+                resolve({ error: { message: `RPC call '${method}' timed out after ${timeoutMs}ms` } });
+            }, timeoutMs) : null;
+            this.pending.set(id, wrappedResolve);
             const msg = { jsonrpc: '2.0', id, method };
             if (params !== undefined)
                 msg.params = params;
@@ -126,6 +144,9 @@ export class CodexAppServer {
                 this.proc.stdin.write(JSON.stringify(msg) + '\n');
             }
             catch {
+                if (timer)
+                    clearTimeout(timer);
+                this.pending.delete(id);
                 resolve({ error: { message: 'write failed' } });
             }
         });
@@ -238,6 +259,34 @@ function summarizeCodexFileChange(item) {
         return `Updated ${paths.length} files`;
     return 'Updated files';
 }
+function summarizeCodexRawResponseItem(item) {
+    if (!item || typeof item !== 'object')
+        return null;
+    switch (item.type) {
+        case 'web_search_call': {
+            const action = item.action || {};
+            if (action.type === 'search') {
+                const query = shortValue(action.query, 120);
+                return query ? `Search web: ${query}` : 'Search web';
+            }
+            if (action.type === 'open_page') {
+                const url = shortValue(action.url, 120);
+                return url ? `Open ${url}` : 'Open web page';
+            }
+            return 'Search web';
+        }
+        case 'custom_tool_call': {
+            const name = shortValue(item.name, 80);
+            return name ? `Use ${name}` : 'Use tool';
+        }
+        case 'local_shell_call': {
+            const command = shortValue(item.action?.command || item.action?.cmd, 120);
+            return command ? `Run shell command: ${command}` : 'Run shell command';
+        }
+        default:
+            return null;
+    }
+}
 function buildCodexInteractionRequest(method, params, requestId) {
     if (method === 'item/tool/requestUserInput') {
         const questions = Array.isArray(params?.questions) ? params.questions : [];
@@ -423,7 +472,7 @@ function codexErrorResult(error, start, sessionId, model, thinkingEffort) {
 // ---------------------------------------------------------------------------
 // Stream notification handler (extracted from doCodexStream)
 // ---------------------------------------------------------------------------
-function handleCodexNotification(method, params, s, opts, deadline, emit, hardTimer, settleTurnDone) {
+function handleCodexNotification(method, params, s, opts, deadline, emit, hardTimer, settleTurnDone, publishTurnControl) {
     if (Date.now() > deadline)
         return;
     if (params.threadId !== s.sessionId) {
@@ -448,6 +497,9 @@ function handleCodexNotification(method, params, s, opts, deadline, emit, hardTi
         case 'item/completed':
             handleItemCompleted(params.item || {}, s, emit);
             return;
+        case 'rawResponseItem/completed':
+            handleRawResponseItemCompleted(params.item || {}, s, emit);
+            return;
         case 'thread/tokenUsage/updated':
             applyCodexTokenUsage(s, params.tokenUsage, opts.codexPrevCumulative);
             emit();
@@ -475,6 +527,7 @@ function handleCodexNotification(method, params, s, opts, deadline, emit, hardTi
         }
         case 'turn/started':
             s.turnId = params.turn?.id ?? null;
+            publishTurnControl?.();
             return;
         case 'model/rerouted':
             s.model = params.model ?? s.model;
@@ -537,6 +590,27 @@ function handleItemCompleted(item, s, emit) {
         emit();
     }
 }
+function handleRawResponseItemCompleted(item, s, emit) {
+    if (item?.type === 'reasoning') {
+        const summary = Array.isArray(item.summary)
+            ? item.summary
+                .map((entry) => (typeof entry === 'string' ? entry : entry?.text || ''))
+                .filter(Boolean)
+                .join('\n')
+                .trim()
+            : '';
+        if (summary) {
+            s.thinkParts.push(summary);
+            emit();
+            return;
+        }
+    }
+    const summary = summarizeCodexRawResponseItem(item);
+    if (!summary)
+        return;
+    pushRecentActivity(s.recentNarrative, summary);
+    emit();
+}
 function handleCompletedAgentMessage(item, s, emit) {
     const phase = item.phase || s.messagePhases.get(item.id) || 'final_answer';
     if (phase === 'final_answer') {
@@ -620,6 +694,8 @@ export async function doCodexStream(opts) {
     let unsubscribeNotifications = () => { };
     let unsubscribeRequests = () => { };
     let settleTurnDone = null;
+    let emitPreview = () => { };
+    let publishedTurnControl = false;
     try {
         const config = [];
         if (opts.codexExtraArgs?.length) {
@@ -632,6 +708,45 @@ export async function doCodexStream(opts) {
             return codexErrorResult('Failed to start codex app-server.', start, opts.sessionId, opts.model, opts.thinkingEffort);
         }
         const s = createCodexStreamState(opts);
+        const publishTurnControl = () => {
+            if (publishedTurnControl || !opts.onCodexTurnReady || !s.sessionId || !s.turnId)
+                return;
+            publishedTurnControl = true;
+            try {
+                const control = {
+                    threadId: s.sessionId,
+                    turnId: s.turnId,
+                    steer: async (prompt, attachments = []) => {
+                        if (!s.sessionId || !s.turnId)
+                            return false;
+                        const expectedTurnId = s.turnId;
+                        const clippedPrompt = prompt.slice(0, 200);
+                        agentLog(`[codex-rpc] turn/steer turn=${expectedTurnId} prompt="${clippedPrompt}${prompt.length > 200 ? '…' : ''}"`);
+                        const steerResp = await srv.call('turn/steer', {
+                            threadId: s.sessionId,
+                            expectedTurnId,
+                            input: buildCodexTurnInput(prompt, attachments),
+                        }, 30_000);
+                        if (steerResp.error) {
+                            const errMsg = steerResp.error.message || 'turn/steer failed';
+                            agentLog(`[codex-rpc] turn/steer error: ${errMsg}`);
+                            pushRecentActivity(s.recentFailures, `Steer failed: ${shortValue(errMsg, 120)}`, 4);
+                            emitPreview();
+                            return false;
+                        }
+                        s.turnId = steerResp.result?.turnId ?? s.turnId;
+                        pushRecentActivity(s.recentNarrative, 'Applied steer input');
+                        emitPreview();
+                        return true;
+                    },
+                };
+                opts.onSteerReady?.(control.steer);
+                opts.onCodexTurnReady?.(control);
+            }
+            catch (error) {
+                agentLog(`[codex-rpc] onCodexTurnReady error: ${error?.message || error}`);
+            }
+        };
         // thread/start or thread/resume
         let threadResp;
         const threadParams = {
@@ -643,11 +758,11 @@ export async function doCodexStream(opts) {
         };
         if (opts.sessionId) {
             agentLog(`[codex-rpc] thread/resume id=${opts.sessionId}`);
-            threadResp = await srv.call('thread/resume', { threadId: opts.sessionId, ...threadParams });
+            threadResp = await srv.call('thread/resume', { threadId: opts.sessionId, ...threadParams }, 60_000);
         }
         else {
             agentLog(`[codex-rpc] thread/start cwd=${opts.workdir} model=${opts.codexModel || '(default)'}`);
-            threadResp = await srv.call('thread/start', threadParams);
+            threadResp = await srv.call('thread/start', threadParams, 60_000);
         }
         if (threadResp.error) {
             const errMsg = threadResp.error.message || 'thread/start failed';
@@ -689,8 +804,9 @@ export async function doCodexStream(opts) {
                 s.activity = buildCodexActivityPreview(s);
                 opts.onText(s.text, s.thinking, s.activity, buildStreamPreviewMeta(s), s.plan);
             };
+            emitPreview = emit;
             unsubscribeNotifications = srv.onNotification((method, params) => {
-                handleCodexNotification(method, params, s, opts, deadline, emit, hardTimer, settleTurnDone);
+                handleCodexNotification(method, params, s, opts, deadline, emit, hardTimer, settleTurnDone, publishTurnControl);
             });
             unsubscribeRequests = srv.onRequest((method, params, requestId) => {
                 return handleCodexRequest(method, params, requestId, s, opts, emit);
@@ -704,10 +820,16 @@ export async function doCodexStream(opts) {
             s.turnError = s.turnError || 'Interrupted by user.';
             agentLog(`[codex-rpc] abort requested thread=${s.sessionId || '?'} turn=${s.turnId || '?'}`);
             if (s.turnId && s.sessionId) {
-                srv.call('turn/interrupt', { threadId: s.sessionId, turnId: s.turnId }).catch(() => { });
+                // Send turn/interrupt and wait for Codex to acknowledge before settling.
+                // Don't kill the process here — let the finally block handle it after
+                // Codex has had time to persist the interrupted session state.
+                srv.call('turn/interrupt', { threadId: s.sessionId, turnId: s.turnId }, 5_000)
+                    .finally(() => settleTurnDone?.());
+            }
+            else {
+                srv.kill();
+                settleTurnDone?.();
             }
-            srv.kill();
-            settleTurnDone?.();
         };
         if (opts.abortSignal?.aborted)
             abortStream();
@@ -732,7 +854,7 @@ export async function doCodexStream(opts) {
             threadId: s.sessionId, input,
             model: opts.codexModel || undefined,
             effort: mapEffort(opts.thinkingEffort),
-        });
+        }, 60_000);
         if (turnResp.error) {
             opts.abortSignal?.removeEventListener('abort', abortStream);
             unsubscribeNotifications();
@@ -742,6 +864,7 @@ export async function doCodexStream(opts) {
             return codexErrorResult(errMsg, start, s.sessionId, s.model, s.thinkingEffort);
         }
         s.turnId = turnResp.result?.turn?.id ?? null;
+        publishTurnControl();
         await turnDone;
         opts.abortSignal?.removeEventListener('abort', abortStream);
         unsubscribeNotifications();

package/package.json

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