@pentoshi/clai 3.11.5 → 3.11.7

package/dist/agent/interrupted-reasoning.d.ts

@@ -0,0 +1,6 @@
+export declare const INTERRUPTED_REASONING_LIMIT = 4000;
+export declare const INTERRUPTED_REASONING_MIN = 160;
+export declare const MIN_RESUMPTION_YIELD = 240;
+export declare function isMeaningfulResumptionYield(producedChars: number): boolean;
+export declare function appendInterruptedReasoning(previous: string, next: string): string;
+export declare function interruptedReasoningBrief(reasoning: string): string | undefined;

package/dist/agent/interrupted-reasoning.js

@@ -0,0 +1,38 @@
+export const INTERRUPTED_REASONING_LIMIT = 4_000;
+export const INTERRUPTED_REASONING_MIN = 160;
+export const MIN_RESUMPTION_YIELD = 240;
+export function isMeaningfulResumptionYield(producedChars) {
+    return producedChars >= MIN_RESUMPTION_YIELD;
+}
+function normalize(reasoning) {
+    return reasoning.replace(/\r/g, "").replace(/[ \t]+$/gm, "").trim();
+}
+function clampReasoning(reasoning) {
+    if (reasoning.length <= INTERRUPTED_REASONING_LIMIT)
+        return reasoning;
+    const tail = reasoning.slice(reasoning.length - INTERRUPTED_REASONING_LIMIT);
+    const breakAt = tail.indexOf("\n");
+    return breakAt > 0 && breakAt < 400 ? tail.slice(breakAt + 1) : tail;
+}
+export function appendInterruptedReasoning(previous, next) {
+    const addition = normalize(next);
+    if (!addition)
+        return previous;
+    const earlier = normalize(previous);
+    if (!earlier)
+        return clampReasoning(addition);
+    if (earlier.includes(addition))
+        return clampReasoning(earlier);
+    if (addition.includes(earlier))
+        return clampReasoning(addition);
+    return clampReasoning(`${earlier}\n\n${addition}`);
+}
+export function interruptedReasoningBrief(reasoning) {
+    const body = normalize(reasoning);
+    if (body.length < INTERRUPTED_REASONING_MIN)
+        return undefined;
+    return ("Your own reasoning from the interrupted attempt is preserved below. " +
+        "Build on these conclusions instead of re-deriving them, and go straight to the next concrete action.\n\n" +
+        `<preserved_reasoning>\n${body}\n</preserved_reasoning>`);
+}
+//# sourceMappingURL=interrupted-reasoning.js.map

package/dist/agent/interrupted-reasoning.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interrupted-reasoning.js","sourceRoot":"","sources":["../../src/agent/interrupted-reasoning.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,2BAA2B,GAAG,KAAK,CAAC;AAEjD,MAAM,CAAC,MAAM,yBAAyB,GAAG,GAAG,CAAC;AAE7C,MAAM,CAAC,MAAM,oBAAoB,GAAG,GAAG,CAAC;AAExC,MAAM,UAAU,2BAA2B,CAAC,aAAqB;IAC/D,OAAO,aAAa,IAAI,oBAAoB,CAAC;AAC/C,CAAC;AAED,SAAS,SAAS,CAAC,SAAiB;IAClC,OAAO,SAAS,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;AACtE,CAAC;AAED,SAAS,cAAc,CAAC,SAAiB;IACvC,IAAI,SAAS,CAAC,MAAM,IAAI,2BAA2B;QAAE,OAAO,SAAS,CAAC;IACtE,MAAM,IAAI,GAAG,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,GAAG,2BAA2B,CAAC,CAAC;IAC7E,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,OAAO,OAAO,GAAG,CAAC,IAAI,OAAO,GAAG,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AACvE,CAAC;AAED,MAAM,UAAU,0BAA0B,CACxC,QAAgB,EAChB,IAAY;IAEZ,MAAM,QAAQ,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IACjC,IAAI,CAAC,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAC/B,MAAM,OAAO,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;IACpC,IAAI,CAAC,OAAO;QAAE,OAAO,cAAc,CAAC,QAAQ,CAAC,CAAC;IAC9C,IAAI,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAAE,OAAO,cAAc,CAAC,OAAO,CAAC,CAAC;IAC/D,IAAI,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC;QAAE,OAAO,cAAc,CAAC,QAAQ,CAAC,CAAC;IAChE,OAAO,cAAc,CAAC,GAAG,OAAO,OAAO,QAAQ,EAAE,CAAC,CAAC;AACrD,CAAC;AAED,MAAM,UAAU,yBAAyB,CACvC,SAAiB;IAEjB,MAAM,IAAI,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC;IAClC,IAAI,IAAI,CAAC,MAAM,GAAG,yBAAyB;QAAE,OAAO,SAAS,CAAC;IAC9D,OAAO,CACL,sEAAsE;QACtE,0GAA0G;QAC1G,0BAA0B,IAAI,0BAA0B,CACzD,CAAC;AACJ,CAAC"}

package/dist/agent/runner.js

@@ -58,6 +58,7 @@ import { buildDurableEnvelope, WorkLedger, } from "./durable-envelope.js";
 import { COMPACTION_SYSTEM_PROMPT, } from "./compaction-summary.js";
 import { maybeAppendPlanModeReminder, PLAN_REMINDER_TOAST, } from "./plan-mode-reminders.js";
 import { LoopGuard } from "./loop-guard.js";
+import { appendInterruptedReasoning, interruptedReasoningBrief, isMeaningfulResumptionYield, } from "./interrupted-reasoning.js";
 import { CompactionAttemptLedger, compactionAttemptKey, } from "./compaction-attempt.js";
 import { resolveRequestBudget } from "./request-budget.js";
 import { loadPlan, mutatePlan, markTask, appendPlanTask, readyPlanTasks, foregroundRemaining, responderOpenTasks, isPlanTerminal, isPlanSuccessful, } from "../store/plan.js";
@@ -169,6 +170,8 @@ export async function runAgentTurn(prompt, options = {}) {
     // at the top of every loop iteration.
     let visibleCommitted = false;
     let interruptedVisible = "";
+    let interruptedReasoning = "";
+    let lowYieldResumptions = 0;
     const trimExactContinuationOverlap = (previous, current, minLength = 32) => {
         if (previous.length > 0 && current.startsWith(previous)) {
             return current.slice(previous.length);
@@ -3095,6 +3098,30 @@ export async function runAgentTurn(prompt, options = {}) {
                 let accumulatedText = "";
                 const callIds = [];
                 let streamedCallsCount = 0;
+                // A model can think silently for minutes. Without a heartbeat the UI
+                // shows a frozen label and the turn looks hung, so surface elapsed time
+                // and the current phase on a timer rather than only on token arrival.
+                const streamStartedAt = Date.now();
+                const streamPhase = () => {
+                    const seconds = Math.round((Date.now() - streamStartedAt) / 1000);
+                    const elapsed = seconds < 60
+                        ? `${seconds}s`
+                        : `${Math.floor(seconds / 60)}m${String(seconds % 60).padStart(2, "0")}s`;
+                    if (generatedTokens > 0 && !inThinking) {
+                        return `generating response · ${generatedTokens} tokens · ${elapsed}`;
+                    }
+                    if (sawReasoning)
+                        return `thinking · ${elapsed}`;
+                    return `waiting for model · ${elapsed}`;
+                };
+                const heartbeat = setInterval(() => {
+                    const text = streamPhase();
+                    if (writesDirectly)
+                        spinner.setLabel(text);
+                    else
+                        emit({ type: "status", text });
+                }, 10_000);
+                heartbeat.unref?.();
                 const deferredToolCalls = [];
                 const deltaParser = writesDirectly
                     ? undefined
@@ -3336,6 +3363,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         resetStreamRecoveryState(recoveryState);
                         allowModelFallback = false;
                         preferModelFallback = false;
+                        lowYieldResumptions = 0;
                     }
                     catch (streamError) {
                         // User cancelled (double-Esc) — never try to recover, just stop.
@@ -3363,47 +3391,89 @@ export async function runAgentTurn(prompt, options = {}) {
                         // We only rethrow (stop the turn) in the worst case: every approach
                         // for that failure class is exhausted or the total budget is spent.
                         const failureKind = classifyStreamFailure(streamError);
+                        const partialStream = streamAlreadyEmitted(streamError) || accumulatedText.length > 0;
+                        const partial = rememberThinkingFromText(accumulatedText);
+                        const rawPartialVisible = partialStream
+                            ? textBeforeToolCall(stripThinking(collapseRepeatedText(accumulatedText)).visible)
+                            : "";
+                        const normalizedPartialVisible = trimExactContinuationOverlap(interruptedVisible, rawPartialVisible);
+                        const partialVisible = normalizedPartialVisible.trim();
+                        // A route that drops after a handful of characters is not making
+                        // progress, however many times it is retried. Only a substantial
+                        // yield unlocks the generous resumption budget; anything less is
+                        // charged to the failure class and escalates to another route.
+                        const meaningfulProgress = partialStream &&
+                            isMeaningfulResumptionYield(normalizedPartialVisible.length + partial.thinkContent.length);
+                        if (partialStream) {
+                            lowYieldResumptions = meaningfulProgress
+                                ? 0
+                                : lowYieldResumptions + 1;
+                        }
                         const plan = planStreamRecovery({
                             kind: failureKind,
                             state: recoveryState,
+                            progressed: meaningfulProgress,
                         });
-                        const partialStream = streamAlreadyEmitted(streamError) || accumulatedText.length > 0;
+                        const terminalFailure = plan.action === "give-up";
                         let continuationNudge = "";
                         if (partialStream) {
                             spinner.stop();
                             deltaParser?.finish();
-                            const partial = rememberThinkingFromText(accumulatedText);
                             const hasShownToolCall = deferredToolCalls.some((entry) => entry.shown);
-                            const rawPartialVisible = textBeforeToolCall(stripThinking(collapseRepeatedText(accumulatedText)).visible);
-                            const normalizedPartialVisible = trimExactContinuationOverlap(interruptedVisible, rawPartialVisible);
-                            const partialVisible = normalizedPartialVisible.trim();
                             if (partialVisible) {
-                                writeAssistantMessage(partialVisible);
-                                pushAssistantHistory(partialVisible);
+                                // Finalizing here would close the streaming card and split one
+                                // answer across a card per interruption. Keep it open and let
+                                // the single commit below paint the stitched text; only a
+                                // terminal failure has to flush it now.
+                                if (terminalFailure) {
+                                    writeAssistantMessage(interruptedVisible + normalizedPartialVisible);
+                                }
+                                else {
+                                    visibleCommitted = true;
+                                }
+                                messages.push({
+                                    role: "assistant",
+                                    content: sanitizeAssistantText(partialVisible),
+                                });
                                 interruptedVisible += normalizedPartialVisible;
                             }
-                            else if (!writesDirectly) {
+                            else if (terminalFailure && !writesDirectly) {
                                 emit({ type: "assistant-message", text: "" });
                             }
                             if (partial.hasThinking && !hasShownToolCall) {
                                 writeThinkingBlock(partial.thinkContent);
                             }
+                            if (partial.hasThinking) {
+                                interruptedReasoning = appendInterruptedReasoning(interruptedReasoning, partial.thinkContent);
+                            }
                             for (const deferred of deferredToolCalls) {
                                 if (!deferred.shown || deferred.call.name === "…")
                                     continue;
                                 writeToolBlocked(deferred.eventId, deferred.call.name, "Incomplete tool call discarded after the provider stream was interrupted.", chalk.yellow("  ⚠ incomplete tool call discarded after stream interruption\n"));
                             }
-                            continuationNudge =
-                                "The provider stream was interrupted after partial output. Continue from the exact stopping point without repeating prior text. Any incomplete tool call was discarded and must be reissued in full.";
-                            const restartNotice = plan.action === "give-up"
+                            continuationNudge = [
+                                partialVisible
+                                    ? "The provider stream was interrupted after partial output. Continue from the exact stopping point without repeating prior text. Any incomplete tool call was discarded and must be reissued in full."
+                                    : "The provider stream was interrupted before any answer was produced. Any incomplete tool call was discarded and must be reissued in full. Do not restart your analysis from the beginning.",
+                                interruptedReasoningBrief(interruptedReasoning),
+                            ]
+                                .filter((part) => Boolean(part))
+                                .join("\n\n");
+                            const restartNotice = terminalFailure
                                 ? "partial response preserved before terminal provider failure"
-                                : "partial response preserved — resuming from the interruption";
+                                : lowYieldResumptions > 1
+                                    ? `route is dropping after almost no output (${lowYieldResumptions} in a row) — switching model`
+                                    : "partial response preserved — resuming from the interruption";
                             writeNotice("warn", restartNotice, chalk.yellow(`  ⚠ ${restartNotice}\n`));
                         }
-                        if (plan.action === "give-up") {
+                        if (terminalFailure) {
                             throw streamError;
                         }
-                        recordRecoveryAttempt(recoveryState, failureKind);
+                        recordRecoveryAttempt(recoveryState, failureKind, meaningfulProgress);
+                        if (lowYieldResumptions > 1) {
+                            allowModelFallback = true;
+                            preferModelFallback = true;
+                        }
                         if (plan.notice) {
                             writeNotice("warn", plan.notice, chalk.yellow(`  ⚠ ${plan.notice}\n`));
                         }
@@ -3434,6 +3504,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 }
                 finally {
                     // Always clear the spinner — abort, network error, or success.
+                    clearInterval(heartbeat);
                     spinner.stop();
                 }
                 if (responderDelivery) {
@@ -3487,7 +3558,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 const commitAssistantRetry = (historyText) => {
                     const hasShownToolCall = deferredToolCalls.some((entry) => entry.shown);
                     if (!hasShownToolCall) {
-                        const displayText = textBeforeToolCall(collapseRepeatedText(assistantText.visible)).trim();
+                        const displayText = textBeforeToolCall(collapseRepeatedText(canonicalAssistantVisible)).trim();
                         if (displayText) {
                             writeAssistantMessage(displayText);
                         }
@@ -3503,6 +3574,8 @@ export async function runAgentTurn(prompt, options = {}) {
                     }
                     pushAssistantHistory(historyText);
                     interruptedVisible = "";
+                    interruptedReasoning = "";
+                    lowYieldResumptions = 0;
                 };
                 // Only emit a thinking-block event when the classic renderer is
                 // active (writesDirectly / no deltaParser).  In TUI v2 the
@@ -4186,6 +4259,8 @@ export async function runAgentTurn(prompt, options = {}) {
                     emit({ type: "assistant-message", text: "" });
                 }
                 interruptedVisible = "";
+                interruptedReasoning = "";
+                lowYieldResumptions = 0;
                 let bound = [];
                 if (nativeToolCalls.length) {
                     bound = nativeToolCalls.map((tc, index) => {