@lincoln504/pi-research 1.5.0 → 1.5.1

package/src/infrastructure/browser/thread-worker.mjs

@@ -1571,6 +1571,8 @@ function isBenignScrapeFailure(error) {
   msg.startsWith("Fetch returned stub:") || // nav-only / near-empty page
   msg.startsWith("Could not extract content from PDF") || // malformed/encrypted/scanned-only PDF
   msg.startsWith("PDF too large") || // exceeds the deliberate 100MB policy cap
+  msg.startsWith("HTML response too large") || // fetch-layer 25MB policy cap — same class as the PDF cap
+  msg.startsWith("Browser HTML too large") || // browser-layer 25MB policy cap
   /^HTTP \d{3}\b/.test(msg) || // remote 4xx/5xx status
   isCloudflareBlockError(error) || isTaskTimeoutError(error) || isPoolShutdownError(error);
 }
@@ -2190,7 +2192,7 @@ async function extractSearchResults(page) {
       try {
         const u = new URL(url);
         const uddg = u.searchParams.get("uddg");
-        if (uddg) url = decodeURIComponent(uddg || "");
+        if (uddg) url = uddg;
       } catch {
       }
       let urlHostname = "";
@@ -2374,7 +2376,8 @@ async function executeScrapeTask(_context, url, signal) {
     }
     const contentType = await response?.headerValue("content-type") || "";
     const status = response?.status?.() ?? 0;
-    if (contentType.includes("application/pdf") || url.toLowerCase().endsWith(".pdf")) {
+    const finalUrl = String(response?.url?.() ?? url);
+    if (contentType.includes("application/pdf") || finalUrl.toLowerCase().endsWith(".pdf")) {
       if (!response) throw new Error(`[Worker] No response received for PDF URL: ${url}`);
       if (status >= 400) throw new Error(`HTTP ${status}`);
       const declaredLength = parseInt(await response.headerValue("content-length").catch(() => null) || "", 10);
@@ -2805,7 +2808,17 @@ async function initBrowser() {
             // silent either, so the mute is applied unconditionally.
             firefox_user_prefs: {
               "media.volume_scale": "0.0",
-              "media.autoplay.default": 5
+              "media.autoplay.default": 5,
+              // SSRF: WebSocket connections bypass BOTH layers of the browser
+              // scrape defense — page.route('**') intercepts HTTP(S) only, and
+              // the serverAddr() rebinding backstop hangs off page.on('response'),
+              // which a WS handshake never fires. A hostile scraped page could
+              // therefore `new WebSocket('ws://10.x.x.x/...')` to probe or reach
+              // internal hosts with no validation, and write any reply into the
+              // DOM that page.content() returns. The scraper extracts static
+              // content (domcontentloaded), so nothing it needs arrives over WS —
+              // disable the channel outright at the engine level.
+              "network.websocket.max-connections": 0
             }
           });
           launchPromise.catch((err) => logToDebugFile3("DEBUG", `[ThreadWorker] Background browser launch rejection: ${err.message}`));

package/src/infrastructure/embedding/embedding-factory.ts

@@ -162,6 +162,31 @@ export async function getEmbedder(config?: Config, _attempt = 0): Promise<IEmbed
     // read → the entry omits it and liveness falls back to a bare signal-0 check.
     const myStartTime = await processLifecycle.getCurrentProcessStartTime();
 
+    // Read-only state (a NEWER build's state file is on disk — mixed-version
+    // window): every state write is suppressed, so the port=-1 candidacy claim
+    // below would never be visible to other processes, every process would
+    // "win" its own election, and the GPU lock would likewise always read as
+    // unowned — the exact concurrent-GPU-init segfault class election + lock
+    // exist to prevent. Degrade to a coordination-free mode instead: no
+    // election, local in-process embedder forced onto CPU (concurrent CPU
+    // inference across processes is safe; the exclusion protects GPU/WebGPU
+    // contexts, and a CPU device never touches the GPU lock). Slower embedding
+    // for the mixed-version window only; normal service resumes once every
+    // session runs the same build.
+    const localCpuForReadOnlyState = (): IEmbedder => {
+      logger.warn(
+        '[EmbeddingFactory] State file is read-only (written by a newer build): cross-process leader election and the GPU lock cannot coordinate in this mode. Skipping election and embedding locally on CPU until all sessions run the same build.',
+      );
+      const embedder = buildInProcessEmbedder({ ...cfg, EMBEDDING_DEVICE: 'cpu' }, stateManager);
+      _embeddingInstance = embedder;
+      _cachedModel = cfg.EMBEDDING_MODEL;
+      _cachedDevice = cfg.EMBEDDING_DEVICE;
+      return embedder;
+    };
+    if (stateManager.isReadOnly?.()) {
+      return localCpuForReadOnlyState();
+    }
+
     // ---- Phase 1: Atomically claim candidacy under the state lock ----
     // Writing port=-1 acts as a mutex: other processes that see it will wait
     // for the real port rather than starting their own model initialization.
@@ -200,6 +225,15 @@ export async function getEmbedder(config?: Config, _attempt = 0): Promise<IEmbed
       return state;
     });
 
+    // Re-check AFTER the claim: the read-only flag is set lazily by the first
+    // read that encounters the newer file — which can be this very updateState.
+    // In that case iAmCandidate is true but the claim write was silently
+    // suppressed: no other process can see it, so proceeding as leader is the
+    // concurrent-election hazard the pre-check above exists to avoid.
+    if (iAmCandidate && stateManager.isReadOnly?.()) {
+      return localCpuForReadOnlyState();
+    }
+
     // A live leader serving a DIFFERENT model must not be adopted: two sessions
     // with different EMBEDDING_MODELs would cross-embed (same-dimension models
     // corrupt the vector space silently). Fall back to a local in-process

package/src/infrastructure/embedding/embedding-server.ts

@@ -350,6 +350,11 @@ export class EmbeddingServer implements IEmbedder {
     // stuck native thread (itself hanging) or touch a device-lost context. Clearing
     // the state registration + closing the HTTP server is enough for re-election;
     // the wedged native resources are abandoned to eventual process exit.
+    // Latch the wedge on the Embedder itself too: it stays registered for
+    // process-exit cleanup (registerGlobalEmbedder), and without the latch that
+    // exit task's dispose() would call pipeline.dispose() on the wedged session
+    // anyway — re-creating at teardown the exact hang this path avoids.
+    this.embedder.markPipelineWedged();
     void this.shutdown(false);
     this.externalOnPoison?.(err);
   }

package/src/infrastructure/state/state-manager.ts

@@ -198,6 +198,21 @@ export class StateManager {
     };
   }
 
+  /**
+   * True once this process has seen a newer-build state file and entered
+   * read-only mode (writes suppressed, reads served from an in-memory default).
+   * In this mode NO cross-process coordination that lives in the state file
+   * works: a GPU-lock acquire always sees "no owner" and the embedding
+   * leader-election CAS always sees an empty slot, so every read-only process
+   * would self-elect — the concurrent-GPU-init class those mechanisms exist to
+   * prevent. Consumers that rely on that exclusion (the embedding factory) must
+   * check this and degrade to a coordination-free mode (local CPU embedding).
+   * The flag is set lazily by the first read that encounters the newer file.
+   */
+  isReadOnly(): boolean {
+    return this.stateTooNew;
+  }
+
   // ==================== Core State Operations ====================
 
   /**

package/src/knowledge/embedder.ts

@@ -50,6 +50,14 @@ export class Embedder {
   private initializingPromise: Promise<void> | null = null;
   private disposePromise: Promise<void> | null = null;
   private recoveryPromise: Promise<void> | null = null;
+  // Latched by the SerialQueue poison path (via EmbeddingServer): a native
+  // inference is permanently hung inside this pipeline. dispose() must then
+  // never call pipeline.dispose() — it would join the stuck native thread, the
+  // exact hazard the poison path's shutdown(false) avoided — yet this instance
+  // stays registered for process-exit cleanup (registerGlobalEmbedder), whose
+  // task calls dispose() unconditionally. Without the latch the teardown path
+  // re-created the hang the step-down deliberately abandoned.
+  private pipelineWedged = false;
 
   private model: string;
   private poolingMode: 'mean' | 'cls' | 'last_token';
@@ -656,6 +664,15 @@ export class Embedder {
     }
   }
 
+  /**
+   * Mark this embedder's pipeline as permanently wedged (a native inference hung
+   * past the SerialQueue hard deadline). From here on, dispose() abandons the
+   * pipeline instead of calling pipeline.dispose() — see pipelineWedged.
+   */
+  markPipelineWedged(): void {
+    this.pipelineWedged = true;
+  }
+
   /**
    * @param reason `'idle'` for the memory-reclaim pause driven by the idle timer —
    *   a later embed is allowed to revive the embedder. Anything else is terminal
@@ -678,9 +695,13 @@ export class Embedder {
     this.disposeReason = reason;
     this.state = 'disposing';
     this.disposePromise = (async () => {
-      // Wait for all active embeddings to complete
+      // Wait for all active embeddings to complete. Pointless when the pipeline
+      // is wedged: the hung call holds its activeEmbeddings slot forever, so the
+      // drain can only time out — skip straight to the (dispose-skipping)
+      // teardown below instead of burning the wait twice at process exit.
       const maxWaitMs = 5000;
       const drainActiveEmbeddings = async (): Promise<void> => {
+        if (this.pipelineWedged) return;
         const startTime = Date.now();
         while (this.activeEmbeddings > 0 && (Date.now() - startTime) < maxWaitMs) {
           await new Promise(resolve => setTimeout(resolve, 50));
@@ -709,14 +730,22 @@ export class Embedder {
       }
 
       if (this.pipeline) {
-        try {
-          if (typeof (this.pipeline as any).dispose === 'function') {
-            await (this.pipeline as DisposablePipeline).dispose();
+        if (this.pipelineWedged) {
+          // See pipelineWedged's declaration: disposing a wedged ORT session
+          // joins the permanently hung native thread. Abandon it — the native
+          // resources die with process exit, which is where this path runs.
+          logger.warn('[embedder] Skipping pipeline.dispose(): pipeline wedged by a permanently hung inference; abandoning native resources to process exit.');
+          this.pipeline = null;
+        } else {
+          try {
+            if (typeof (this.pipeline as any).dispose === 'function') {
+              await (this.pipeline as DisposablePipeline).dispose();
+            }
+          } catch (err) {
+            logger.warn('[embedder] Error during pipeline dispose:', err);
           }
-        } catch (err) {
-          logger.warn('[embedder] Error during pipeline dispose:', err);
+          this.pipeline = null;
         }
-        this.pipeline = null;
       }
 
       // Always release the GPU lock once on dispose (defensive: the gpuLockHeld flag

package/src/knowledge/store-operations.ts

@@ -13,6 +13,52 @@ import { logger } from '../logger.ts';
 import { metrics } from '../utils/metrics.ts';
 import { StoreDocument } from '../core/interfaces/knowledge-interfaces.ts';
 
+/**
+ * Guard against a broken embedder silently writing corrupt vectors: a
+ * wrong-count, empty, ragged, or NaN/Inf-poisoned result would otherwise land
+ * in the FixedSizeList column and surface only as an opaque Arrow error or,
+ * worse, as silently degraded search (NaN distances break ANN ordering). Fail
+ * loudly at the last gate before persistence instead. Shared by the normal
+ * addDocuments path and the re-embed migration (which writes vectors through
+ * its own table handle and previously had no guard at all).
+ */
+export function assertValidEmbeddingVectors(
+  vectors: (Float32Array | number[])[],
+  expectedCount: number,
+  declaredDim: number | null | undefined,
+): void {
+  if (vectors.length !== expectedCount) {
+    throw new Error(
+      `[store] embedder returned ${vectors.length} vectors for ${expectedCount} documents`,
+    );
+  }
+  // Expected width: the embedder's declared dimension, falling back to the
+  // first vector's width. Every vector must match it exactly — a uniformly
+  // wrong width is just as corrupting as a ragged one.
+  const dim = declaredDim && declaredDim > 0 ? declaredDim : (vectors[0]?.length ?? 0);
+  if (dim === 0) {
+    throw new Error('[store] embedder returned empty/zero-width vectors');
+  }
+  for (let i = 0; i < vectors.length; i++) {
+    const v = vectors[i];
+    if (!v || v.length !== dim) {
+      throw new Error(
+        `[store] embedder returned a wrong-width vector at index ${i} (got ${v?.length ?? 0}, expected ${dim})`,
+      );
+    }
+    // A correct-width vector can still be poisoned: a WebGPU device-lost
+    // mid-inference, or a truncated server response coerced through
+    // Float32Array, yields NaN/Inf entries that pass every length check.
+    for (let j = 0; j < v.length; j++) {
+      if (!Number.isFinite(v[j]!)) {
+        throw new Error(
+          `[store] embedder returned a non-finite value (${v[j]}) at vector ${i}, position ${j}`,
+        );
+      }
+    }
+  }
+}
+
 /**
  * Add documents to the store
  */
@@ -35,44 +81,7 @@ export async function addDocumentsToStore(
 
   try {
     const vectors = await embedder.embedMany(docs.map(d => d.text));
-
-    // Guard against a broken embedder silently writing corrupt vectors: a
-    // wrong-count, empty, or ragged result would otherwise land in the
-    // FixedSizeList column and surface only as an opaque Arrow error or, worse,
-    // as silently degraded search. Fail loudly here instead.
-    if (vectors.length !== docs.length) {
-      throw new Error(
-        `[store] embedder returned ${vectors.length} vectors for ${docs.length} documents`,
-      );
-    }
-    // Expected width: the embedder's declared dimension, falling back to the
-    // first vector's width. Every vector must match it exactly — a uniformly
-    // wrong width is just as corrupting as a ragged one.
-    const declaredDim = embedder.getDimension?.();
-    const dim = declaredDim && declaredDim > 0 ? declaredDim : (vectors[0]?.length ?? 0);
-    if (dim === 0) {
-      throw new Error('[store] embedder returned empty/zero-width vectors');
-    }
-    for (let i = 0; i < vectors.length; i++) {
-      const v = vectors[i];
-      if (!v || v.length !== dim) {
-        throw new Error(
-          `[store] embedder returned a wrong-width vector at index ${i} (got ${v?.length ?? 0}, expected ${dim})`,
-        );
-      }
-      // A correct-width vector can still be poisoned: a WebGPU device-lost
-      // mid-inference, or a truncated server response coerced through
-      // Float32Array, yields NaN/Inf entries that pass every length check but
-      // silently corrupt the ANN index (NaN distances break ordering). Scan
-      // here — this is the last gate before the vector is persisted.
-      for (let j = 0; j < v.length; j++) {
-        if (!Number.isFinite(v[j]!)) {
-          throw new Error(
-            `[store] embedder returned a non-finite value (${v[j]}) at vector ${i}, position ${j}`,
-          );
-        }
-      }
-    }
+    assertValidEmbeddingVectors(vectors, docs.length, embedder.getDimension?.());
 
     const data = docs.map((doc, i) => ({
       vector: vectors[i]!,

package/src/knowledge/store.ts

@@ -22,7 +22,7 @@ import * as path from 'node:path';
 import { MigrationStrategy, MigrationResult } from './migration.ts';
 import { metrics } from '../utils/metrics.ts';
 import { createStoreTable, CURRENT_SCHEMA_VERSION } from './store-schema.ts';
-import { addDocumentsToStore, searchStore, findDocumentsByUrl, findRelevantUrls } from './store-operations.ts';
+import { addDocumentsToStore, assertValidEmbeddingVectors, searchStore, findDocumentsByUrl, findRelevantUrls } from './store-operations.ts';
 import { isEmbedderUnreachable } from './embedder-utils.ts';
 import { ServiceLifecycle } from '../core/service-registry.ts';
 import { ServiceNames } from '../core/service-interfaces.ts';
@@ -448,7 +448,16 @@ export class KnowledgeStore implements IKnowledgeStore {
         });
 
         const texts = batchDocs.map(d => d.text);
-        const vectors = await this.options.embedder.embedMany(texts);
+        // Reconnect-wrapped like the warm-up embed in openInternal: a re-embed
+        // migration is a LONG operation, exactly when a leader idle-dispose /
+        // step-down (ECONNREFUSED fast-fail) is most likely — and any throw
+        // here escalates through openInternal's fallback ladder to the 'backup'
+        // strategy, which replaces the fully-intact table with an EMPTY one.
+        // One transient blip must not convert "preserve my data" into that.
+        const vectors = await this.withEmbedderReconnect(embedder => embedder.embedMany(texts));
+        // Same last-gate integrity check as addDocumentsToStore: this path
+        // writes vectors through its own table handle and previously had none.
+        assertValidEmbeddingVectors(vectors, batchDocs.length, this.options.embedder.getDimension?.());
 
         const records = batchDocs.map((doc, idx) => ({
           vector: Array.from(vectors[idx]!),
@@ -1007,11 +1016,24 @@ export class KnowledgeStore implements IKnowledgeStore {
     // coexist, and LanceDB's fragment-scan order typically returns the OLDEST row
     // first — limit(1) would serve the superseded content (and feed its older
     // timestamp to the serve-age gate) until the next successful ingest.
-    const results = await table
+    const whereClause = `url = '${escapedUrl}' AND ingestion_type = 'synthesis-description' AND (${scopeFilter})`;
+    let results = await table
       .query()
-      .where(`url = '${escapedUrl}' AND ingestion_type = 'synthesis-description' AND (${scopeFilter})`)
+      .where(whereClause)
       .limit(16)
       .toArray();
+    if (results.length === 16) {
+      // Cap hit: the OLD generation alone may have filled all 16 slots (a long
+      // description chunks into many rows), leaving the newest generation
+      // entirely outside the fragment-scan window — the sort below would then
+      // pick "newest of the stale". Re-fetch with a bound two generations of
+      // one URL cannot plausibly reach.
+      results = await table
+        .query()
+        .where(whereClause)
+        .limit(1024)
+        .toArray();
+    }
 
     const duration = Date.now() - startTime;
     metrics.observe('knowledge_store_query_duration_ms', duration, { operation: 'rebuild_document' });

package/src/knowledge/writer-queue.ts

@@ -181,8 +181,10 @@ export class WriterQueue implements IWriterQueue {
     };
 
     // Dedup: check if we already have this exact URL+type with identical content.
-    // findByUrl applies scope filtering, so this only dedupes within the
-    // current project's visible scope (local workspace + global entries).
+    // findByUrl applies scope filtering, so this only dedupes within the current
+    // scope's VISIBLE rows — in project mode that is the workspace's own rows only
+    // (getScopeFilter() in project mode excludes global rows), which is correct because
+    // project mode doesn't serve global rows either.
     // Compared against the NEWEST generation, not row order: after a failed prune
     // two generations coexist and findByUrl's order is arbitrary — matching the
     // OLD generation's hash would skip the refresh with the duplicates in place.

package/src/orchestration/deep-research-orchestrator.ts

@@ -226,13 +226,18 @@ export class DeepResearchOrchestrator {
         // to run the SAME round again. Announcing it each time emitted `round_start`
         // 1, 2, 2, 3 — a duplicate rather than the gap the post-loop guard was added for,
         // but the same broken contract for a consumer counting rounds.
-        if (this.currentRound > lastAnnouncedRound) {
+        const firstEntryThisRound = this.currentRound > lastAnnouncedRound;
+        if (firstEntryThisRound) {
           observer?.onRoundStart?.(this.currentRound);
           lastAnnouncedRound = this.currentRound;
         }
 
         // Check infrastructure health (advisory: logs status, never aborts the run).
-        await orchestrationService.checkHealth(this.currentRound, researchId, ctx);
+        // Once per round, not per loop entry: a 'wait' retry re-enters the same
+        // round and must not re-probe the same infrastructure it just probed.
+        if (firstEntryThisRound) {
+          await orchestrationService.checkHealth(this.currentRound, researchId, ctx);
+        }
 
         // 1. Update/Generate Plan
         let plan: ResearchPlan;
@@ -254,7 +259,14 @@ export class DeepResearchOrchestrator {
             });
         } else {
             const synthesisService = await getService<IResearchSynthesisService>(ServiceNames.RESEARCH_SYNTHESIS_SERVICE, ctx, container);
-            observer?.onEvaluationStart?.(this.currentRound);
+            // Same once-per-round contract as round_start above: a 'wait' retry
+            // re-enters this branch for the SAME round, and re-emitting
+            // evaluation_start per retry gave consumers counting evaluations
+            // duplicates (2, 2, 2 for one round-2 evaluation). The progress
+            // pulse below is a status update and stays per-entry.
+            if (firstEntryThisRound) {
+              observer?.onEvaluationStart?.(this.currentRound);
+            }
             observer?.onEvaluationProgress?.('evaluating');
             plan = await planningService.updatePlanForRound({
                 sessionId: researchId,

package/src/orchestration/quick-research-orchestrator.ts

@@ -356,6 +356,13 @@ export class QuickResearchOrchestrator {
 
           // Ensure CITED LINKS section is accurate and consistent
           result = synthesisService.ensureCitedLinks(this.options.researchId, result);
+          // Snapshot BEFORE steering guidance is appended: parseCitations absorbs
+          // any text trailing the last CITED LINKS entry into that entry's
+          // Description (the same mechanism that forced the weak-grounding notice
+          // to sit BEFORE the header), so knowledge-store descriptions must be
+          // parsed from the pre-steering text or a steered quick run stores the
+          // steering block inside the final source's description.
+          const citationSource = result;
 
           // Append steering guidance — only active (consumed by orchestrator) messages
           const finalSteeringMessages = getActiveSteeringMessages(this.options.sessionId);
@@ -386,7 +393,7 @@ export class QuickResearchOrchestrator {
               if (!writer) {
                 logger.debug('[QuickOrchestrator] Writer queue unavailable, skipping link descriptions');
               } else {
-              const citations = parseCitations(result);
+              const citations = parseCitations(citationSource);
               if (citations.length === 0) {
                 logger.warn('[QuickOrchestrator] Researcher produced no parseable CITED LINKS — no descriptions stored for this session');
               }

package/src/orchestration/research-orchestration-service.ts

@@ -209,8 +209,12 @@ export class ResearchOrchestrationService implements IResearchOrchestration {
       return result;
     } catch (error) {
       const researchDuration = Date.now() - researchStart;
-      metrics.observe('research_manager_latency_ms', researchDuration, { depth: String(depth), status: 'error', source: 'extension' });
-      metrics.increment('research_manager_requests_total', 1, { depth: String(depth), status: 'error', source: 'extension' });
+      // Label a user cancel 'cancelled', not 'error' — the orchestrators' own
+      // research_session_duration_ms one layer down already does, and a metrics
+      // consumer diffing the two layers read every quick-mode cancel as an error.
+      const status = signal?.aborted ? 'cancelled' : 'error';
+      metrics.observe('research_manager_latency_ms', researchDuration, { depth: String(depth), status, source: 'extension' });
+      metrics.increment('research_manager_requests_total', 1, { depth: String(depth), status, source: 'extension' });
       throw error;
     } finally {
       // Always release the run-cap slot — on success, error, or abort (the
@@ -366,6 +370,15 @@ export class ResearchOrchestrationService implements IResearchOrchestration {
 
     const researchers = plan.researchers || [];
     const active = new Set<Promise<void>>();
+    // Set just before each fast-stop throw below. A researcher wedged past the
+    // bounded abort/settle waits is ABANDONED by the stop — its promise settles
+    // later, after the run's single terminal callback has fired (and, on the
+    // tool path, after endResearchSession freed the session state). Its late
+    // failure must then be suppressed: recordResearcherFailure would re-create
+    // the just-freed session entry via getPiState's create-on-read (a
+    // process-lifetime leak on the SDK's random per-run sessionIds), and
+    // onResearcherFailure would violate the no-events-after-terminal contract.
+    let runTerminated = false;
     // Honour MAX_CONCURRENT_RESEARCHERS — prevents resource spikes when a plan has many researchers.
     const maxConcurrent: number = (orchestratorOptions.config as Config)?.MAX_CONCURRENT_RESEARCHERS ?? DEFAULTS.MAX_CONCURRENT_RESEARCHERS;
     const maxFailedResearchers: number = (orchestratorOptions.config as Config)?.MAX_FAILED_RESEARCHERS ?? DEFAULTS.MAX_FAILED_RESEARCHERS;
@@ -406,6 +419,7 @@ export class ResearchOrchestrationService implements IResearchOrchestration {
           Promise.allSettled(active).then(() => undefined),
           () => logger.debug('[ResearchOrchestrationService] Fast-stop: active researchers did not settle within bound; proceeding with stop'),
         );
+        runTerminated = true;
         throw createResearchStopError(sessionId, researchId);
       }
 
@@ -467,6 +481,10 @@ export class ResearchOrchestrationService implements IResearchOrchestration {
           // researcher-executor.ts.
           if (signal?.aborted || isAbortSentinel(errMsg) || container?.isDisposing || errMsg.includes('during container disposal')) {
             logger.debug(`[ResearchOrchestrationService] Researcher ${id} cancelled (aborted).`);
+          } else if (runTerminated) {
+            // Abandoned-by-fast-stop researcher settling AFTER the run's
+            // terminal error — see the runTerminated declaration above.
+            logger.debug(`[ResearchOrchestrationService] Researcher ${id} settled after the run's fast-stop terminal error; suppressing post-terminal failure recording (${errMsg}).`);
           } else {
             logger.error(`[ResearchOrchestrationService] Researcher ${id} failed: ${errMsg}`);
             // Record failure (with its root cause) for stopping logic and for the
@@ -525,6 +543,7 @@ export class ResearchOrchestrationService implements IResearchOrchestration {
           () => logger.debug('[ResearchOrchestrationService] Fast-stop: active researchers did not settle within bound; proceeding with stop'),
         );
 
+        runTerminated = true;
         throw createResearchStopError(sessionId, researchId);
       }
     }

package/src/orchestration/research-synthesis-service.ts

@@ -34,7 +34,7 @@ const NO_SOURCES_NOTE =
 const UNVERIFIED_LINKS_NOTE =
   '_None of the links above could be verified: no page fetch succeeded this session and no citation could be matched to retrieved content. They may be inaccurate or invented — check each one before relying on it._';
 
-// Below this many verified sources, a completed report is WEAKLY grounded: it will
+// Below this many cited sources, a completed report is WEAKLY grounded: it will
 // still read as a fully sourced document, but almost none of its claims can trace to
 // retrieved content — exactly the shape of a run where scrapes mostly failed (bot
 // blocks, resource starvation) or the topic had little real coverage, and the model
@@ -45,7 +45,11 @@ const UNVERIFIED_LINKS_NOTE =
 const WEAK_GROUNDING_MIN_SOURCES = 3;
 
 function weakGroundingNote(count: number): string {
-  return `_Grounding notice: only ${count} source${count === 1 ? '' : 's'} could be verified for this report. ` +
+  // "cited", not "verified": since the provenance gate was removed (see the
+  // comment in extractGlobalCitations' caller), this count includes citations
+  // the model wrote whose pages were never successfully retrieved — claiming
+  // they were "verified" overstated what the pipeline checked.
+  return `_Grounding notice: only ${count} source${count === 1 ? ' is' : 's are'} cited in this report. ` +
     'Claims not attributable to the cited source' + (count === 1 ? '' : 's') +
     ' above should be treated as unverified — cross-check anything load-bearing before relying on it._';
 }
@@ -405,7 +409,7 @@ export class ResearchSynthesisService implements IService {
           // string to build knowledge-store entries — a notice placed after the
           // list polluted the stored description of the final source on precisely
           // the degraded runs the notice exists to flag.
-          logger.warn(`[ResearchSynthesisService] Report is weakly grounded: only ${globalCitations.length} verified source(s) — appending grounding notice.`);
+          logger.warn(`[ResearchSynthesisService] Report is weakly grounded: only ${globalCitations.length} cited source(s) — appending grounding notice.`);
           return `${body}\n\n${weakGroundingNote(globalCitations.length)}\n\n${verifiedLinksSection}`;
         }
         return `${body}\n\n${verifiedLinksSection}`;
@@ -422,7 +426,7 @@ export class ResearchSynthesisService implements IService {
       if (globalCitations.length < WEAK_GROUNDING_MIN_SOURCES) {
         // Before the CITED LINKS header for the same parseCitations-absorption
         // reason as the replace path above.
-        logger.warn(`[ResearchSynthesisService] Report is weakly grounded: only ${globalCitations.length} verified source(s) — appending grounding notice.`);
+        logger.warn(`[ResearchSynthesisService] Report is weakly grounded: only ${globalCitations.length} cited source(s) — appending grounding notice.`);
         return `${prose}\n\n${weakGroundingNote(globalCitations.length)}\n\n${verifiedLinksSection}`;
       }
       return `${prose}\n\n${verifiedLinksSection}`;

package/src/orchestration/researcher-executor.ts

@@ -130,7 +130,21 @@ export async function runResearcher(options: RunResearcherOptions): Promise<void
         if (signal?.aborted || container?.isDisposing || stopRequested()) break;
         const delay = Math.min(1000 * Math.pow(2, linkAttempt - 2), config.RESEARCHER_MAX_RETRY_DELAY_MS);
         logger.warn(`[ResearcherExecutor] Researcher ${id} has no initial search results; retry ${linkAttempt - 1}/${config.RESEARCHER_MAX_RETRIES} after ${delay}ms`);
-        await new Promise(r => setTimeout(r, delay));
+        // Abortable, like every sibling sleep in this file (attempt backoff
+        // below, stagger in runResearchers): a plain setTimeout held a cancel
+        // hostage for up to RESEARCHER_MAX_RETRY_DELAY_MS. The loop-top
+        // abort/stop check right after this resolves handles the early wake.
+        await new Promise<void>((resolve) => {
+          const timer = setTimeout(() => {
+            if (signal) signal.removeEventListener('abort', onAbort);
+            resolve();
+          }, delay);
+          const onAbort = () => { clearTimeout(timer); resolve(); };
+          if (signal) {
+            if (signal.aborted) onAbort();
+            else signal.addEventListener('abort', onAbort, { once: true });
+          }
+        });
       }
       if (signal?.aborted || container?.isDisposing || stopRequested()) break;
       try {

package/src/orchestration/session-state.ts

@@ -130,6 +130,23 @@ export function addSteeringMessage(piSessionId: string | undefined, message: str
       state.steeringMessages.splice(evictIdx, 1);
     }
   }
+
+  // 'popped' entries are otherwise pruned only in endResearchSession's
+  // last-run-out branch, which a long-lived pi session that always has at
+  // least one active run never reaches — every Alt+P pop then accumulated one
+  // array entry forever. Bound them to the same cap here; nothing reads a
+  // popped message once it is popped (dedup and eviction above both skip them).
+  const poppedCount = state.steeringMessages.filter(m => m.status === 'popped').length;
+  if (poppedCount > MAX_STEERING_MESSAGES) {
+    let toDrop = poppedCount - MAX_STEERING_MESSAGES;
+    state.steeringMessages = state.steeringMessages.filter(m => {
+      if (m.status === 'popped' && toDrop > 0) {
+        toDrop--;
+        return false;
+      }
+      return true;
+    });
+  }
     
     const steeringMsg: SteeringMessage = {
       id: randomUUID(),