@gajae-code/coding-agent 0.11.9 → 0.11.10

package/src/tools/subagent-render.ts

@@ -11,6 +11,12 @@ import type { Component } from "@gajae-code/tui";
 import { Text } from "@gajae-code/tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
+import {
+	collectProviderDegradationGroups,
+	hasActiveProviderRetryInProgress,
+	providerProgressAgeLabel,
+	providerRetryPhaseLabel,
+} from "../task/provider-retry-status";
 import { renderSubagentLiveProgress } from "../task/render";
 import { Ellipsis, Hasher, renderStatusLine } from "../tui";
 import {
@@ -42,7 +48,8 @@ const PREVIEW_LINE_WIDTH = 80;
  * wall-clock displays are deliberately kept OUT of the cached body — the animated
  * spinner and the fresh duration live in the cheap per-subagent status line, and
  * `renderSubagentLiveProgress` is invoked with `staticTime` so current-tool elapsed
- * and retry countdowns are never baked into cached lines.
+ * and retry countdowns are never baked into cached lines. Snapshots with an active
+ * retry anywhere in their nested task tree bypass this cache and render dynamically.
  */
 const SUBAGENT_BODY_CACHE_MAX = 128;
 const subagentBodyCache = new Map<bigint, string[]>();
@@ -77,6 +84,15 @@ export const subagentBodyCacheTestHooks = {
 	},
 };
 
+function snapshotHasActiveRetry(snapshot: SubagentSnapshot): boolean {
+	if (snapshot.liveProgressAvailable === false || !snapshot.progress) return false;
+	return hasActiveProviderRetryInProgress(snapshot.progress);
+}
+
+function boundSubagentBodyLines(lines: string[], width: number): string[] {
+	return lines.map(line => (line.length > 0 ? truncateToWidth(replaceTabs(line), width, Ellipsis.Omit) : ""));
+}
+
 function renderCachedSubagentBody(
 	snapshot: SubagentSnapshot,
 	signature: string,
@@ -92,9 +108,7 @@ function renderCachedSubagentBody(
 		subagentBodyCache.set(key, hit);
 		return hit;
 	}
-	const lines = renderSubagentSnapshotBody(snapshot, expanded, theme).map(line =>
-		line.length > 0 ? truncateToWidth(line, width, Ellipsis.Omit) : "",
-	);
+	const lines = boundSubagentBodyLines(renderSubagentSnapshotBody(snapshot, expanded, theme), width);
 	subagentBodyRenderCount += 1;
 	subagentBodyCache.set(key, lines);
 	if (subagentBodyCache.size > SUBAGENT_BODY_CACHE_MAX) {
@@ -104,6 +118,16 @@ function renderCachedSubagentBody(
 	return lines;
 }
 
+function renderDynamicSubagentBody(
+	snapshot: SubagentSnapshot,
+	expanded: boolean,
+	width: number,
+	theme: Theme,
+): string[] {
+	subagentBodyRenderCount += 1;
+	return boundSubagentBodyLines(renderSubagentSnapshotBody(snapshot, expanded, theme, false), width);
+}
+
 function statusIconKind(status: SubagentSnapshot["status"]): ToolUIStatus {
 	switch (status) {
 		case "completed":
@@ -131,15 +155,25 @@ function renderSubagentStatusLine(snapshot: SubagentSnapshot, theme: Theme, spin
 		snapshot.status === "running" ? spinnerFrame : undefined,
 	);
 	const id = theme.fg("muted", truncateToWidth(replaceTabs(snapshot.id), PREVIEW_LINE_WIDTH, Ellipsis.Unicode));
-	const status = theme.fg("dim", snapshot.status);
+	const retryState = snapshot.liveProgressAvailable !== false ? snapshot.progress?.retryState : undefined;
+	const status = retryState
+		? theme.fg(
+				"warning",
+				`provider degraded · ${providerRetryPhaseLabel(retryState.kind)} · ${providerProgressAgeLabel(retryState, Date.now())}`,
+			)
+		: theme.fg("dim", snapshot.status);
 	const duration = theme.fg("dim", formatDuration(snapshot.durationMs));
 	return `${icon} ${id} ${status} ${duration}`;
 }
 
-// Heavy, cacheable per-subagent body: a pure function of (snapshot content, expanded,
-// theme). No spinner frame and no wall-clock displays leak in (live progress uses
-// `staticTime`), so the module body cache can never serve stale or frozen-ticking lines.
-function renderSubagentSnapshotBody(snapshot: SubagentSnapshot, expanded: boolean, theme: Theme): string[] {
+// Heavy per-subagent body. The cache path uses staticTime=true; the bounded dynamic
+// path opts into wall-clock displays when an active retry exists in the nested tree.
+function renderSubagentSnapshotBody(
+	snapshot: SubagentSnapshot,
+	expanded: boolean,
+	theme: Theme,
+	staticTime = true,
+): string[] {
 	const lines: string[] = [];
 
 	// Static receipt fields (parity with the markdown content for non-await actions).
@@ -174,9 +208,9 @@ function renderSubagentSnapshotBody(snapshot: SubagentSnapshot, expanded: boolea
 	// exists (subagent.ts #liveProgressFields), but the renderer also honors an
 	// explicit `liveProgressAvailable: false` so stale retained progress can never
 	// resurrect a live panel (AC5). `staticTime` keeps wall-clock displays out of
-	// these cached lines.
+	// cached lines when the body is served by the cache.
 	if (snapshot.progress && snapshot.liveProgressAvailable !== false) {
-		for (const pl of renderSubagentLiveProgress(snapshot.progress, expanded, theme, undefined, true)) {
+		for (const pl of renderSubagentLiveProgress(snapshot.progress, expanded, theme, undefined, staticTime)) {
 			lines.push(`  ${pl}`);
 		}
 	} else if (snapshot.liveProgressAvailable && (snapshot.status === "running" || snapshot.status === "queued")) {
@@ -251,26 +285,50 @@ export const subagentToolRenderer = {
 					},
 					theme,
 				);
-				const out: string[] = [truncateToWidth(header, width, Ellipsis.Omit)];
+				const out: string[] = [truncateToWidth(replaceTabs(header), width, Ellipsis.Omit)];
 				// Discoverability: the inline panel is a bounded preview; the session
 				// observer (ctrl+s) streams the full per-subagent message history.
 				if (runningCount > 0) {
-					out.push(truncateToWidth(`  ${theme.fg("dim", "(ctrl+s to observe sessions)")}`, width, Ellipsis.Omit));
+					out.push(
+						truncateToWidth(
+							replaceTabs(`  ${theme.fg("dim", "(ctrl+s to observe sessions)")}`),
+							width,
+							Ellipsis.Omit,
+						),
+					);
+				}
+				const liveProgress = subagents.flatMap(snapshot =>
+					snapshot.progress && snapshot.liveProgressAvailable !== false ? [snapshot.progress] : [],
+				);
+				for (const group of collectProviderDegradationGroups(liveProgress)) {
+					out.push(
+						truncateToWidth(
+							replaceTabs(
+								`  ${theme.fg("warning", `provider degraded: ${group.count} subagents retrying on ${group.provider}`)}`,
+							),
+							width,
+							Ellipsis.Omit,
+						),
+					);
 				}
 
 				snapshotSignatures ??= subagents.map(snapshot =>
 					subagentAwaitRenderedStateSignature([snapshot], result.details),
 				);
 				subagents.forEach((snapshot, index) => {
-					// Fresh per-subagent status line (cheap), then the cached heavy body.
+					// Fresh per-subagent status line (cheap), then a cached or dynamic body.
 					out.push(
 						truncateToWidth(
-							renderSubagentStatusLine(snapshot, theme, options.spinnerFrame),
+							replaceTabs(renderSubagentStatusLine(snapshot, theme, options.spinnerFrame)),
 							width,
 							Ellipsis.Omit,
 						),
 					);
-					out.push(...renderCachedSubagentBody(snapshot, snapshotSignatures![index]!, expanded, width, theme));
+					out.push(
+						...(snapshotHasActiveRetry(snapshot)
+							? renderDynamicSubagentBody(snapshot, expanded, width, theme)
+							: renderCachedSubagentBody(snapshot, snapshotSignatures![index]!, expanded, width, theme)),
+					);
 				});
 				return out;
 			},

package/src/tools/subagent.ts

@@ -936,6 +936,8 @@ function canonicalizeProgressForSignature(progress: AgentProgress): unknown {
 					attempt: progress.retryState.attempt,
 					maxAttempts: progress.retryState.maxAttempts,
 					unbounded: progress.retryState.unbounded ?? false,
+					kind: progress.retryState.kind,
+					provider: progress.retryState.provider ?? null,
 					delayMs: progress.retryState.delayMs,
 					errorMessage: progress.retryState.errorMessage,
 					// startedAtMs intentionally excluded (drives countdown only).

package/vendor/insane-search/MANIFEST.json

@@ -21,7 +21,10 @@
   "exclusionRationale": "Excludes upstream install hooks (SessionStart settings.json mutation), GitHub star-baiting (gh api user/starred), the update-notifier, and the past-session transcript-language scanner. Only the runtime Phase 0-3 engine and its Playwright/stealth templates are vendored.",
   "localPatches": [
     "engine/content_safety.py + FetchResult trust/risk metadata (content_trust, prompt_injection_risk, prompt_injection_signals, untrusted_content_boundary) and to_untrusted_text(): cherry-picked from insane-search a16f7c1 (upstream PR #5, v0.9.0). Adds prompt-injection labelling to the JSON surface (to_dict); the default CLI text output is intentionally left unchanged (plain content preserved, no envelope).",
-    "engine/phase0.py _ytdlp_argv() console-script→module fallback + engine/bias_check.py rel.as_posix() Windows exemption + engine/tests/test_u9.py: cherry-picked from insane-search 33f898d (upstream PR #6, released v0.9.2). Cross-platform yt-dlp resolution; no capability or site logic added."
+    "engine/phase0.py _ytdlp_argv() console-script→module fallback + engine/bias_check.py rel.as_posix() Windows exemption + engine/tests/test_u9.py: cherry-picked from insane-search 33f898d (upstream PR #6, released v0.9.2). Cross-platform yt-dlp resolution; no capability or site logic added.",
+    "engine/validators.py TERMINAL_NONSUCCESS drops Verdict.RATE_LIMITED + engine/fetch_chain.py _rate_limit_backoff(resp) and grid-loop 429 skip-and-continue + probe-phase 429 backoff: local P0 fix. Upstream treated 429 as terminal, so a single rate-limited probe or candidate aborted the whole fetch chain (no grid diversity, no Playwright fallback, no backoff), contradicting the transient-429 routing hints the same module already emitted. Backoff is linear (INSANE_RATE_LIMIT_BACKOFF_S, default 2s, x1..x5) and honours the server-provided Retry-After header (numeric, capped at 30s) on every 429 path (probe and grid). The configured base is validated and clamped (fetch_chain._clamp_rate_limit_base) and the final per-attempt delay is hard-capped to 30s, so a hostile or mis-set INSANE_RATE_LIMIT_BACKOFF_S (non-numeric, NaN, infinite, negative, or huge) can neither crash the chain, hang time.sleep, nor bypass the advertised bound; backoff sleeps stay finite and <=30s so a cancellation (KeyboardInterrupt) between attempts is honoured promptly. No capability or site logic added. Regression coverage: engine/tests/test_rate_limit_backoff.py (deterministic, mocked sleep; includes base-validation and cancellation/timeout regressions).",
+    "engine/transport.py SessionPool.warmup(): bind allow_private = safety.allow_private_default() before use and qualify safety.DEFAULT_MAX_REDIRECTS: local fix for two NameErrors on the same call. warmup() raised NameError on every invocation that passed the safety gate, so per-(host, impersonate) root warmup never actually ran and engine/tests/test_u4.py failed on the vendored tree. Matches the already-correct qualification at transport.py get_or_create(). No capability or site logic added.",
+    "engine/bias_check.py URL_ALLOWLIST adds funcaptcha.com/api.funcaptcha.com (Arkose Labs WAF challenge endpoints already referenced by validators.py and waf_profiles.yaml) and r.jina.ai/jina.ai (generic headless rendering endpoint): local fix so the No-Site-Name gate passes on vendored code. Allowlist-only; both are vendor/infrastructure artifacts, not target-site preferences."
   ],
   "notes": "Runtime engine is invoked via `python3 -m engine \"<url>\" --json` with cwd=this directory and PYTHONPATH pointed at this directory. Phase 0-2 require python3 + curl_cffi; Phase 3 requires node + playwright/playwright-extra/puppeteer-extra-plugin-stealth installed under engine/templates. GJC never auto-installs these dependencies."
 }

package/vendor/insane-search/engine/bias_check.py

@@ -54,6 +54,11 @@ URL_ALLOWLIST = {
     "www.google.com", "google.com",
     # Generic HTTP test endpoint for infrastructure / transport tests.
     "httpbin.org",
+    # WAF vendor challenge domains — product artifacts used in detectors,
+    # NOT target-site biases. Any site running Arkose Labs serves these.
+    "funcaptcha.com", "api.funcaptcha.com",
+    # Jina Reader — generic headless-Chrome rendering service (infra endpoint).
+    "r.jina.ai", "jina.ai",
 }
 
 # Files / dirs that must be clean.

package/vendor/insane-search/engine/fetch_chain.py

@@ -31,6 +31,7 @@ No site-specific branching. Site knowledge enters only via:
 """
 from __future__ import annotations
 
+import math
 import os
 import random
 import time
@@ -47,6 +48,34 @@ _OK_VALUES = (Verdict.STRONG_OK.value, Verdict.WEAK_OK.value)
 _TERMINAL_NONSUCCESS_VALUES = frozenset(v.value for v in TERMINAL_NONSUCCESS)
 
 
+# --- 429 rate-limit backoff bounds -------------------------------------------
+# The configured base (INSANE_RATE_LIMIT_BACKOFF_S) AND the final per-attempt
+# delay are both clamped to a hard 30s ceiling so a hostile or mis-set
+# environment value (huge, negative, NaN, or infinite) can never bypass the
+# advertised bound, hang time.sleep, or crash the fetch chain. Keeping each
+# sleep short and finite is also what makes the backoff cancellable: an
+# abort/KeyboardInterrupt between attempts is honoured promptly rather than
+# blocked behind an unbounded sleep.
+_RATE_LIMIT_MAX_DELAY = 30.0
+_RATE_LIMIT_DEFAULT_BASE = 2.0
+
+
+def _clamp_rate_limit_base(raw) -> float:
+    """Parse INSANE_RATE_LIMIT_BACKOFF_S into a safe, finite, non-negative base.
+
+    Rejects (falls back to the default) any value that is non-numeric, NaN,
+    infinite, or negative; clamps a valid value to the hard ceiling so the
+    linear escalation (base * 1..5) can never exceed the advertised bound.
+    """
+    try:
+        value = float(raw)
+    except (TypeError, ValueError):
+        return _RATE_LIMIT_DEFAULT_BASE
+    if not math.isfinite(value) or value < 0:
+        return _RATE_LIMIT_DEFAULT_BASE
+    return min(value, _RATE_LIMIT_MAX_DELAY)
+
+
 # --- Referer strategies (name → function of original URL) --------------------
 def _self_root(url: str) -> str:
     from urllib.parse import urlsplit
@@ -450,6 +479,32 @@ def _fetch_core(
     def _jitter():
         time.sleep(random.uniform(_jmin / 1000.0, _jmax / 1000.0))
 
+    # 429 backoff: longer than normal jitter. Respects Retry-After header when
+    # available. The configured base is validated/clamped (_clamp_rate_limit_base)
+    # and the final delay is hard-capped to _RATE_LIMIT_MAX_DELAY (30s) so a
+    # pathological INSANE_RATE_LIMIT_BACKOFF_S can never bypass the advertised
+    # bound, hang time.sleep, or defeat cancellation.
+    _rl_base = _clamp_rate_limit_base(os.environ.get("INSANE_RATE_LIMIT_BACKOFF_S", "2.0"))
+    _rl_count = 0
+
+    def _rate_limit_backoff(resp=None):
+        nonlocal _rl_count
+        _rl_count += 1
+        delay = _rl_base * min(_rl_count, 5)  # linear: 2s, 4s, 6s, 8s, 10s cap
+        if resp is not None:
+            try:
+                ra = {k.lower(): v for k, v in dict(getattr(resp, "headers", {}) or {}).items()}.get("retry-after", "")
+                if ra.isdigit():
+                    delay = max(delay, min(int(ra), _RATE_LIMIT_MAX_DELAY))
+            except Exception:
+                pass
+        # Hard ceiling + NaN/negative guard: never hand time.sleep an unbounded
+        # or invalid value (it would hang or raise), and never exceed the
+        # advertised 30s bound.
+        if not math.isfinite(delay) or delay < 0:
+            delay = _RATE_LIMIT_DEFAULT_BASE
+        time.sleep(min(delay, _RATE_LIMIT_MAX_DELAY))
+
     # Surface profile-loader failures as a diagnostic trace entry (not counted
     # as a network attempt).
     load_err = last_load_error()
@@ -533,6 +588,10 @@ def _fetch_core(
             return _give_up(trace, profile_used, last_resp, last_attempt, best_suspect,
                             planned=0, executed=curl_attempts, grid_exhausted=False,
                             stop_reason=probe_attempt.verdict)
+        # Probe-phase 429: back off before entering the grid so the first
+        # grid candidate doesn't immediately hit the same rate window.
+        if probe_attempt.verdict == Verdict.RATE_LIMITED.value:
+            _rate_limit_backoff(probe_resp)
 
     # -------- Phase 2: detect + plan + execute ------------------------------
     if last_resp is not None:
@@ -571,13 +630,20 @@ def _fetch_core(
             if att.verdict in _TERMINAL_NONSUCCESS_VALUES:
                 stop_reason = att.verdict
                 break
+            # 429 rate-limit: transient — back off longer than normal jitter,
+            # then continue to the next candidate (a different TLS/referer
+            # combo may not be rate-limited). Do NOT break the grid.
+            if att.verdict == Verdict.RATE_LIMITED.value:
+                _rate_limit_backoff(resp)
+                continue
         # continuing → polite jitter (only on non-terminal failure)
         _jitter()
     else:
         grid_exhausted = True
         stop_reason = "exhausted"
 
-    # If a terminal-nonsuccess (404/auth/429) stopped us, browser won't help.
+    # If a terminal-nonsuccess (404/auth) stopped us, browser won't help.
+    # NOTE: 429 is NOT terminal — browser fallback is still attempted.
     skip_browser = stop_reason in _TERMINAL_NONSUCCESS_VALUES
 
     # -------- Phase 3: Playwright fallback ----------------------------------

package/vendor/insane-search/engine/transport.py

@@ -77,14 +77,16 @@ class SessionPool:
         if ent is None or ent.warmed:
             return False
         from . import safety
-        ok, _reason = safety.classify_url(root_url, safety.allow_private_default())
+        allow_private = safety.allow_private_default()
+        ok, _reason = safety.classify_url(root_url, allow_private)
         if not ok:
             ent.warmed = True   # don't retry a blocked root
             return False
         ent.warmed = True  # mark first to avoid duplicate warmups under race
         def _do_get(u):
             return ent.session.get(u, timeout=timeout, allow_redirects=False)
-        resp, err = self._fetch_following(_do_get, root_url, allow_private, DEFAULT_MAX_REDIRECTS, ent)
+        resp, err = self._fetch_following(_do_get, root_url, allow_private,
+                                          safety.DEFAULT_MAX_REDIRECTS, ent)
         return resp is not None and err is None
 
     def inject_cookies(self, host: str, impersonate: str,
@@ -120,6 +122,15 @@ class SessionPool:
         """GET via the pooled session (cookie + connection reuse), with an SSRF
         guard: the initial URL and EVERY redirect hop are validated against the
         private/loopback/link-local/metadata block-list before being fetched.
+
+        SECURITY NOTE: This is a resolver-level (pre-connect) check only. It is
+        NOT transport-bound DNS validation — a TOCTOU gap exists between
+        resolution and connection (DNS rebinding), and redirect-to-private
+        authority changes after the initial check are only caught at the next
+        hop boundary. The TypeScript bridge disables the real engine for this
+        reason; this Python guard is a defense-in-depth layer, not equivalent
+        protection against DNS rebinding or redirect-to-private attacks.
+
         Falls back to a one-shot get if no session could be created."""
         from . import safety
         if allow_private is None:

package/vendor/insane-search/engine/validators.py

@@ -81,8 +81,11 @@ class Verdict(Enum):
 
 
 # Verdicts that mean "stop the grid — more TLS attempts cannot help".
+# NOTE: RATE_LIMITED (429) is intentionally EXCLUDED — it is transient.
+# The grid skips the rate-limited candidate, backs off, and continues;
+# a different TLS/referer combo may not be rate-limited.
 TERMINAL_NONSUCCESS = frozenset({
-    Verdict.AUTH_REQUIRED, Verdict.NOT_FOUND, Verdict.RATE_LIMITED,
+    Verdict.AUTH_REQUIRED, Verdict.NOT_FOUND,
 })