@lincoln504/pi-research 1.4.1 → 1.4.3

package/src/sdk.ts

@@ -369,6 +369,16 @@ async function _doInit(options: ResearchSDKOptions = {}): Promise<void> {
  * Public initialization. Guarantees the SDK is ready for use.
  */
 export async function initResearchSDK(options: ResearchSDKOptions = {}): Promise<void> {
+  // A shutdown may be in flight: isInitialized only flips to false near the END
+  // of _doShutdown (after container disposal), so without this a caller racing a
+  // shutdown would hit the isInitialized branch below, log its "already
+  // initialized" warning, and return believing the SDK is ready — while the
+  // container it would use is mid-teardown or about to be nulled out from under
+  // it. Wait the shutdown out first so this call observes the real post-shutdown
+  // state, mirroring shutdownResearchSDK's symmetric wait on _initPromise.
+  if (_shutdownPromise) {
+    await _shutdownPromise.catch(() => { /* a failed shutdown must not block a fresh init */ });
+  }
   if (isInitialized) {
     logger.warn('[SDK] Research SDK already initialized. Call shutdownResearchSDK() first if you want to re-initialize with new options.');
     return;

package/src/skill-install/skill-installer.ts

@@ -480,7 +480,11 @@ export function uninstallSkill(toolIds?: string[], opts: InstallOptions = {}): U
   }
 
   for (const { tool, path: skillPath } of targets.values()) {
-    if (toolIds && toolIds.length && !toolIds.includes(tool)) {
+    // undefined = every manifest entry; an explicit (including empty) list means
+    // exactly those tools. `toolIds.length` used to gate this, so `[]` was
+    // indistinguishable from `undefined` and silently uninstalled everything —
+    // inconsistent with this file's other list params, where empty means none.
+    if (toolIds !== undefined && !toolIds.includes(tool)) {
       const e = manifest.entries.find(x => x.path === skillPath);
       if (e) keep.push(e);
       continue;

package/src/stackexchange/index.ts

@@ -27,6 +27,7 @@ import {
 } from './output/compact.ts';
 import type { ExtensionContext, AgentToolResult } from '@earendil-works/pi-coding-agent';
 import { logger } from '../logger.ts';
+import { metrics } from '../utils/metrics.ts';
 
 function notify(
   ctx: ExtensionContext,
@@ -86,6 +87,7 @@ export async function stackexchangeCommand(options: {
   try {
     // Check quota before making requests
     if (client.isQuotaExhausted()) {
+      metrics.increment('stackexchange_quota_exhausted_total', 1);
       const quota = client.getQuotaInfo();
       notify(
         ctx,
@@ -103,6 +105,7 @@ export async function stackexchangeCommand(options: {
 
     // Warn if quota is low
     if (client.isQuotaLow()) {
+      metrics.increment('stackexchange_quota_low_total', 1);
       const quota = client.getQuotaInfo();
       notify(
         ctx,

package/src/stackexchange/rest-client.ts

@@ -193,24 +193,19 @@ export class StackExchangeClient {
     });
   }
 
+  // Pure accessor — no metrics side effects. `stackexchangeCommand()` calls this
+  // repeatedly per invocation (pre-request gate checks, success footer, error
+  // footer) purely to read current state for display; incrementing counters here
+  // used to record 2-3x the real number of quota-low/exhausted events per call.
+  // The counters are incremented once, at the single gate check that actually
+  // observes each event (see stackexchange/index.ts).
   getQuotaInfo(): { remaining: number; max: number; requestCount: number; lastBackoff: number | null } {
-    const info = {
+    return {
       remaining: this.quotaRemaining,
       max: this.quotaMax,
       requestCount: this.requestCount,
       lastBackoff: this.lastBackoff,
     };
-    
-    // Track quota exhaustion events
-    if (this.isQuotaExhausted()) {
-      metrics.increment('stackexchange_quota_exhausted_total', 1);
-    }
-    
-    if (this.isQuotaLow()) {
-      metrics.increment('stackexchange_quota_low_total', 1);
-    }
-    
-    return info;
   }
 
   isQuotaExhausted(): boolean {

package/src/tools/research-tool-definition.ts

@@ -17,6 +17,7 @@ import type {
 import type { ExtendedExtensionContext } from '../types/extension-context.ts';
 import type { ResearchDepth, CleanupContext } from '../types/index.ts';
 import { Type, type Static } from 'typebox';
+import { Value } from 'typebox/value';
 import { validateConfig, getConfig, type ConfigInterface } from '../config.ts';
 import { tryGetServiceContainerFromCtx, getService } from '../core/service-registry.ts';
 
@@ -28,7 +29,7 @@ import { redactSecrets } from '../utils/log-utils.ts';
 import { exportResearchReport, appendExportMessage } from '../utils/research-export.ts';
 import { validateAndSanitizeQuery } from '../utils/input-validation.ts';
 import { validateInitialLinks, MAX_INITIAL_LINKS, MAX_INITIAL_LINK_CHARS } from '../utils/url-utils.ts';
-import { startResearchSession, endResearchSession, registerSessionAbort, clearSteeringMessages, getPiActivePanels } from '../orchestration/session-state.ts';
+import { startResearchSession, endResearchSession, registerSessionAbort, clearSteeringMessages, getActiveResearchRunCount } from '../orchestration/session-state.ts';
 import { createResearchTuiManager, hideWorkingIndicator } from '../tui/research-tui-manager.ts';
 import { createCleanupFunction } from '../cleanup/research-cleanup.ts';
 import { createResearchObserver, createObserverState, stopObserverWaveAnimation } from '../observers/research-observer-impl.ts';
@@ -118,6 +119,21 @@ export function createResearchTool(iface?: ConfigInterface): ToolDefinition {
 
   type ResearchParams = Static<typeof parameters>;
 
+  // Same field shapes as `parameters`, but WITHOUT the initialLinks count/length
+  // bounds — used only for the runtime execute() gate below. validateInitialLinks
+  // already enforces those same two bounds with a specific, friendly message
+  // ("at most N URLs...", "at most N characters..."); checking them again here
+  // would just produce the generic 'invalid_parameters' rejection first and mask
+  // that better message. Structural type-checking (initialLinks must still be an
+  // array of strings) is kept, since validateInitialLinks assumes that shape.
+  const executeShapeCheck = Type.Object({
+    query: Type.String(),
+    depth: Type.Optional(Type.Integer({ minimum: 1, maximum: 3 })),
+    model: Type.Optional(Type.String()),
+    excludeTools: Type.Optional(Type.Array(Type.String())),
+    initialLinks: Type.Optional(Type.Array(Type.String())),
+  });
+
   return {
     name: 'research',
     label: 'Research',
@@ -169,6 +185,17 @@ export function createResearchTool(iface?: ConfigInterface): ToolDefinition {
         };
       }
 
+      // Every other tool in this codebase re-validates params against its own
+      // schema before trusting it (the host does not enforce this) — this was the
+      // one exception, relying entirely on incidental downstream checks (a
+      // typeof on query, a warn-gate on excludeTools) for fields that skip both.
+      if (!Value.Check(executeShapeCheck, params)) {
+        return {
+          content: [{ type: 'text', text: 'Error: invalid parameters for research tool.' }],
+          details: { error: 'invalid_parameters' },
+        };
+      }
+
       const { query, depth: rawDepth, model: modelId, excludeTools: paramExcludeTools, initialLinks } = params as ResearchParams;
 
       // Enforce the same bounds the CLI applies to --initial-links: these links are
@@ -227,11 +254,13 @@ export function createResearchTool(iface?: ConfigInterface): ToolDefinition {
         }
         // Steering messages are shared per pi-session. Only reset them when THIS is
         // the last active run — otherwise a finishing run wipes a concurrent sibling
-        // run's queued/active steering mid-flight. This run's panel is still
-        // registered here (endResearchSession runs later in cleanup()), so a count
-        // of <= 1 means no other run is active.
+        // run's queued/active steering mid-flight. This run's abort registration is
+        // still in place here (endResearchSession runs later in cleanup()), so a
+        // count of <= 1 means no other run is active. getActiveResearchRunCount
+        // (not getPiActivePanels) because headless runs never register a panel —
+        // a panel-based check here was always a no-op for headless callers.
         try {
-          if (getPiActivePanels(piSessionId).length <= 1) clearSteeringMessages(piSessionId);
+          if (getActiveResearchRunCount(piSessionId) <= 1) clearSteeringMessages(piSessionId);
         } catch (e) { logger.error('[research] Clear steering messages failed:', e); }
         if (detachAbortListener) {
           try { detachAbortListener(); } catch { /* best-effort */ } finally { detachAbortListener = undefined; }
@@ -344,9 +373,11 @@ export function createResearchTool(iface?: ConfigInterface): ToolDefinition {
               // module-level piSessions map keyed by the STABLE pi session id, so
               // without this every headless run leaked them for the process
               // lifetime (the TUI branch frees them via createCleanupFunction, the
-              // SDK in its own finally; this branch freed only steering).
+              // SDK in its own finally). Steering is NOT cleared here — teardownUi()
+              // already does that, gated on getActiveResearchRunCount so a finishing
+              // run doesn't wipe a concurrent sibling headless run's steering; an
+              // unconditional clear here bypassed that guard entirely.
               endResearchSession(piSessionId, sessionResearchId);
-              clearSteeringMessages(piSessionId);
             };
             
             // Minimal stub — only stopObserverWaveAnimation touches panelState in the

package/src/tools/security.ts

@@ -98,16 +98,6 @@ export function createSecuritySearchTool(options: {
           };
       }
 
-      // Record call in tracker - returns false if limit reached
-      const allowed = options.tracker.recordCall('security_search');
-      if (!allowed) {
-          metrics.increment('tool_security_search_calls_total', 1, { status: 'rate_limited' });
-          return {
-            content: [{ type: 'text', text: options.tracker.getLimitMessage('security_search') }],
-            details: { blocked: true, reason: 'limit_reached' },
-          };
-      }
-
       const p = params as SecuritySearchParamsType;
 
       const terms = p.terms;
@@ -160,6 +150,19 @@ export function createSecuritySearchTool(options: {
       }
       const maxResults = p.maxResults ?? 20;
 
+      // Record call in tracker - returns false if limit reached. Deliberately AFTER
+      // every semantic-validation reject above (terms/databases/severity), same
+      // reasoning as the schema check: a rejected call did no work and must not
+      // permanently consume one of the researcher's shared MAX_GATHERING_CALLS slots.
+      const allowed = options.tracker.recordCall('security_search');
+      if (!allowed) {
+          metrics.increment('tool_security_search_calls_total', 1, { status: 'rate_limited' });
+          return {
+            content: [{ type: 'text', text: options.tracker.getLimitMessage('security_search') }],
+            details: { blocked: true, reason: 'limit_reached' },
+          };
+      }
+
       metrics.increment('tool_security_search_terms_total', terms.length);
       metrics.increment('tool_security_search_databases_total', databases.length);
 

package/src/utils/coverage-digest.ts

@@ -109,7 +109,7 @@ export interface SplitReport {
  * better than one that reaches it short.
  */
 export function splitCoverageDigest(report: string): SplitReport {
-  if (!report) return { digest: '', body: report ?? '' };
+  if (!report) return { digest: '', body: report };
 
   const headerMatch = delimiterRegex(COVERAGE_DIGEST_HEADER).exec(report);
   if (!headerMatch) return { digest: '', body: report };

package/src/utils/host-config.ts

@@ -27,11 +27,22 @@ let _configDirName: string | undefined;
  * Resolution order: explicit env override (`PI_RESEARCH_CONFIG_DIR_NAME`) →
  * the host `@earendil-works/pi-coding-agent` package (only where it is actually
  * resolvable, i.e. the main pi process) → the stable default `.pi`.
+ *
+ * The override is a directory NAME, not a path: it is joined onto
+ * `os.homedir()` by every caller (getGlobalConfigDir() in config.ts), which in
+ * turn is the base for config.env (API keys, chmod 0600), the state dir
+ * (locks, run semaphores), and the knowledge_db. A value containing a path
+ * separator or `..` traverses out of HOME entirely — scripts/cleanup.cjs
+ * already rejects exactly that in its own copy of this resolution (see its
+ * `rawDirName`/`dirName` guard); this must reject it the same way, since this
+ * is the copy every actual run resolves secrets and state through.
  */
 export function getConfigDirName(): string {
   if (_configDirName !== undefined) return _configDirName;
   const override = process.env['PI_RESEARCH_CONFIG_DIR_NAME'];
-  if (override) return (_configDirName = override);
+  if (override && !override.includes('/') && !override.includes('\\') && override !== '.' && override !== '..') {
+    return (_configDirName = override);
+  }
   try {
     const require = createRequire(import.meta.url);
     const host = require('@earendil-works/pi-coding-agent') as { CONFIG_DIR_NAME?: string };

package/src/utils/log-utils.ts

@@ -255,6 +255,16 @@ export function redactSecrets(message: string): string {
     // never negative; it still prefers the larger rawLength when the
     // REDACT_SCAN_LENGTH cut discarded raw content redaction then shrank.
     out = `${out.slice(0, keep)}…[truncated ${Math.max(rawLength, out.length) - keep} chars]`;
+  } else if (rawLength > scanEnd) {
+    // The scanEnd cut (line 220) already dropped `rawLength - scanEnd` raw
+    // chars before redaction ever ran. If redaction then net-shrinks the
+    // scanned prefix enough that `out.length` no longer exceeds
+    // MAX_LOG_MESSAGE_LENGTH (e.g. many long hex/JWT runs each collapsed to
+    // the short literal '[REDACTED]'), the branch above never fires and this
+    // message would otherwise read as complete — silently hiding the tail of
+    // a large scraped page or provider error body with no indication
+    // anything was cut.
+    out = `${out}…[truncated ${rawLength - scanEnd} chars]`;
   }
   return out;
 }

package/src/web-research/browser-search.ts

@@ -5,7 +5,7 @@
  */
 
 import { runWorkerSearch } from '../infrastructure/browser/task-execution-service.ts';
-import { getMaxWorkers } from '../infrastructure/browser/config.ts';
+import { getMaxWorkers, COLD_START_ALLOWANCE_MS } from '../infrastructure/browser/config.ts';
 import { isTaskTimeoutError } from '../infrastructure/browser/browser-error-utils.ts';
 import { logger } from '../logger.ts';
 import { safeUnref } from '../utils/safe-unref.ts';
@@ -82,8 +82,9 @@ export async function performSearch(
     // cannot stall the entire Promise.all burst.
     //
     // The budget mirrors the scheduler's own task ceiling in
-    // BrowserTaskScheduler.runSearch (= SEARCH_TIMEOUT_MS + BROWSER_TASK_TIMEOUT_MS)
-    // so this layer never preempts the worker's deadline with a shorter one.
+    // BrowserTaskScheduler.runSearch (= SEARCH_TIMEOUT_MS + BROWSER_TASK_TIMEOUT_MS +
+    // COLD_START_ALLOWANCE_MS) so this layer never preempts the worker's deadline with
+    // a shorter one.
     //
     // Both clocks now start at DISPATCH (see startQueryDeadline below), which is
     // what makes mirroring the value correct. While this one started at enqueue,
@@ -95,7 +96,13 @@ export async function performSearch(
     // query's worth of wait, and a burst four times the pool's reach exhausts any
     // constant. Measuring execution instead of waiting is the fix; the sum
     // survives as the budget because a search legitimately costs nav plus overhead.
-    const QUERY_TIMEOUT_MS = (config?.SEARCH_TIMEOUT_MS ?? 45_000) + (config?.BROWSER_TASK_TIMEOUT_MS ?? 10_000);
+    //
+    // COLD_START_ALLOWANCE_MS is part of the sum for the same reason it is part of
+    // the scheduler's own ceiling: the first query dispatched to a freshly created or
+    // just-reset worker pays a real browser launch + context creation inline before
+    // any navigation starts, and this layer's budget must not fire before the
+    // scheduler's own (correct, larger) deadline gets a chance to.
+    const QUERY_TIMEOUT_MS = (config?.SEARCH_TIMEOUT_MS ?? 45_000) + (config?.BROWSER_TASK_TIMEOUT_MS ?? 10_000) + COLD_START_ALLOWANCE_MS;
 
     // Deduplicated: resultMap and the failures map are both keyed by the query
     // string, so two tasks for the same string race last-writer-wins — instance A

package/src/web-research/web-scraper.ts

@@ -123,23 +123,34 @@ async function extractPdfToMarkdown(bytes: Uint8Array): Promise<string> {
 
   try {
     const doc = new WasmPdfDocument(bytes);
-    const pageCount = doc.pageCount();
-    
-    let markdown = `# PDF Document\n\n**Pages:** ${pageCount}\n\n`;
-    
+    // free() is native/WASM-side memory, not GC-reclaimed — it must run on
+    // every exit, including the case toMarkdownAll() AND the per-page fallback
+    // both throw (a malformed/encrypted PDF the codebase already treats as
+    // routine on the open web, so this path fires regularly). It used to sit
+    // after the fallback loop, reachable only when nothing below it threw —
+    // the one case that needed the fallback landing squarely on the one case
+    // that skipped the free(), leaking one WasmPdfDocument per occurrence in a
+    // browser-server process that stays warm across many research sessions.
     try {
-      markdown += doc.toMarkdownAll();
-    } catch {
-      for (let i = 0; i < pageCount; i++) {
-        markdown += `## Page ${i + 1}\n\n${doc.toMarkdown(i)}\n\n`;
+      const pageCount = doc.pageCount();
+
+      let markdown = `# PDF Document\n\n**Pages:** ${pageCount}\n\n`;
+
+      try {
+        markdown += doc.toMarkdownAll();
+      } catch {
+        for (let i = 0; i < pageCount; i++) {
+          markdown += `## Page ${i + 1}\n\n${doc.toMarkdown(i)}\n\n`;
+        }
       }
+
+      const pdfExtractionDuration = Date.now() - pdfExtractionStart;
+      metrics.observe('scrape_pdf_conversion_ms', pdfExtractionDuration);
+      metrics.increment('scrape_pdf_conversions_total', 1, { status: 'success', pages: String(pageCount) });
+      return markdown;
+    } finally {
+      doc.free();
     }
-    
-    doc.free();
-    const pdfExtractionDuration = Date.now() - pdfExtractionStart;
-    metrics.observe('scrape_pdf_conversion_ms', pdfExtractionDuration);
-    metrics.increment('scrape_pdf_conversions_total', 1, { status: 'success', pages: String(pageCount) });
-    return markdown;
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
     // debug, not error: a malformed/encrypted/scanned-image-only PDF is an
@@ -300,7 +311,7 @@ async function scrapeWithFetch(url: string, signal?: AbortSignal): Promise<Scrap
     const contentLength = response.headers.get('content-length');
     if (contentLength) {
       const size = parseInt(contentLength, 10);
-      if (contentType.includes('application/pdf') || url.toLowerCase().endsWith('.pdf')) {
+      if (contentType.includes('application/pdf') || currentUrl.toLowerCase().endsWith('.pdf')) {
         if (size > MAX_PDF_SIZE) {
           const sizeMB = Math.round(size / 1024 / 1024);
           logger.warn(`[Scrapers] PDF too large (Content-Length: ${sizeMB}MB, max 100MB), skipping`);
@@ -319,7 +330,7 @@ async function scrapeWithFetch(url: string, signal?: AbortSignal): Promise<Scrap
       }
     }
     
-    if (contentType.includes('application/pdf') || url.toLowerCase().endsWith('.pdf')) {
+    if (contentType.includes('application/pdf') || currentUrl.toLowerCase().endsWith('.pdf')) {
       let pdfBytes: Uint8Array;
       try {
         pdfBytes = await readBodyCapped(response, MAX_PDF_SIZE);

package/src/youtube/potoken.ts

@@ -44,6 +44,7 @@
 import { logger } from '../logger.ts';
 import { safeUnref } from '../utils/safe-unref.ts';
 import { metrics } from '../utils/metrics.ts';
+import { readJsonCapped } from '../utils/http-body.ts';
 
 /**
  * Well-known request key for the YouTube web PoToken program. This is a public
@@ -229,7 +230,13 @@ async function doMint(
       body: JSON.stringify([requestKey, botguardResponse]),
       signal: opts.signal,
     });
-    const integrityJson = (await integrityResponse.json()) as unknown[];
+    if (!integrityResponse.ok) {
+      throw new Error(`HTTP ${integrityResponse.status} from attestation server`);
+    }
+    // The attestation response is a short JSON array; readJsonCapped bounds it the
+    // same way as every other externally-controlled body this codebase reads (the
+    // default 32MB cap is already generous for this endpoint).
+    const integrityJson = await readJsonCapped<unknown[]>(integrityResponse);
     const integrityToken = integrityJson?.[0] as string | undefined;
     if (!integrityToken) {
       throw new Error('Integrity token rejected by attestation server (likely a non-residential IP)');

package/src/youtube/transcript-client.ts

@@ -18,6 +18,7 @@
  */
 
 import { withTimeout, retryWithBackoff, createTimeoutSignal } from '../web-research/retry-utils.ts';
+import { getSsrfSafeFetcher } from '../web-research/scraper-utils.ts';
 import { CircuitBreaker } from '../utils/circuit-breaker.ts';
 import { logger } from '../logger.ts';
 import { redactSecrets } from '../utils/log-utils.ts';
@@ -109,7 +110,31 @@ export async function fetchVideoTranscripts(
   } catch {
     // non-fatal: logging stays at default if the API ever changes
   }
-  const fetchImpl: typeof fetch = (input, init) => fetch(input, init);
+  // Connect-time SSRF pin (see scraper-utils.ts's getSsrfSafeFetcher): closes the
+  // gap between assertTrustedTimedtextUrl's host check below and fetch's own
+  // re-resolution at connect time. The host allowlist only constrains WHICH
+  // hostname a redirect can name; it says nothing about what that hostname
+  // resolves to at the moment the socket opens, and this codebase already
+  // treats a resolver answering differently between validation and connect as
+  // a real threat elsewhere (thread-worker-messaging.ts's DNS-rebinding
+  // backstop applies even to already-trusted hosts). One fetchImpl closure
+  // covers every network call in this batch: the BotGuard/attestation fetches
+  // inside mintPoTokens() and the timedtext fetch below. Falls back to the
+  // plain global fetch for non-string/URL input (never seen in practice here)
+  // since the dispatcher pairing requires a URL string; see getSsrfSafeFetcher's
+  // own doc comment for why the fetch and its dispatcher must travel together.
+  const ssrfFetcher = await getSsrfSafeFetcher();
+  const fetchImpl: typeof fetch = ssrfFetcher
+    ? (input, init) => {
+        if (typeof input === 'string' || input instanceof URL) {
+          return ssrfFetcher.fetch(String(input), {
+            ...(init ?? {}),
+            dispatcher: ssrfFetcher.dispatcher,
+          }) as unknown as Promise<Response>;
+        }
+        return fetch(input, init);
+      }
+    : (input, init) => fetch(input, init);
 
   // 1) Throwaway session to obtain stable visitor data for the PoToken binding.
   let visitorData: string;
@@ -245,10 +270,36 @@ async function fetchOne(
           // response headers AND the body read are bounded and tear the socket
           // down on timeout/cancellation (withTimeout alone would not bound text()).
           const fetchSignal = createTimeoutSignal(timeoutMs, signal);
-          const response = await fetchImpl(url, {
-            signal: fetchSignal,
-            headers: { 'User-Agent': 'Mozilla/5.0', 'Accept-Language': lang },
-          });
+          // Manual redirect following, re-validating each hop against the same
+          // trusted-host allowlist as the first hop. `redirect: 'follow' (the
+          // default) would carry the PoToken-bearing request to whatever host a
+          // 3xx Location header names with no revalidation — assertTrustedTimedtextUrl
+          // above only ever checked base_url, the pre-redirect URL. fetchImpl
+          // carries the connect-time IP pin (see its construction above), so each
+          // hop is also protected against a resolver answering differently
+          // between this host check and the moment the socket actually opens.
+          const MAX_REDIRECTS = 5;
+          let currentUrl = url;
+          let response!: Response;
+          for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
+            response = await fetchImpl(currentUrl, {
+              signal: fetchSignal,
+              redirect: 'manual',
+              headers: { 'User-Agent': 'Mozilla/5.0', 'Accept-Language': lang },
+            });
+            if (response.status >= 300 && response.status < 400) {
+              const location = response.headers.get('location');
+              if (!location) break; // No Location header — treat as final response
+              const resolved = new URL(location, currentUrl).href;
+              assertTrustedTimedtextUrl(resolved);
+              // Drain the redirect response before following: an unconsumed body
+              // pins its socket (undici keeps it open until read/cancelled or GC).
+              void response.body?.cancel()?.catch(() => { /* best-effort */ });
+              currentUrl = resolved;
+              continue;
+            }
+            break; // Non-redirect response
+          }
           // Surface the real HTTP status. Without this, a 403 (age-restricted) or
           // 404 (removed) returns HTML that parseJson3 yields '' for, which would
           // be misreported below as a bot-protection/PoToken failure.