@lincoln504/pi-research 0.1.12 → 1.0.0

package/src/utils/input-validation.ts

@@ -5,12 +5,7 @@
  */
 
 import { logger } from '../logger.ts';
-
-/** Maximum query length */
-export const MAX_QUERY_LENGTH = 500;
-
-/** Minimum query length */
-export const MIN_QUERY_LENGTH = 3;
+import { MAX_QUERY_LENGTH, MIN_QUERY_LENGTH } from '../constants.ts';
 
 /**
  * Validate research query
@@ -36,16 +31,19 @@ export function validateQuery(query: string): { isValid: boolean; error?: string
     return { isValid: false, error: `Query must be at most ${MAX_QUERY_LENGTH} characters` };
   }
 
-  // Check for empty or whitespace-only queries
-  if (trimmed === '') {
-    return { isValid: false, error: 'Query cannot be empty or whitespace-only' };
+  // Check for whitespace-only queries
+  if (/^\s+$/.test(query)) {
+    return { isValid: false, error: 'Query cannot be whitespace-only' };
   }
 
   // Check for potentially dangerous patterns
   const dangerousPatterns = [
     /<script/i,
     /javascript:/i,
-    /on\w+\s*=/i, // Event handlers like onclick=
+    /(?<!\w)on\w+\s*=/i, // Event handlers like onclick= — a non-word boundary before `on` rejects
+                         // false positives ("pokemon2=", "season2=") while still catching tag-internal
+                         // slash-delimited handlers ("<svg/onload=", "<img/onerror=") the old [\s"'<]
+                         // class missed (it omitted `/`).
     /<iframe/i,
     /<object/i,
     /<embed/i,

package/src/utils/json-utils.ts

@@ -54,11 +54,69 @@ export function extractJsonFromCodeBlocks<T = unknown>(
   };
 }
 
+/**
+ * Walk forward from `start` tracking brace depth, respecting JSON string literals.
+ * Returns the index of the matching closing `}`, or -1 if not found.
+ * Also returns whether the walk ended while inside a string literal.
+ */
+function findMatchingBracket(text: string, start: number): { index: number; inString: boolean } {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  const open = text[start]!;
+  const close = open === '{' ? '}' : ']';
+
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i]!;
+    if (escaped) { escaped = false; continue; }
+    if (ch === '\\' && inString) { escaped = true; continue; }
+    if (ch === '"') { inString = !inString; continue; }
+    if (inString) continue;
+    if (ch === open) depth++;
+    else if (ch === close) {
+      depth--;
+      if (depth === 0) return { index: i, inString: false };
+    }
+  }
+  return { index: -1, inString };
+}
+
+/**
+ * Deterministically repair common JSON formation errors:
+ * 1. Replace smart quotes (“, ”, ‘, ’) with standard quotes.
+ * 2. Remove trailing commas before closing braces/brackets.
+ */
+function preRepairJson(jsonStr: string): string {
+  return jsonStr
+    // 1. Replace smart quotes
+    .replace(/[\u201C\u201D]/g, '"')
+    .replace(/[\u2018\u2019]/g, "'")
+    // 2. Remove trailing commas (only if they are followed by } or ] while NOT in a string)
+    // This is a bit tricky with regex but works for most common cases
+    .replace(/,\s*([}\]])/g, '$1');
+}
+
+/**
+ * Parse a JSON slice, trying it verbatim first and only running preRepairJson on
+ * failure. preRepairJson rewrites smart quotes and trailing commas even inside
+ * string values, so applying it unconditionally would corrupt otherwise-valid JSON
+ * whose content legitimately contains curly quotes (common when a summary quotes
+ * web text). Raw-first keeps the happy path lossless; repair is the fallback.
+ */
+function parseRawThenRepair(jsonStr: string): unknown {
+  try {
+    return JSON.parse(jsonStr);
+  } catch {
+    return JSON.parse(preRepairJson(jsonStr));
+  }
+}
+
 /**
  * Extract JSON object from raw text
  *
- * Looks for a JSON object spanning from the first `{` to the last `}`.
- * Useful when JSON is embedded in prose without code blocks.
+ * Finds the first `{` then walks forward with depth-tracking (respecting string
+ * literals) to locate its matching `}`. This correctly handles text that contains
+ * multiple JSON objects or has trailing content after the object.
  *
  * @param text - Text to search for JSON object
  * @returns Extraction result with parsed value or error
@@ -67,9 +125,8 @@ export function extractJsonObject<T = unknown>(
   text: string
 ): JsonExtractionResult<T> {
   const objStart = text.indexOf('{');
-  const objEnd = text.lastIndexOf('}');
 
-  if (objStart === -1 || objEnd <= objStart) {
+  if (objStart === -1) {
     return {
       success: false,
       value: undefined,
@@ -77,9 +134,38 @@ export function extractJsonObject<T = unknown>(
     };
   }
 
+  const { index: objEnd, inString } = findMatchingBracket(text, objStart);
+
+  if (objEnd === -1) {
+    // Attempt local repair for truncated JSON
+    logger.debug('[json-utils] JSON object truncated; attempting local repair');
+    let partialText = text.slice(objStart);
+    
+    // If we were inside a string, we MUST close it first
+    if (inString) {
+        partialText += '"';
+    }
+
+    for (let i = 1; i <= 15; i++) {
+      try {
+        const candidate = preRepairJson(partialText + '}'.repeat(i));
+        const parsed = JSON.parse(candidate);
+        logger.debug(`[json-utils] JSON object truncated; salvaged by appending ${inString ? 'quote and ' : ''}${i} closing braces`);
+        return { success: true, value: parsed as T, method: 'raw-object' };
+      } catch {
+        continue;
+      }
+    }
+    
+    return {
+      success: false,
+      value: undefined,
+      error: 'No matching closing brace found and local repair failed',
+    };
+  }
+
   try {
-    const jsonStr = text.slice(objStart, objEnd + 1);
-    const parsed = JSON.parse(jsonStr);
+    const parsed = parseRawThenRepair(text.slice(objStart, objEnd + 1));
     return { success: true, value: parsed as T, method: 'raw-object' };
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
@@ -103,19 +189,48 @@ export function extractJsonObject<T = unknown>(
 export function extractJsonArray<T = unknown>(
   text: string
 ): JsonExtractionResult<T[]> {
-  const stripped = text.trim();
-  
-  // Quick check if it's a JSON array
-  if (!stripped.startsWith('[') || !stripped.endsWith(']')) {
+  const arrStart = text.indexOf('[');
+
+  if (arrStart === -1) {
+    return {
+      success: false,
+      value: undefined,
+      error: 'No JSON array boundaries found',
+    };
+  }
+
+  const { index: arrEnd, inString } = findMatchingBracket(text, arrStart);
+  if (arrEnd === -1) {
+    // Attempt local repair for truncated JSON
+    logger.debug('[json-utils] JSON array truncated; attempting local repair');
+    let partialText = text.slice(arrStart);
+    
+    if (inString) {
+        partialText += '"';
+    }
+
+    for (let i = 1; i <= 15; i++) {
+      try {
+        const candidate = preRepairJson(partialText + ']'.repeat(i));
+        const parsed = JSON.parse(candidate);
+        if (Array.isArray(parsed)) {
+          logger.debug(`[json-utils] JSON array truncated; salvaged by appending ${inString ? 'quote and ' : ''}${i} closing brackets`);
+          return { success: true, value: parsed as T[], method: 'raw-array' };
+        }
+      } catch {
+        continue;
+      }
+    }
+
     return {
       success: false,
       value: undefined,
-      error: 'Text is not a JSON array',
+      error: 'No matching closing bracket found and local repair failed',
     };
   }
 
   try {
-    const parsed = JSON.parse(stripped);
+    const parsed = parseRawThenRepair(text.slice(arrStart, arrEnd + 1));
     if (!Array.isArray(parsed)) {
       return {
         success: false,
@@ -138,9 +253,10 @@ export function extractJsonArray<T = unknown>(
  * Extract JSON with fallback chain
  *
  * Tries multiple extraction methods in order:
- * 1. Code blocks (most reliable)
- * 2. Raw JSON object (for objects)
- * 3. Raw JSON array (for arrays)
+ * 1. Direct parse of the whole trimmed string (the payload IS the JSON)
+ * 2. Code blocks
+ * 3. Raw JSON object (for objects)
+ * 4. Raw JSON array (for arrays)
  *
  * @param text - Text to extract JSON from
  * @param targetType - Whether to expect 'object', 'array', or 'any'
@@ -150,7 +266,25 @@ export function extractJson<T = unknown>(
   text: string,
   targetType: 'object' | 'array' | 'any' = 'any'
 ): JsonExtractionResult<T> {
-  // Try code blocks first (most reliable)
+  // Direct parse first: when the entire response is the JSON payload, a fenced
+  // ```json example embedded INSIDE one of its string values must not win —
+  // code-block-first extraction would latch onto that example and return it
+  // instead of the real payload.
+  try {
+    const direct = JSON.parse(text.trim());
+    const isArray = Array.isArray(direct);
+    const typeMatches =
+      targetType === 'any' ||
+      (targetType === 'array' ? isArray : !isArray && direct !== null && typeof direct === 'object');
+    if (typeMatches && direct !== null && typeof direct === 'object') {
+      logger.debug('[json-utils] Extracted JSON via direct parse of full text');
+      return { success: true, value: direct as T, method: isArray ? 'raw-array' : 'raw-object' };
+    }
+  } catch {
+    // Not a pure-JSON payload — fall through to the extraction chain.
+  }
+
+  // Try code blocks next (most reliable for mixed prose+JSON responses)
   const codeBlockResult = extractJsonFromCodeBlocks<T>(text);
   if (codeBlockResult.success) {
     logger.debug('[json-utils] Extracted JSON from code block');

package/src/utils/llm-usage.ts

@@ -0,0 +1,54 @@
+/**
+ * Unified LLM usage accounting.
+ *
+ * Every billed LLM call in a research run must record its token/cost the same way,
+ * to the same run-scoped `metrics` counters (`llm_tokens_total` / `llm_cost_total`)
+ * and — when a run observer is present — to the live `onTokensConsumed` event. Those
+ * counters are the single source of truth the tool layer reports (see
+ * research-tool-definition.ts → extractRunStats). Prior to this helper the same
+ * extract→increment→emit block was hand-copied at each call site, and drift (a call
+ * site that counted metrics but forgot the observer, or an agentic-repair pass that
+ * counted nothing at all) silently under-reported cost. Route every call site here.
+ */
+
+import type { Model } from '@earendil-works/pi-ai';
+import { extractUsage } from '../types/llm.ts';
+import { metrics } from './metrics.ts';
+
+/** Structural subset of the run observer — just the token sink. Kept structural (rather
+ *  than importing ResearchObserver from core/) so this foundation-layer helper does not
+ *  depend on an upper layer; the full ResearchObserver satisfies it. */
+export interface TokenSink {
+  onTokensConsumed?: (tokens: number, cost: number) => void;
+}
+
+export interface RecordUsageOptions {
+  /** Metrics `component` label (e.g. 'coordinator', 'evaluator', 'researcher'). */
+  component: string;
+  /** Optional complexity label, stringified for the metric labels. */
+  complexity?: number | string;
+  /** Live run observer; receives onTokensConsumed for the interactive cost meter. */
+  observer?: TokenSink | null;
+}
+
+/**
+ * Extract usage from a raw LLM response usage object and record it to the active
+ * run-scoped metrics registry (+ the observer, if any). Zero/absent usage is a no-op.
+ * Returns the extracted { tokens, cost } for callers that also need the value.
+ */
+export function recordLlmUsage(
+  model: Model<any>,
+  rawUsage: unknown,
+  opts: RecordUsageOptions
+): { tokens: number; cost: number } {
+  if (!rawUsage) return { tokens: 0, cost: 0 };
+  const { tokens, cost } = extractUsage(model, rawUsage);
+  if (tokens > 0 || cost > 0) {
+    const labels: Record<string, string> = { component: opts.component };
+    if (opts.complexity !== undefined) labels['complexity'] = String(opts.complexity);
+    metrics.increment('llm_tokens_total', tokens, labels);
+    metrics.increment('llm_cost_total', cost, labels);
+    opts.observer?.onTokensConsumed?.(tokens, cost);
+  }
+  return { tokens, cost };
+}

package/src/utils/log-rotation.ts

@@ -0,0 +1,125 @@
+/**
+ * Log Rotation
+ *
+ * Handles log file rotation and cleanup.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export interface RotationLogger {
+  log(...args: unknown[]): void;
+}
+
+export class LogRotation {
+  private readonly MAX_LOG_SIZE = 10 * 1024 * 1024; // 10MB max file size
+  private readonly MAX_LOG_FILES = 10; // Keep last 10 archived logs
+  private lastRotationCheck: number = 0;
+  private readonly logger: RotationLogger;
+
+  constructor(logger: RotationLogger) {
+    this.logger = logger;
+  }
+
+  /**
+   * Clear all research logs including archives.
+   */
+  clearLogs(logFile: string, logDir: string): void {
+    try {
+      if (fs.existsSync(logFile)) {
+        fs.unlinkSync(logFile);
+      }
+      
+      const files = fs.readdirSync(logDir);
+      const baseName = path.basename(logFile);
+      const archives = files.filter(f => f.startsWith(baseName) && f !== baseName);
+      
+      for (const archive of archives) {
+        try {
+          fs.unlinkSync(path.join(logDir, archive));
+        } catch { /* ignore */ }
+      }
+      
+      this.logger.log('[Logger] All logs and archives cleared.');
+    } catch (err) {
+      this.logger.log('[Logger] Failed to clear logs:', err);
+    }
+  }
+
+  /**
+   * Rotate log files when they exceed MAX_LOG_SIZE.
+   * Archives are created with ISO timestamp suffix.
+   * Old archives beyond MAX_LOG_FILES are cleaned up.
+   */
+  rotateLogFile(logFile: string, logDir: string): void {
+    try {
+      const stats = fs.statSync(logFile);
+      const fileSize = stats.size;
+      
+      if (fileSize <= this.MAX_LOG_SIZE) {
+        return; // No rotation needed
+      }
+      
+      // Create archive filename with timestamp
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const archivePath = `${logFile}.${timestamp}`;
+      
+      // Rename current log file to archive
+      try {
+        fs.renameSync(logFile, archivePath);
+      } catch (renameErr) {
+        // fs.renameSync fails on Windows if target exists (NTFS). Fall back to copy+delete.
+        if (process.platform === 'win32') {
+          fs.copyFileSync(logFile, archivePath);
+          fs.unlinkSync(logFile);
+        } else {
+          throw renameErr;
+        }
+      }
+      
+      // Clean up old archives
+      try {
+        const files = fs.readdirSync(logDir);
+        const logFiles = files
+          .filter(f => f.startsWith(path.basename(logFile)) && f !== path.basename(logFile))
+          .sort(); // Sort by timestamp (oldest first)
+        
+        // Remove excess archives
+        const toDelete = logFiles.slice(0, -this.MAX_LOG_FILES);
+        for (const file of toDelete) {
+          try {
+            fs.unlinkSync(path.join(logDir, file));
+          } catch {
+            // Ignore cleanup errors
+          }
+        }
+      } catch {
+        // Ignore cleanup errors
+      }
+      
+      this.logger.log('[Logger] Rotated log file to:', archivePath);
+    } catch (_error) {
+      // Ignore rotation errors (file might not exist yet, etc.)
+    }
+  }
+
+  /**
+   * Check if rotation is needed and perform if necessary.
+   *
+   * Throttled to one filesystem stat per 60s. We deliberately do NOT offer a
+   * `force` bypass: a previous version forced a check on every WARN/ERROR, which
+   * turned into a synchronous fs.statSync per line (thousands per heavy run) and
+   * also reset the throttle so the timer path never fired. The 60s timer
+   * preserves all log data on rotation regardless of when it lands — a file may
+   * transiently exceed MAX_LOG_SIZE by at most one check interval, which is fine.
+   * @returns true if a rotation check was performed
+   */
+  checkAndRotate(logFile: string, logDir: string): boolean {
+    const now = Date.now();
+    if (now - this.lastRotationCheck > 60_000) {
+      this.rotateLogFile(logFile, logDir);
+      this.lastRotationCheck = now;
+      return true;
+    }
+    return false;
+  }
+}

package/src/utils/log-utils.ts

@@ -0,0 +1,159 @@
+/**
+ * Log Utilities
+ *
+ * Utilities for log configuration, context management, and formatting.
+ */
+
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { randomBytes } from 'node:crypto';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+export interface LogContext {
+  sessionId?: string;
+  sessionFile?: string;
+  cwd?: string;
+  researchRunId?: string;
+  toolName?: string;
+  phase?: string;
+  eventName?: string;
+  [key: string]: unknown;
+}
+
+const logContextStorage = new AsyncLocalStorage<LogContext>();
+
+/**
+ * Resolve the consolidated diagnostic log path.
+ * Defaults to {os.tmpdir()}/pi-research.log; overridable via PI_RESEARCH_LOG_PATH.
+ * All scopes (main process, researchers, embedding server, browser worker) write
+ * to this single file — logging is intentionally consolidated, not per-run-id.
+ */
+export function buildDefaultDebugLogPath(): string {
+  const override = process.env['PI_RESEARCH_LOG_PATH'];
+  if (override) return override;
+  return path.join(os.tmpdir(), 'pi-research.log');
+}
+
+/**
+ * Check whether debug/verbose logging is enabled.
+ *
+ * Reads PI_RESEARCH_DEBUG env var. This env var is kept in sync with
+ * config.DEBUG whenever the config is loaded or saved (see config.ts).
+ * Set to "true" to enable INFO+DEBUG logs.
+ */
+export function isVerboseFromEnv(): boolean {
+  return process.env['PI_RESEARCH_DEBUG'] === 'true';
+}
+
+export function createResearchRunId(): string {
+  return `run-${randomBytes(4).toString('hex')}`;
+}
+
+export function getLogContext(): LogContext {
+  return logContextStorage.getStore() ?? {};
+}
+
+export function runWithLogContext<T>(context: LogContext, callback: () => T): T {
+  const parent = logContextStorage.getStore() ?? {};
+  return logContextStorage.run({ ...parent, ...context }, callback);
+}
+
+export function safeJsonStringify(value: unknown): string {
+  try {
+    return JSON.stringify(value, null, 0);
+  } catch {
+    return '[unserializable]';
+  }
+}
+
+export function formatArg(arg: unknown): string {
+  if (arg instanceof Error) {
+    return arg.stack ?? arg.message;
+  }
+  if (typeof arg === 'object' && arg !== null) {
+    return safeJsonStringify(arg);
+  }
+  return String(arg);
+}
+
+/** Upper bound on a single log message; defends the log file against being
+ *  flooded by large network/scraped payloads passed to the logger. */
+const MAX_LOG_MESSAGE_LENGTH = 10_000;
+
+// ANSI escape sequences embedded in untrusted content (we add our own colours
+// separately for the console). Matching the ESC control byte is the point here.
+// eslint-disable-next-line no-control-regex
+const ANSI_PATTERN = /\x1b\[[0-9;]*[A-Za-z]/g;
+// Credentials embedded in a URL userinfo component: scheme://user:pass@host
+const URL_CREDENTIALS_PATTERN = /([a-z][a-z0-9+.-]*:\/\/)[^/\s:@]+:[^/\s:@]+@/gi;
+// key=value / key: "value" pairs whose key names a secret.
+const SENSITIVE_KV_PATTERN =
+  /\b(api[_-]?key|apikey|access[_-]?token|auth[_-]?token|refresh[_-]?token|secret|client[_-]?secret|password|passwd|pwd|authorization|bearer|set[_-]?cookie|cookie|session[_-]?id|session|csrf[_-]?token|xsrf[_-]?token|private[_-]?key)\b(["']?\s*[:=]\s*["']?)([^\s"',&)]+)/gi;
+// Well-known opaque credential formats (OpenAI, GitHub, AWS, Slack, Anthropic).
+const KNOWN_TOKEN_PATTERN =
+  /\b(sk-[A-Za-z0-9_-]{16,}|gh[posru]_[A-Za-z0-9]{16,}|github_pat_[A-Za-z0-9_]{20,}|AKIA[0-9A-Z]{16}|xox[baprs]-[A-Za-z0-9-]{10,})\b/g;
+// JSON Web Tokens — header.payload.signature, each a base64url segment.
+const JWT_PATTERN = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
+// HTTP Basic credentials: "Basic <base64>".
+const BASIC_AUTH_PATTERN = /\bBasic\s+[A-Za-z0-9+/]{16,}={0,2}/gi;
+// HTTP Bearer credentials: "Bearer <token>". The token is often opaque — many
+// providers (e.g. GLM/zhipuai) use dotted keys that are NOT JWTs and carry no
+// known prefix, so KNOWN_TOKEN_PATTERN/JWT_PATTERN miss them and the KV pass
+// only masks the word "Bearer" (its value class stops at the space). Match the
+// scheme and redact the whole RFC 6750 b64token that follows, whatever its shape.
+const BEARER_AUTH_PATTERN = /\bBearer\s+[A-Za-z0-9._~+/-]+=*/gi;
+// Provider keys not covered by KNOWN_TOKEN_PATTERN: Google API/OAuth, Stripe.
+const PROVIDER_TOKEN_PATTERN =
+  /\b(AIza[0-9A-Za-z_-]{35}|ya29\.[0-9A-Za-z_-]{20,}|[sp]k_(?:live|test)_[0-9A-Za-z]{16,})\b/g;
+// Long opaque hex secrets (>=32 hex chars), e.g. the 64-hex browser auth secret
+// or MD5/SHA-style tokens. Diagnostic logs may over-redact content hashes of
+// this length; that trade-off favors not persisting credentials clear-text.
+const LONG_HEX_SECRET_PATTERN = /\b[0-9a-fA-F]{32,}\b/g;
+// All C0 control characters plus DEL — newlines/carriage returns are the log/
+// terminal-injection vector when written to a raw console line. Matching these
+// control bytes is exactly the intent.
+// eslint-disable-next-line no-control-regex
+const CONTROL_CHARS_PATTERN = /[\x00-\x1f\x7f]/g;
+
+/**
+ * Redact secrets and bound the size of a log message before it is persisted.
+ *
+ * Removes embedded ANSI sequences, masks credentials in URLs, sensitive
+ * key/value pairs, and known token formats, and truncates oversized payloads.
+ * Applied to every message before it reaches the log file or the console, so
+ * neither sink receives clear-text secrets or unbounded network data.
+ */
+export function redactSecrets(message: string): string {
+  let out = message.length > MAX_LOG_MESSAGE_LENGTH
+    ? `${message.slice(0, MAX_LOG_MESSAGE_LENGTH)}…[truncated ${message.length - MAX_LOG_MESSAGE_LENGTH} chars]`
+    : message;
+  out = out.replace(ANSI_PATTERN, '');
+  out = out.replace(URL_CREDENTIALS_PATTERN, '$1[REDACTED]@');
+  // Redact whole-token formats BEFORE the key/value pass: the KV value class
+  // stops at whitespace, so "Authorization: Basic <b64>" would otherwise mask
+  // only the word "Basic" and leave the credential blob exposed.
+  out = out.replace(JWT_PATTERN, '[REDACTED]');
+  out = out.replace(BASIC_AUTH_PATTERN, 'Basic [REDACTED]');
+  // Before the KV pass, for the same reason as Basic above: the KV value class
+  // stops at the space after "Bearer", leaving an opaque token exposed.
+  out = out.replace(BEARER_AUTH_PATTERN, 'Bearer [REDACTED]');
+  out = out.replace(SENSITIVE_KV_PATTERN, (_m, key: string, sep: string) => `${key}${sep}[REDACTED]`);
+  out = out.replace(KNOWN_TOKEN_PATTERN, '[REDACTED]');
+  out = out.replace(PROVIDER_TOKEN_PATTERN, '[REDACTED]');
+  out = out.replace(LONG_HEX_SECRET_PATTERN, '[REDACTED]');
+  return out;
+}
+
+/**
+ * Neutralize control characters (newlines, carriage returns, etc.) so that
+ * untrusted content cannot forge or corrupt a raw console log line
+ * (log-injection defense). Use for sinks that are NOT already structurally
+ * escaped — the JSON log file escapes control chars on its own.
+ */
+export function neutralizeControlChars(message: string): string {
+  // Strip CR/LF explicitly first. These are the actual log-injection vector
+  // (forged/corrupted log lines) and an explicit line-break replacement is the
+  // form static analysis recognizes as a log-injection sanitizer. The second
+  // pass removes any remaining C0 control chars + DEL.
+  return message.replace(/\r\n|\r|\n/g, ' ').replace(CONTROL_CHARS_PATTERN, ' ');
+}

package/src/utils/make-resource-loader.ts

@@ -5,7 +5,7 @@
  * Both files use identical ResourceLoader implementations.
  */
 
-import type { ResourceLoader, ExtensionRuntime } from '@mariozechner/pi-coding-agent';
+import type { ResourceLoader, ExtensionRuntime } from '@earendil-works/pi-coding-agent';
 
 export function makeResourceLoader(systemPromptText: string): ResourceLoader {
   const mockRuntime: ExtensionRuntime = {
@@ -27,6 +27,8 @@ export function makeResourceLoader(systemPromptText: string): ResourceLoader {
     setModel: async () => true,
     getThinkingLevel: () => 'off',
     setThinkingLevel: () => {},
+    assertActive: () => {},
+    invalidate: () => {},
   };
 
   return {