pikiclaw 0.3.61 → 0.3.62

package/dist/agent/drivers/claude-tui.js

@@ -43,7 +43,7 @@ import { tmpdir } from 'node:os';
 import { Q, agentLog, agentWarn, buildStreamPreviewMeta, computeContext, joinErrorMessages, emitSessionIdUpdate, normalizeClaudeModelId, pushRecentActivity, summarizeClaudeToolUse, summarizeClaudeToolResult, previewToolCallInput, previewToolCallResult, detectClaudeApiError, } from '../utils.js';
 import { encodePathAsDirName, getHome, whichSync } from '../../core/platform.js';
 import { stripAnsiEscapes } from '../../core/utils.js';
-import { AGENT_STREAM_HARD_KILL_GRACE_MS } from '../../core/constants.js';
+import { AGENT_STREAM_HARD_KILL_GRACE_MS, CLAUDE_TUI_STALL_QUIET_MS, CLAUDE_TUI_STALL_PENDING_TOOL_MS, } from '../../core/constants.js';
 import { claudeParse, createClaudeStreamState, claudeContextWindowFromModel, claudeEffectiveContextWindow, registerClaudeBackgroundAgentLaunch, pendingClaudeBackgroundAgentCount, } from './claude.js';
 async function loadPty() {
     // Dynamic import keeps node-pty an optional dependency — if it's not
@@ -643,6 +643,26 @@ export function decideClaudeTuiStop(input) {
     }
     return 'terminate';
 }
+/**
+ * Decide whether the turn has gone dead. claude CLI is known to freeze
+ * mid-turn (observed 2026-06-02 on 2.1.160): after a tool_result lands the
+ * next assistant segment never starts — the process stays alive, the JSONL
+ * goes permanently quiet, no Stop hook ever fires, no error surfaces. Without
+ * a watchdog the IM card spins forever.
+ *
+ * `lastProgressAt` is the freshest of every live signal the driver tracks
+ * (main JSONL, hook tool events, sub-agent sidecars, hook lifecycle state).
+ * A pending tool (PreToolUse seen, no PostToolUse) extends the threshold:
+ * the freeze can also hit mid-execution, but a legitimately long foreground
+ * command must not get shot — claude's own Bash timeout fires PostToolUse
+ * well inside CLAUDE_TUI_STALL_PENDING_TOOL_MS.
+ */
+export function decideClaudeTuiStall(input) {
+    const threshold = input.pendingToolCount > 0
+        ? (input.pendingToolMs ?? CLAUDE_TUI_STALL_PENDING_TOOL_MS)
+        : (input.quietMs ?? CLAUDE_TUI_STALL_QUIET_MS);
+    return input.now - input.lastProgressAt > threshold ? 'stall' : 'wait';
+}
 // ---------------------------------------------------------------------------
 // Main entry
 // ---------------------------------------------------------------------------
@@ -981,6 +1001,14 @@ export async function doClaudeTuiStream(opts) {
     // Last pending-background count we logged, so the waiting state logs on
     // transitions instead of every 200ms poll tick.
     let lastLoggedPendingBg = -1;
+    // Stall-watchdog liveness signals. Together with lastMainJsonlEventAt they
+    // answer "is the claude process still doing anything at all?" — see
+    // decideClaudeTuiStall for why this exists (claude CLI mid-turn freeze).
+    let lastToolEventAt = start;
+    let lastSidecarEventAt = 0;
+    let stallKilled = false;
+    /** Hook-reported tools still executing: PreToolUse seen, no PostToolUse. */
+    const pendingHookToolIds = new Set();
     // Append-only tool-events log fed by PreToolUse / PostToolUse hooks. We
     // tail it with the same incremental reader the JSONL transcript uses, so
     // tool calls + plan changes surface live during the turn even while the
@@ -1004,6 +1032,18 @@ export async function doClaudeTuiStream(opts) {
             catch {
                 continue;
             }
+            // Stall-watchdog bookkeeping: any hook event is proof of life, and the
+            // Pre/Post pairing tells the watchdog whether a tool is mid-execution
+            // (which extends the stall threshold — long foreground commands are
+            // legitimately silent).
+            lastToolEventAt = Date.now();
+            const hookToolId = typeof ev?.tool_use_id === 'string' ? ev.tool_use_id : '';
+            if (hookToolId) {
+                if (ev?.event === 'PreToolUse')
+                    pendingHookToolIds.add(hookToolId);
+                else if (ev?.event === 'PostToolUse')
+                    pendingHookToolIds.delete(hookToolId);
+            }
             // A Task PreToolUse and the first sub-agent tool PreToolUse can land in
             // the same tick batch. If the sub-agent's hook arrives before we've
             // discovered its sidecar (and thus before s.subAgentIdToParent knows
@@ -1105,6 +1145,10 @@ export async function doClaudeTuiStream(opts) {
                 any = true;
             }
         }
+        // Stall-watchdog: live sub-agents count as turn progress even while the
+        // parent thread is quietly waiting on them.
+        if (any)
+            lastSidecarEventAt = Date.now();
         return any;
     };
     const tick = () => {
@@ -1248,6 +1292,35 @@ export async function doClaudeTuiStream(opts) {
             // Continue polling so any post-Stop JSONL writes still get parsed; the
             // process will exit shortly and onExit will resolve the wait.
         }
+        // Stall watchdog. claude CLI can freeze mid-turn (observed on 2.1.160):
+        // a tool_result lands, then the next assistant segment never starts — the
+        // process stays alive, every signal goes quiet, no Stop hook ever fires.
+        // When ALL liveness signals have been silent past the threshold, declare
+        // the turn stalled and SIGTERM; doClaudeWithRetry auto-resumes the session
+        // once so the turn continues instead of spinning forever in the IM card.
+        if (!stopHookFired && !timedOut && !interrupted && !stallKilled) {
+            const lastProgressAt = Math.max(start, lastMainJsonlEventAt, lastToolEventAt, lastSidecarEventAt, state.stoppedAt || 0, state.promptSubmittedAt || 0);
+            const stallDecision = decideClaudeTuiStall({
+                now: Date.now(),
+                lastProgressAt,
+                pendingToolCount: pendingHookToolIds.size,
+            });
+            if (stallDecision === 'stall') {
+                stallKilled = true;
+                const quietMin = Math.round((Date.now() - lastProgressAt) / 60_000);
+                s.stopReason = 'stalled';
+                if (!s.errors) {
+                    s.errors = [`Claude process went silent mid-turn for ${quietMin}m (no JSONL, hook, or sub-agent events) — known claude CLI freeze. Terminated for auto-resume.`];
+                }
+                agentWarn(`[claude-tui] stall detected: no progress for ${quietMin}m (pendingTools=${pendingHookToolIds.size}) — terminating TUI pid=${proc.pid} for auto-resume`);
+                pushRecentActivity(s.recentActivity, `Agent stalled (${quietMin}m silent) — restarting turn`);
+                s.activity = s.recentActivity.join('\n');
+                emit();
+                killProc('SIGTERM');
+                // Keep polling: onExit resolves the wait and the final drains pick up
+                // whatever the dying process flushes.
+            }
+        }
         pollHandle = setTimeout(tick, POLL_INTERVAL_MS);
     };
     pollHandle = setTimeout(tick, POLL_INTERVAL_MS);

package/dist/agent/drivers/claude.js

@@ -2275,8 +2275,53 @@ function makeOverloadFriendlyResult(result, reason, attempts) {
  * friendly human-readable explanation in `message` so the IM card doesn't
  * dump raw "API Error: Overloaded" text on the user.
  */
+/**
+ * Continuation prompt for stall recovery. The frozen process already accepted
+ * and partially executed the user's prompt (it sits in the transcript), so the
+ * resumed process must NOT receive the original prompt again — it gets an
+ * explicit "pick up where you left off" instead.
+ */
+const CLAUDE_STALL_RESUME_PROMPT = '[pikiclaw] The previous agent process stalled mid-turn and was restarted. '
+    + 'Continue the task from where it left off — do not start over or repeat work that already completed.';
+/** At most one automatic resume per turn; a second stall surfaces to the user. */
+const CLAUDE_STALL_RESUME_LIMIT = 1;
 async function doClaudeWithRetry(opts) {
     let lastResult = await doClaudeStreamOnce(opts);
+    // Mid-turn stall recovery. The TUI driver SIGTERMs a frozen claude process
+    // (stopReason 'stalled' — see decideClaudeTuiStall in claude-tui.ts) instead
+    // of letting the IM card spin forever. Resume the same session once with a
+    // continuation prompt so the turn picks up where the frozen process died.
+    let stallResumes = 0;
+    while (lastResult.stopReason === 'stalled'
+        && stallResumes < CLAUDE_STALL_RESUME_LIMIT
+        && !opts.abortSignal?.aborted) {
+        const stalledSessionId = lastResult.sessionId || opts.sessionId;
+        if (!stalledSessionId)
+            break;
+        stallResumes++;
+        agentWarn(`[claude] turn stalled mid-flight; auto-resuming session ${stalledSessionId.slice(0, 8)} (${stallResumes}/${CLAUDE_STALL_RESUME_LIMIT})`);
+        lastResult = await doClaudeStreamOnce({
+            ...opts,
+            sessionId: stalledSessionId,
+            forkOf: undefined,
+            prompt: CLAUDE_STALL_RESUME_PROMPT,
+            attachments: undefined,
+        });
+    }
+    if (lastResult.stopReason === 'stalled') {
+        // Still stalled after the resume budget (or no session id to resume).
+        // Surface a self-explanatory failure instead of the raw error text.
+        return {
+            ...lastResult,
+            ok: false,
+            incomplete: true,
+            message: [
+                'The agent process stalled mid-turn and could not be auto-recovered (known claude CLI freeze, seen on 2.1.160).',
+                'Your session is intact — re-send your message (or say "continue") to pick up where it stopped.',
+                'If this keeps happening, pin the claude CLI to a known-good version: npm install -g @anthropic-ai/claude-code@2.1.159',
+            ].join(' '),
+        };
+    }
     let attempts = 0;
     // Use the error text recorded by detectClaudeApiError-driven branches to
     // decide retry: lastResult.error is "Anthropic API error: <reason>" on

package/dist/core/constants.js

@@ -287,6 +287,25 @@ export const AGENT_STREAM_HARD_KILL_GRACE_MS = 10_000;
  * resumed via --resume, can see it in the transcript.
  */
 export const AGENT_GRACEFUL_ABORT_GRACE_MS = 2_000;
+/**
+ * claude-tui stall watchdog — claude CLI is known to freeze mid-turn (observed
+ * 2026-06-02 on 2.1.160: after a tool_result lands, the next assistant segment
+ * never starts; the process stays alive, the JSONL goes permanently quiet, no
+ * Stop hook ever fires). When every live signal (main JSONL, hook tool events,
+ * sub-agent sidecars, hook lifecycle state) is silent past the threshold the
+ * driver SIGTERMs the PTY and the dispatch wrapper auto-resumes the session
+ * once. Quiet threshold must sit safely above the longest healthy gap between
+ * JSONL events — a single max-effort inference can take a few minutes before
+ * its first content block lands.
+ */
+export const CLAUDE_TUI_STALL_QUIET_MS = 10 * 60_000;
+/**
+ * Stall threshold while a hook-reported tool is still executing (PreToolUse
+ * seen, no matching PostToolUse). Claude's own Bash timeout caps foreground
+ * commands at ~10 minutes and fires PostToolUse either way, so a pending tool
+ * silent for this long means the freeze hit mid-execution.
+ */
+export const CLAUDE_TUI_STALL_PENDING_TOOL_MS = 30 * 60_000;
 /** Codex-specific grace period added to the user-configured timeout. */
 export const CODEX_STREAM_HARD_KILL_GRACE_MS = 5_000;
 /**

package/package.json

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