pikiclaw 0.3.73 → 0.3.74

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

@@ -323,6 +323,32 @@ export function detectClaudeTuiTerminalLimitNotice(msgOrText) {
         return null;
     return limitNoticeFromText(extractTextBlocks(msgOrText.content));
 }
+/**
+ * Evidence-based arbitration for a detected limit notice. The banner text is
+ * deliberately matched broadly (wording shifts across CLI versions and some
+ * notices are informational — "You're now using usage credits · Your session
+ * limit resets 3pm" means the turn CONTINUES on extra-usage credits), so a
+ * match alone must never fail the turn. What decides the outcome is whether
+ * the turn produced anything substantive after the banner:
+ *
+ *  - 'info'  — assistant text exists, or a substantive signal (non-synthetic
+ *              assistant JSONL, hook tool event, sub-agent sidecar) postdates
+ *              the notice. The turn is alive; the notice is informational.
+ *  - 'fatal' — nothing substantive after the banner. The limit genuinely ate
+ *              the turn; surface the banner text as a rate_limit failure.
+ *  - 'none'  — no notice was seen.
+ *
+ * Worst case of the broad matching is therefore an activity line, not a
+ * killed turn (the bug this replaced: the credits banner used to SIGTERM the
+ * process mid-answer).
+ */
+export function resolveClaudeTuiLimitOutcome(input) {
+    if (!input.noticeText)
+        return 'none';
+    if (input.hasOutputText || input.lastSubstantiveEventAt > input.noticeAt)
+        return 'info';
+    return 'fatal';
+}
 /**
  * Detect Claude Code's startup "Bypass Permissions mode" confirmation dialog in
  * a slice of (ANSI-stripped) PTY screen output. When pikiclaw spawns the TUI
@@ -1048,6 +1074,7 @@ export async function doClaudeTuiStream(opts) {
     let exitCode = null;
     let exitSignal = null;
     let terminalLimitNotice = null;
+    let terminalLimitNoticeAt = 0;
     let proc;
     const emit = () => {
         try {
@@ -1069,16 +1096,20 @@ export async function doClaudeTuiStream(opts) {
             }
         }, after);
     };
-    const markTerminalLimitNotice = (notice) => {
+    // Record-only: a limit banner is EVIDENCE, not a verdict. Some banners are
+    // informational (extra-usage credits kick in and the turn continues), so
+    // killing here would shoot healthy turns. resolveClaudeTuiLimitOutcome
+    // arbitrates later — at the stall watchdog and at result assembly — based
+    // on whether the turn produced anything substantive after the banner.
+    const noteTerminalLimitNotice = (notice) => {
         if (terminalLimitNotice)
             return;
         terminalLimitNotice = notice;
-        s.stopReason = 'rate_limit';
-        s.errors = [notice];
-        agentWarn(`[claude-tui] terminal limit notice detected: ${notice}`);
+        terminalLimitNoticeAt = Date.now();
+        agentWarn(`[claude-tui] limit notice observed (watching turn liveness): ${notice}`);
+        pushRecentActivity(s.recentActivity, `Claude usage notice: ${notice}`);
+        s.activity = s.recentActivity.join('\n');
         emit();
-        if (!processExited)
-            killProc('SIGTERM', 1500);
     };
     // Simulated streaming. See TuiStreamBuffer / applyAssistantStreaming above.
     const streamBuf = makeTuiStreamBuffer();
@@ -1317,7 +1348,7 @@ export async function doClaudeTuiStream(opts) {
                 stderrCapture = stderrCapture.slice(0, 4096);
             const notice = detectClaudeTuiTerminalLimitNotice(stderrCapture);
             if (notice)
-                markTerminalLimitNotice(notice);
+                noteTerminalLimitNotice(notice);
         }
     });
     // 7. Abort handling.
@@ -1367,6 +1398,11 @@ export async function doClaudeTuiStream(opts) {
     // decideClaudeTuiStall for why this exists (claude CLI mid-turn freeze).
     let lastToolEventAt = start;
     let lastSidecarEventAt = 0;
+    // Last non-synthetic assistant JSONL event — substantive-progress signal
+    // for the limit-notice arbitration (resolveClaudeTuiLimitOutcome). Distinct
+    // from lastMainJsonlEventAt, which also counts bookkeeping lines (mode,
+    // last-prompt, …) that land right after submit and prove nothing.
+    let lastAssistantEventAt = 0;
     let stallKilled = false;
     // Stall diagnostics (capture-only) — see writeStallDiag.
     let observedClaudeVersion = '';
@@ -1590,13 +1626,14 @@ export async function doClaudeTuiStream(opts) {
                 if (!isSubAgentEvent && ev.type === 'assistant') {
                     const notice = detectClaudeTuiTerminalLimitNotice(ev.message);
                     if (notice) {
-                        markTerminalLimitNotice(notice);
+                        noteTerminalLimitNotice(notice);
                         touched = true;
                         continue;
                     }
                     applyAssistantStreaming(s, ev.message, streamBuf);
                     applyAssistantUsage(s, ev.message);
                     if (ev.message?.model && ev.message.model !== '<synthetic>' && typeof ev.message.model === 'string') {
+                        lastAssistantEventAt = Date.now();
                         s.model = ev.message.model;
                         applyModelContextWindow(s);
                     }
@@ -1788,15 +1825,34 @@ export async function doClaudeTuiStream(opts) {
                     screenSample: stallScreen.sample,
                 });
                 if (!s.errors) {
-                    // Be honest about which kind of stall this is. looksLikePrompt here
-                    // means the auto-answer (detectClaudeProceedPrompt) did NOT clear an
-                    // interactive prompt — so it's a blocking dialog, not the CLI freeze.
-                    s.errors = [stallScreen.looksLikePrompt
-                            ? `Claude blocked mid-turn on an interactive prompt (PTY quiet ${ptyQuietS}s) that auto-answer couldn't clear. Terminated for auto-resume.`
-                            : `Claude process went silent mid-turn for ${quietMin}m (no JSONL, hook, or sub-agent events; PTY quiet ${ptyQuietS}s) — known claude CLI freeze. Terminated for auto-resume.`];
+                    // Limit-notice arbitration first: a turn that showed a limit banner
+                    // and then produced nothing substantive didn't freeze — the limit
+                    // ate it. Label it rate_limit with the banner's own text (which
+                    // carries the reset time) so the user gets the real reason, and so
+                    // doClaudeWithRetry doesn't auto-resume into the same wall.
+                    const limitOutcome = resolveClaudeTuiLimitOutcome({
+                        noticeText: terminalLimitNotice,
+                        noticeAt: terminalLimitNoticeAt,
+                        lastSubstantiveEventAt: Math.max(lastAssistantEventAt, lastToolEventAt, lastSidecarEventAt),
+                        hasOutputText: !!s.text.trim(),
+                    });
+                    if (limitOutcome === 'fatal') {
+                        s.stopReason = 'rate_limit';
+                        s.errors = [terminalLimitNotice];
+                    }
+                    else {
+                        // Be honest about which kind of stall this is. looksLikePrompt here
+                        // means the auto-answer (detectClaudeProceedPrompt) did NOT clear an
+                        // interactive prompt — so it's a blocking dialog, not the CLI freeze.
+                        s.errors = [stallScreen.looksLikePrompt
+                                ? `Claude blocked mid-turn on an interactive prompt (PTY quiet ${ptyQuietS}s) that auto-answer couldn't clear. Terminated for auto-resume.`
+                                : `Claude process went silent mid-turn for ${quietMin}m (no JSONL, hook, or sub-agent events; PTY quiet ${ptyQuietS}s) — known claude CLI freeze. Terminated for auto-resume.`];
+                    }
                 }
-                agentWarn(`[claude-tui] stall detected: no progress for ${quietMin}m (pendingTools=${pendingHookToolIds.size}, ptyQuiet=${ptyQuietS}s) — terminating TUI pid=${proc.pid} for auto-resume`);
-                pushRecentActivity(s.recentActivity, `Agent stalled (${quietMin}m silent) — restarting turn`);
+                agentWarn(`[claude-tui] stall detected: no progress for ${quietMin}m (pendingTools=${pendingHookToolIds.size}, ptyQuiet=${ptyQuietS}s) — terminating TUI pid=${proc.pid}${s.stopReason === 'rate_limit' ? ' (usage limit)' : ' for auto-resume'}`);
+                pushRecentActivity(s.recentActivity, s.stopReason === 'rate_limit'
+                    ? 'Usage limit blocked the turn — stopping'
+                    : `Agent stalled (${quietMin}m silent) — restarting turn`);
                 s.activity = s.recentActivity.join('\n');
                 emit();
                 killProc('SIGTERM');
@@ -1845,13 +1901,14 @@ export async function doClaudeTuiStream(opts) {
             if (!isSubAgentEvent && ev.type === 'assistant') {
                 const notice = detectClaudeTuiTerminalLimitNotice(ev.message);
                 if (notice) {
-                    markTerminalLimitNotice(notice);
+                    noteTerminalLimitNotice(notice);
                     touched = true;
                     continue;
                 }
                 applyAssistantStreaming(s, ev.message, streamBuf);
                 applyAssistantUsage(s, ev.message);
                 if (ev.message?.model && ev.message.model !== '<synthetic>' && typeof ev.message.model === 'string') {
+                    lastAssistantEventAt = Date.now();
                     s.model = ev.message.model;
                     applyModelContextWindow(s);
                 }
@@ -1908,6 +1965,23 @@ export async function doClaudeTuiStream(opts) {
         if (!s.errors)
             s.errors = [`Anthropic API error: ${apiErrorReason}`];
     }
+    // Limit-notice arbitration (see resolveClaudeTuiLimitOutcome). Covers the
+    // paths the stall watchdog never reaches: the TUI painted a limit banner,
+    // then Stop fired on an empty turn or the process exited — nothing
+    // substantive ever followed the banner, so the limit ate the turn. A banner
+    // followed by real output stays informational (already in the activity log).
+    if (!interrupted && !timedOut && !s.errors) {
+        const limitOutcome = resolveClaudeTuiLimitOutcome({
+            noticeText: terminalLimitNotice,
+            noticeAt: terminalLimitNoticeAt,
+            lastSubstantiveEventAt: Math.max(lastAssistantEventAt, lastToolEventAt, lastSidecarEventAt),
+            hasOutputText: !!s.text.trim(),
+        });
+        if (limitOutcome === 'fatal') {
+            s.stopReason = 'rate_limit';
+            s.errors = [terminalLimitNotice];
+        }
+    }
     const errorText = joinErrorMessages(s.errors);
     // "ok" requires: process exited cleanly (or via our own SIGTERM after Stop
     // hook fired, which yields a non-zero exit), no errors from the parser, no

package/package.json

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