pikiclaw 0.3.49 → 0.3.50

package/dist/agent/drivers/claude.js

@@ -8,7 +8,7 @@ import { createInterface } from 'node:readline';
 import { registerDriver } from '../driver.js';
 import { 
 // shared helpers
-Q, run, agentError, agentLog, agentWarn, buildStreamPreviewMeta, computeContext, pushRecentActivity, summarizeClaudeToolUse, summarizeClaudeToolResult, joinErrorMessages, parseTodoWriteAsPlan, emitSessionIdUpdate, IMAGE_EXTS, mimeForExt, listPikiclawSessions, mergeManagedAndNativeSessions, readTailLines, stripInjectedPrompts, sanitizeSessionUserPreviewText, SESSION_PREVIEW_IMAGE_PLACEHOLDER_RE, CLAUDE_AT_MENTION_IMAGE_RE, extractClaudeAtMentionImagePaths, attachAgentImage, applyTurnWindow, shortValue, roundPercent, modelFamily, normalizeClaudeModelId, emptyUsage, normalizeUsageStatus, collapseSkillPrompt, } from '../index.js';
+Q, run, agentError, agentLog, agentWarn, buildStreamPreviewMeta, computeContext, pushRecentActivity, summarizeClaudeToolUse, summarizeClaudeToolResult, joinErrorMessages, parseTodoWriteAsPlan, detectClaudeApiError, isRetryableClaudeApiError, emitSessionIdUpdate, IMAGE_EXTS, mimeForExt, listPikiclawSessions, mergeManagedAndNativeSessions, readTailLines, stripInjectedPrompts, sanitizeSessionUserPreviewText, SESSION_PREVIEW_IMAGE_PLACEHOLDER_RE, CLAUDE_AT_MENTION_IMAGE_RE, extractClaudeAtMentionImagePaths, attachAgentImage, applyTurnWindow, shortValue, roundPercent, modelFamily, normalizeClaudeModelId, emptyUsage, normalizeUsageStatus, collapseSkillPrompt, } from '../index.js';
 import { AGENT_STREAM_HARD_KILL_GRACE_MS, AGENT_GRACEFUL_ABORT_GRACE_MS, SESSION_RUNNING_THRESHOLD_MS } from '../../core/constants.js';
 import { terminateProcessTree } from '../../core/process-control.js';
 import { getHome, IS_MAC, encodePathAsDirName } from '../../core/platform.js';
@@ -270,6 +270,48 @@ function accumulateClaudeImagesFromContent(content, s) {
         }
     }
 }
+/**
+ * Read the server-assigned task id from a TaskCreate tool_result. Claude
+ * surfaces it via the structured `ev.toolUseResult.task.id` companion field,
+ * with a textual fallback ("Task #N created successfully: …") that we parse
+ * if the structured form is missing.
+ */
+function readClaudeTaskCreateId(ev, block) {
+    const structured = ev?.toolUseResult?.task?.id;
+    if (structured != null && String(structured).trim())
+        return String(structured).trim();
+    const content = block?.content;
+    if (typeof content === 'string') {
+        const match = content.match(/Task #(\d+)/);
+        if (match)
+            return match[1];
+    }
+    return null;
+}
+/**
+ * Rebuild s.plan from the accumulated TaskCreate / TaskUpdate state so the
+ * dashboard + IM plan card show the canonical Claude Code 2.x task progress.
+ * Order follows insertion order (matches the on-screen Claude task list).
+ */
+function rebuildClaudePlanFromTasks(s) {
+    if (!s.claudeTaskOrder?.length) {
+        // Nothing to render — leave s.plan alone so TodoWrite-era data (if any)
+        // doesn't get clobbered by an empty rebuild.
+        return;
+    }
+    const steps = [];
+    for (const id of s.claudeTaskOrder) {
+        const task = s.claudeTaskList.get(id);
+        if (!task)
+            continue;
+        const lowered = String(task.status || '').toLowerCase();
+        const status = lowered === 'completed' ? 'completed'
+            : lowered === 'in_progress' || lowered === 'inprogress' ? 'inProgress'
+                : 'pending';
+        steps.push({ step: task.subject, status });
+    }
+    s.plan = { explanation: null, steps };
+}
 export function claudeParse(ev, s) {
     const t = ev.type || '';
     // Sub-agent events (Task tool spawns a child agent) carry parent_tool_use_id
@@ -374,7 +416,7 @@ export function claudeParse(ev, s) {
             if (!toolId || s.seenClaudeToolIds.has(toolId))
                 continue;
             const toolName = String(block?.name || 'Tool').trim() || 'Tool';
-            // TodoWrite → update plan instead of adding activity noise
+            // TodoWrite → update plan instead of adding activity noise (Claude Code 1.x)
             if (toolName === 'TodoWrite') {
                 const plan = parseTodoWriteAsPlan(block?.input);
                 if (plan)
@@ -383,6 +425,38 @@ export function claudeParse(ev, s) {
                 s.claudeToolsById.set(toolId, { name: toolName, summary: 'Update plan' });
                 continue;
             }
+            // TaskCreate / TaskUpdate → 2.x plan tools. Same intent as TodoWrite, but
+            // emitted one task at a time. Buffer TaskCreate inputs until the matching
+            // tool_result arrives with the server-assigned id; apply TaskUpdate status
+            // changes against the running map. Both rebuild s.plan so the dashboard /
+            // IM plan card keeps surfacing total + current progress.
+            if (toolName === 'TaskCreate') {
+                const subject = typeof block?.input?.subject === 'string' ? block.input.subject.trim() : '';
+                if (subject)
+                    s.pendingClaudeTaskCreates.set(toolId, { subject });
+                s.seenClaudeToolIds.add(toolId);
+                s.claudeToolsById.set(toolId, { name: toolName, summary: subject ? `Create task: ${subject}` : 'Create task' });
+                continue;
+            }
+            if (toolName === 'TaskUpdate') {
+                const taskId = String(block?.input?.taskId ?? '').trim();
+                const rawStatus = String(block?.input?.status ?? '').trim().toLowerCase();
+                if (taskId) {
+                    if (rawStatus === 'deleted') {
+                        s.claudeTaskList.delete(taskId);
+                        s.claudeTaskOrder = s.claudeTaskOrder.filter((id) => id !== taskId);
+                    }
+                    else if (rawStatus) {
+                        const existing = s.claudeTaskList.get(taskId);
+                        if (existing)
+                            existing.status = rawStatus;
+                    }
+                    rebuildClaudePlanFromTasks(s);
+                }
+                s.seenClaudeToolIds.add(toolId);
+                s.claudeToolsById.set(toolId, { name: toolName, summary: `Update task ${taskId || '?'} → ${rawStatus || 'unknown'}` });
+                continue;
+            }
             // Task → represents a sub-agent invocation. Carve it out as its own
             // streamed unit so the child's tool stream and model don't bleed into
             // the parent's activity card.
@@ -418,10 +492,37 @@ export function claudeParse(ev, s) {
         const toolResults = contents.filter((b) => b?.type === 'tool_result');
         for (const block of toolResults) {
             const toolId = String(block?.tool_use_id || '').trim();
+            // Dedup against tool_results already pushed by the TUI hook stream —
+            // PreToolUse / PostToolUse arrive in real time, JSONL eventually
+            // delivers the same events at end-of-turn and would otherwise re-push
+            // each summary into activity / re-process TaskCreate's plan entry.
+            if (toolId && s.seenClaudeToolResultIds?.has(toolId))
+                continue;
+            if (toolId) {
+                if (!s.seenClaudeToolResultIds)
+                    s.seenClaudeToolResultIds = new Set();
+                s.seenClaudeToolResultIds.add(toolId);
+            }
             const tool = toolId ? s.claudeToolsById.get(toolId) : undefined;
-            // Skip TodoWrite results from activity — plan card handles it
+            // Skip TodoWrite / TaskCreate / TaskUpdate results from activity — plan
+            // card handles them. TaskCreate's tool_result carries the assigned task
+            // id, which we splice into the running task list before skipping.
             if (tool?.name === 'TodoWrite')
                 continue;
+            if (tool?.name === 'TaskCreate') {
+                const pending = toolId ? s.pendingClaudeTaskCreates.get(toolId) : undefined;
+                const assignedId = readClaudeTaskCreateId(ev, block);
+                if (pending && assignedId) {
+                    s.pendingClaudeTaskCreates.delete(toolId);
+                    if (!s.claudeTaskList.has(assignedId))
+                        s.claudeTaskOrder.push(assignedId);
+                    s.claudeTaskList.set(assignedId, { subject: pending.subject, status: 'pending' });
+                    rebuildClaudePlanFromTasks(s);
+                }
+                continue;
+            }
+            if (tool?.name === 'TaskUpdate')
+                continue;
             // Sub-agent tool_result closes out the sub-agent's lifecycle — flip its
             // status and skip the regular activity append (the sub-agent card carries
             // it). The result content text is the sub-agent's full response which
@@ -517,6 +618,17 @@ export function createClaudeStreamState(opts) {
         activity: '',
         recentActivity: [],
         plan: null,
+        // Claude Code 2.x replaced the single `TodoWrite` plan tool with two
+        // separate tools — `TaskCreate` (one task per call, server-assigned id)
+        // and `TaskUpdate` (taskId + status). We maintain an ordered map and
+        // rebuild s.plan whenever either fires so the dashboard / IM plan card
+        // keeps showing total / current progress just like the TodoWrite era.
+        claudeTaskList: new Map(),
+        claudeTaskOrder: [],
+        /** Pending TaskCreate tool_uses indexed by tool_use id — the input
+         *  carries the subject but Claude assigns the numeric task id only in
+         *  the matching tool_result, so we have to bridge the two halves. */
+        pendingClaudeTaskCreates: new Map(),
         claudeToolsById: new Map(),
         seenClaudeToolIds: new Set(),
         subAgents: new Map(),
@@ -811,6 +923,19 @@ async function doClaudeInteractiveStream(opts) {
         s.text = s.msgs.join('\n\n');
     if (!s.thinking.trim() && s.thinkParts.length)
         s.thinking = s.thinkParts.join('\n\n');
+    // Catch the Claude CLI's synthetic "API Error: …" assistant body (transient
+    // Anthropic 5xx / 529 Overloaded). Without this rewrite the raw error string
+    // gets surfaced into the IM card as if it were Claude's reply, and the
+    // retry wrapper in `doClaudeStream` can't tell a transient failure apart
+    // from a real short reply.
+    const apiErrorReason = detectClaudeApiError(s.text);
+    if (apiErrorReason) {
+        agentWarn(`[claude] upstream API error detected: ${apiErrorReason}`);
+        s.stopReason = 'api_error';
+        s.text = '';
+        if (!s.errors)
+            s.errors = [`Anthropic API error: ${apiErrorReason}`];
+    }
     const errorText = joinErrorMessages(s.errors);
     const ok = procOk && !s.errors && !timedOut && !interrupted;
     const error = errorText
@@ -1915,6 +2040,103 @@ export function isClaudePrintModeForced() {
         return true;
     return false;
 }
+/**
+ * Single-attempt dispatch: print mode when forced via env, otherwise TUI mode
+ * with print-mode fallback if TUI prerequisites are missing (node-pty absent,
+ * PTY allocation refused, …).
+ */
+async function doClaudeStreamOnce(opts) {
+    if (isClaudePrintModeForced()) {
+        agentLog('[claude] print mode forced via env, using -p');
+        return doClaudeStream(opts);
+    }
+    try {
+        const mod = await import('./claude-tui.js');
+        return await mod.doClaudeTuiStream(opts);
+    }
+    catch (err) {
+        // TUI prerequisite failed (node-pty missing, PTY allocation refused, etc.).
+        // Fall back to print mode so pikiclaw stays functional — with the caveat
+        // that this turn lands on the Agent SDK credit pool.
+        agentWarn(`[claude] TUI unavailable (${err?.message || err}); falling back to -p — this turn bills the Agent SDK credit pool`);
+        return doClaudeStream(opts);
+    }
+}
+/**
+ * Backoff schedule (in ms) for retrying transient Anthropic upstream failures
+ * — 529 Overloaded, 5xx, gateway timeouts. Total wait budget ~30s before we
+ * surface the failure to the user. Non-retryable errors (auth, quota,
+ * context-length) skip the loop and fail fast.
+ */
+const CLAUDE_API_RETRY_BACKOFFS_MS = [4000, 12000];
+function makeOverloadFriendlyResult(result, reason, attempts) {
+    const wait = CLAUDE_API_RETRY_BACKOFFS_MS.slice(0, attempts).reduce((sum, ms) => sum + ms, 0);
+    const elapsedNote = wait > 0 ? ` (retried ${attempts}× over ${Math.round(wait / 1000)}s)` : '';
+    const message = [
+        `Anthropic API temporarily overloaded${elapsedNote}.`,
+        `Reason from upstream: ${reason}.`,
+        'Please re-send your last message in a moment — your session is intact and will resume from where it stopped.',
+    ].join(' ');
+    return {
+        ...result,
+        ok: false,
+        incomplete: true,
+        stopReason: 'api_error',
+        message,
+        error: `Anthropic API error: ${reason}`,
+    };
+}
+/**
+ * Driver-entry wrapper. Detects the Claude CLI's synthetic "API Error: …"
+ * assistant turn and re-issues the request with backoff for retryable upstream
+ * conditions (Overloaded, 5xx, timeouts). Non-retryable failures surface
+ * immediately. After the budget is exhausted, the final result carries a
+ * friendly human-readable explanation in `message` so the IM card doesn't
+ * dump raw "API Error: Overloaded" text on the user.
+ */
+async function doClaudeWithRetry(opts) {
+    let lastResult = await doClaudeStreamOnce(opts);
+    let attempts = 0;
+    // Use the error text recorded by detectClaudeApiError-driven branches to
+    // decide retry: lastResult.error is "Anthropic API error: <reason>" on
+    // detection, undefined otherwise.
+    const reasonOf = (r) => {
+        if (r.stopReason !== 'api_error')
+            return null;
+        const m = (r.error || '').match(/^Anthropic API error:\s*(.+)$/i);
+        return m ? m[1].trim() : null;
+    };
+    while (attempts < CLAUDE_API_RETRY_BACKOFFS_MS.length) {
+        const reason = reasonOf(lastResult);
+        if (!reason || !isRetryableClaudeApiError(reason))
+            break;
+        const wait = CLAUDE_API_RETRY_BACKOFFS_MS[attempts];
+        attempts++;
+        agentWarn(`[claude] API error "${reason}", retry ${attempts}/${CLAUDE_API_RETRY_BACKOFFS_MS.length} after ${wait}ms`);
+        if (opts.abortSignal?.aborted) {
+            agentWarn('[claude] retry skipped — abort signal already fired');
+            break;
+        }
+        await new Promise(r => setTimeout(r, wait));
+        if (opts.abortSignal?.aborted) {
+            agentWarn('[claude] retry skipped after backoff — abort signal fired');
+            break;
+        }
+        // Resume the same session so we don't restart from scratch. The previous
+        // attempt may have written a synthetic "API Error" assistant block into
+        // the JSONL; Claude resumes past it and re-answers the user's prompt.
+        const nextOpts = {
+            ...opts,
+            sessionId: lastResult.sessionId || opts.sessionId,
+        };
+        lastResult = await doClaudeStreamOnce(nextOpts);
+    }
+    const finalReason = reasonOf(lastResult);
+    if (finalReason) {
+        return makeOverloadFriendlyResult(lastResult, finalReason, attempts);
+    }
+    return lastResult;
+}
 class ClaudeDriver {
     id = 'claude';
     cmd = 'claude';
@@ -1926,21 +2148,7 @@ class ClaudeDriver {
     // `/anthropic/v1`, …). cf. src/model/injector.ts:claudeInjector.
     acceptedProviderKinds = ['anthropic', 'openai-compatible'];
     async doStream(opts) {
-        if (isClaudePrintModeForced()) {
-            agentLog('[claude] print mode forced via env, using -p');
-            return doClaudeStream(opts);
-        }
-        try {
-            const mod = await import('./claude-tui.js');
-            return await mod.doClaudeTuiStream(opts);
-        }
-        catch (err) {
-            // TUI prerequisite failed (node-pty missing, PTY allocation refused,
-            // etc.). Fall back to print mode so pikiclaw stays functional — with
-            // the caveat that this turn lands on the Agent SDK credit pool.
-            agentWarn(`[claude] TUI unavailable (${err?.message || err}); falling back to -p — this turn bills the Agent SDK credit pool`);
-            return doClaudeStream(opts);
-        }
+        return doClaudeWithRetry(opts);
     }
     async getSessions(workdir, limit) {
         return getClaudeSessions(workdir, limit);

package/dist/agent/index.js

@@ -21,7 +21,7 @@ export { IMAGE_EXTS } from './types.js';
 // ── Re-export: image pipeline ──────────────────────────────────────────────
 export { attachAgentImage, attachInlineImage, materializeImage, rewriteImageBlocksForTransport, resolveAllowedAttachmentPath, allowedAttachmentRoots, decodeAttachmentPathParam, sessionAttachmentsDir, codexHome, } from './images.js';
 // ── Re-export: utilities ────────────────────────────────────────────────────
-export { Q, agentLog, agentWarn, agentError, dedupeStrings, numberOrNull, normalizeStreamPreviewPlan, parseTodoWriteAsPlan, normalizeActivityLine, pushRecentActivity, firstNonEmptyLine, shortValue, normalizeErrorMessage, joinErrorMessages, appendSystemPrompt, mimeForExt, computeContext, buildStreamPreviewMeta, summarizeClaudeToolUse, summarizeClaudeToolResult, roundPercent, toIsoFromEpochSeconds, normalizeUsageStatus, labelFromWindowMinutes, usageWindowFromRateLimit, parseJsonTail, modelFamily, normalizeClaudeModelId, emptyUsage, readTailLines, stripInjectedPrompts, sanitizeSessionUserPreviewText, SESSION_PREVIEW_IMAGE_PLACEHOLDER_RE, CLAUDE_AT_MENTION_IMAGE_RE, extractClaudeAtMentionImagePaths, stripClaudeAtMentionImages, isPendingSessionId, emitSessionIdUpdate, sessionListDisplayTitle, } from './utils.js';
+export { Q, agentLog, agentWarn, agentError, dedupeStrings, numberOrNull, normalizeStreamPreviewPlan, parseTodoWriteAsPlan, normalizeActivityLine, pushRecentActivity, detectClaudeApiError, isRetryableClaudeApiError, firstNonEmptyLine, shortValue, normalizeErrorMessage, joinErrorMessages, appendSystemPrompt, mimeForExt, computeContext, buildStreamPreviewMeta, summarizeClaudeToolUse, summarizeClaudeToolResult, roundPercent, toIsoFromEpochSeconds, normalizeUsageStatus, labelFromWindowMinutes, usageWindowFromRateLimit, parseJsonTail, modelFamily, normalizeClaudeModelId, emptyUsage, readTailLines, stripInjectedPrompts, sanitizeSessionUserPreviewText, SESSION_PREVIEW_IMAGE_PLACEHOLDER_RE, CLAUDE_AT_MENTION_IMAGE_RE, extractClaudeAtMentionImagePaths, stripClaudeAtMentionImages, isPendingSessionId, emitSessionIdUpdate, sessionListDisplayTitle, } from './utils.js';
 // ── Re-export: session management ───────────────────────────────────────────
 export { updateSessionMeta, promoteSessionId, recordFork, listPikiclawSessions, findPikiclawSession, getSessionStoredConfig, ensureManagedSession, findManagedThreadSession, stageSessionFiles, mergeManagedAndNativeSessions, getSessions, getSessionTail, getSessionMessages, applyTurnWindow, applyTurnFilter, classifySession, deriveUserStatus, exportSession, importSession, deleteAgentSession, isProcessAlive, isRunningSessionStale, reconcileOrphanedRunningSessions, } from './session.js';
 // ── Re-export: stream & detection ───────────────────────────────────────────

package/dist/agent/utils.js

@@ -166,6 +166,42 @@ export function joinErrorMessages(errors) {
         return '';
     return errors.map(error => normalizeErrorMessage(error)).filter(Boolean).join('; ').trim();
 }
+/**
+ * Detect Claude Code's synthetic "API Error: …" assistant message. When the
+ * upstream Anthropic API returns a transient error (529 Overloaded, 5xx, gateway
+ * timeouts, …), the Claude CLI swallows it and replaces the assistant turn with
+ * a single `text` block whose body is literally `API Error: <reason>`. The
+ * turn's stop_reason still claims `end_turn`, so the driver can't distinguish
+ * it from a normal short reply without inspecting the text.
+ *
+ * Heuristics — keep them tight so real prose mentioning "API Error" doesn't
+ * trip the detector:
+ *  - exact prefix "API Error: "
+ *  - total length ≤ 200 chars (the synthetic line is always short)
+ *  - no newlines (legit prose containing "API Error" virtually always wraps)
+ *
+ * Returns the trimmed reason (e.g. "Overloaded", "Internal server error") when
+ * matched, otherwise null. Callers decide whether the reason is retryable —
+ * `looksRetryable` answers that.
+ */
+export function detectClaudeApiError(text) {
+    if (!text)
+        return null;
+    const trimmed = text.trim();
+    if (trimmed.length > 200 || trimmed.includes('\n'))
+        return null;
+    const m = trimmed.match(/^API Error:\s*(.+)$/i);
+    return m ? m[1].trim() : null;
+}
+/**
+ * Retryable Claude Code API errors — transient upstream conditions that
+ * usually clear within seconds. Non-retryable conditions (auth, quota,
+ * context length) fall through and surface to the user immediately.
+ */
+export function isRetryableClaudeApiError(reason) {
+    const r = reason.toLowerCase();
+    return /overloaded|overload|timeout|timed out|rate limit|500|502|503|504|529|temporar|gateway|connection|network|internal (server )?error/i.test(r);
+}
 export function appendSystemPrompt(base, extra) {
     const lhs = String(base || '').trim();
     const rhs = String(extra || '').trim();
@@ -272,6 +308,10 @@ export function summarizeClaudeToolUse(name, input) {
             }
             if (bare === 'im_list_files')
                 return 'List workspace files';
+            if (bare === 'im_ask_user') {
+                const q = shortValue(input?.question, 120);
+                return q ? `Ask user: ${q}` : 'Ask user';
+            }
             if (description)
                 return `${tool}: ${description}`;
             const d = shortValue(input?.file_path || input?.path || input?.command || input?.query || input?.pattern || input?.url, 120);

package/dist/bot/bot.js

@@ -16,7 +16,7 @@ import { resolveGuiIntegrationConfig } from '../agent/mcp/bridge.js';
 import { terminateProcessTree } from '../core/process-control.js';
 import { expandTilde } from '../core/platform.js';
 import { VERSION } from '../core/version.js';
-import { buildHumanLoopResponse, createEmptyHumanLoopAnswer, currentHumanLoopQuestion, isHumanLoopAwaitingText, setHumanLoopOption, setHumanLoopText, skipHumanLoopQuestion, } from './human-loop.js';
+import { buildHumanLoopResponse, createEmptyHumanLoopAnswer, currentHumanLoopQuestion, isHumanLoopAwaitingText, setHumanLoopOption, setHumanLoopText, skipHumanLoopQuestion, summarizeResolvedHumanLoopAnswers, } from './human-loop.js';
 import { writeScopedLog } from '../core/logging.js';
 import { resolveAgentEffort, resolveAgentModel, } from '../core/config/runtime-config.js';
 import { envBool, envString, envInt, shellSplit, whichSync, fmtTokens, parseAllowedChatIds, ensureGitignore, } from '../core/utils.js';
@@ -1122,6 +1122,7 @@ export class Bot {
             resolve: resolvePrompt,
             reject: rejectPrompt,
             messageIds: [],
+            silent: opts.silent,
         };
         this.humanLoopPrompts.set(promptId, prompt);
         const chatKey = String(opts.chatId);
@@ -1157,6 +1158,7 @@ export class Bot {
         this.removeHumanLoopPromptFromChat(prompt.chatId, promptId);
         prompt.resolve(buildHumanLoopResponse(prompt));
         this.emitInteractionResolved(prompt.taskId, promptId);
+        this.fireInteractionAnswered(prompt, 'answered');
         return prompt;
     }
     clearHumanLoopPrompt(promptId, error) {
@@ -1168,8 +1170,34 @@ export class Bot {
         if (error)
             prompt.reject(error);
         this.emitInteractionResolved(prompt.taskId, promptId);
+        this.fireInteractionAnswered(prompt, 'cancelled');
         return prompt;
     }
+    /**
+     * Unified post-resolution hook for human-loop prompts. Each IM channel
+     * overrides `onInteractionAnswered` to (1) collapse the original prompt card
+     * to an answered/cancelled state and (2) echo the decision as a new chat
+     * message so scrolling back shows what the user picked. Dashboard sessions
+     * (chatId='dashboard') and channels that opt out remain silent.
+     */
+    fireInteractionAnswered(prompt, status) {
+        if (prompt.silent)
+            return;
+        if (prompt.chatId === 'dashboard')
+            return;
+        const summary = summarizeResolvedHumanLoopAnswers(prompt, status);
+        void Promise.resolve()
+            .then(() => this.onInteractionAnswered(prompt, summary))
+            .catch(err => this.warn(`onInteractionAnswered failed: ${err?.message || err}`));
+    }
+    /**
+     * Channel hook fired after a human-loop prompt resolves (answered or
+     * cancelled). Default: no-op. Override in channel subclasses to update the
+     * original card and post a decision-echo message.
+     */
+    async onInteractionAnswered(_prompt, _summary) {
+        // Default: no-op.
+    }
     emitInteractionResolved(taskId, promptId) {
         const task = this.activeTasks.get(taskId);
         if (task)
@@ -1328,9 +1356,10 @@ export class Bot {
         const taskId = `ext-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
         const prompt = opts.prompt.trim();
         const attachments = opts.attachments || [];
+        const chatId = opts.chatId ?? 'dashboard';
         this.beginTask({
             taskId,
-            chatId: opts.chatId ?? 'dashboard',
+            chatId,
             agent: session.agent,
             sessionKey: session.key,
             prompt,
@@ -1348,16 +1377,35 @@ export class Bot {
                 return;
             }
             this.emitStreamStart(taskId, session);
+            // Wire up IM rendering for non-dashboard chats so /goal-driven tasks stream
+            // to the same channel that submitted them, matching handleMessage's UX.
+            const presenter = chatId !== 'dashboard'
+                ? await this.createImTaskPresenter({
+                    chatId, taskId, session, agent: session.agent, prompt, attachments,
+                }).catch(err => {
+                    this.warn(`[submitSessionTask] presenter setup failed task=${taskId}: ${err?.message || err}`);
+                    return null;
+                })
+                : null;
             try {
                 const result = await this.runStream(prompt, session, attachments, (text, thinking, activity, meta, plan) => {
                     opts.onText?.(text, thinking, activity, meta, plan);
+                    presenter?.onText(text, thinking, activity, meta, plan);
                     this.emitStreamText(taskId, session.key, text, thinking, activity, meta, plan);
-                }, undefined, undefined, abortController.signal, this.createInteractionHandler(opts.chatId ?? 'dashboard', taskId), undefined, undefined, opts.forkOf ? { forkOf: opts.forkOf } : undefined);
+                }, undefined, undefined, abortController.signal, this.createInteractionHandler(chatId, taskId), undefined, undefined, opts.forkOf ? { forkOf: opts.forkOf } : undefined);
                 this.emitStreamDone(taskId, session.key, {
                     sessionId: result.sessionId || session.sessionId,
                     incomplete: !!result.incomplete,
                     ...(result.ok ? {} : { error: result.error || result.message }),
                 });
+                if (presenter) {
+                    try {
+                        await presenter.onSuccess(result);
+                    }
+                    catch (e) {
+                        this.warn(`[submitSessionTask] presenter onSuccess failed task=${taskId}: ${e?.message || e}`);
+                    }
+                }
                 try {
                     this.maybeEnqueueGoalContinuation(session, opts, result);
                 }
@@ -1366,13 +1414,23 @@ export class Bot {
                 }
             }
             catch (error) {
+                const errMsg = error?.message || String(error);
                 this.emitStreamDone(taskId, session.key, {
                     sessionId: session.sessionId,
                     incomplete: true,
-                    error: error?.message || String(error),
+                    error: errMsg,
                 });
+                if (presenter) {
+                    try {
+                        await presenter.onFailure(errMsg);
+                    }
+                    catch (e) {
+                        this.warn(`[submitSessionTask] presenter onFailure failed task=${taskId}: ${e?.message || e}`);
+                    }
+                }
             }
             finally {
+                presenter?.dispose();
                 this.finishTask(taskId);
                 this.syncSelectedChats(session);
             }
@@ -1382,6 +1440,14 @@ export class Bot {
         });
         return { ok: true, taskId, sessionKey: session.key, queued: true };
     }
+    /**
+     * Channel hook — returns a presenter that streams the task's runStream
+     * output to the IM chat that submitted it. Default: null (dashboard-only
+     * chats and channels that haven't opted in stay silent in IM).
+     */
+    async createImTaskPresenter(_opts) {
+        return null;
+    }
     /**
      * Goal continuation: after a turn ends, if a goal is still active for the
      * session, account token + wall-clock usage, then enqueue one more task with
@@ -2127,9 +2193,16 @@ export class Bot {
             }
         }
         const mcpSystemPrompt = appendExtraPrompt(appendExtraPrompt(mcpSendFile ? buildMcpDeliveryPrompt() : '', onInteraction && cs.agent === 'claude' ? buildClaudeAskUserPrompt() : ''), buildBrowserAutomationPrompt(browserEnabled));
+        // mcpSystemPrompt carries behaviour directives (use im_ask_user instead of
+        // built-in AskUserQuestion, browser automation status, artifact delivery)
+        // that must apply on every turn, not just the first — on resume the CLI
+        // does not automatically re-inject the previous --append-system-prompt
+        // contents, so Claude silently regresses to the built-in tools on turn 2+.
+        // The caller-supplied `systemPrompt` (per-task scaffolding) remains
+        // first-turn-only since later turns inherit it via the session transcript.
         const effectiveSystemPrompt = isFirstTurnOfSession
             ? appendExtraPrompt(systemPrompt, mcpSystemPrompt)
-            : undefined;
+            : (mcpSystemPrompt || undefined);
         const syncNativeSessionId = (nativeSessionId) => {
             const resolvedSessionId = nativeSessionId.trim();
             if (!resolvedSessionId)

package/dist/bot/human-loop.js

@@ -121,3 +121,48 @@ export function buildHumanLoopResponse(prompt) {
     }
     return prompt.resolveWith(answers);
 }
+function displayValueForOption(question, value) {
+    const match = question.options?.find(opt => opt.value === value);
+    return match?.label || value;
+}
+/**
+ * Build a channel-agnostic summary of a prompt's resolved answers. Used by the
+ * base bot's `onInteractionAnswered` hook so each channel renders the same
+ * closed-state view + echo message without diverging.
+ */
+export function summarizeResolvedHumanLoopAnswers(prompt, status = 'answered') {
+    const rows = [];
+    const compactParts = [];
+    for (const question of prompt.questions) {
+        const answer = prompt.answers[question.id] || createEmptyHumanLoopAnswer();
+        let display;
+        if (answer.skipped) {
+            display = '(skip)';
+        }
+        else if (question.secret && (answer.selectedValue || answer.freeformText)) {
+            display = '(hidden)';
+        }
+        else {
+            const parts = [];
+            if (answer.selectedValue)
+                parts.push(displayValueForOption(question, answer.selectedValue));
+            const freeform = answer.freeformText?.trim();
+            if (freeform)
+                parts.push(freeform);
+            display = parts.length ? parts.join(' · ') : '(no answer)';
+        }
+        const label = (question.header || question.prompt || question.id).trim();
+        rows.push({
+            label,
+            display,
+            skipped: !!answer.skipped,
+            secret: !!question.secret,
+        });
+        compactParts.push(display);
+    }
+    return {
+        status,
+        rows,
+        display: compactParts.join(' · '),
+    };
+}