@lincoln504/pi-research 1.3.3 → 1.3.5

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

@@ -22,7 +22,7 @@ import { getMaxScrapeBatches, resolveExcludedTools } from '../constants.ts';
 import type { ResearchObserver } from '../core/interfaces/observer-interfaces.ts';
 import { HeadlessObserver, makeSafeObserver, type HeadlessObserverOptions } from './headless-observer.ts';
 import { getService, tryGetServiceContainerFromCtx } from '../core/service-registry.ts';
-import { ServiceNames, type IWriterQueue, type IKnowledgeStoreService, type IResearchSynthesisService, type IResearchOrchestration } from '../core/service-interfaces.ts';
+import { ServiceNames, type IKnowledgeStoreService, type IResearchSynthesisService, type IResearchOrchestration } from '../core/service-interfaces.ts';
 import type { ResearchSessionService } from './research-session-service.ts';
 import { normalizeUrl, registerScrapedLinks, getCachedScrapedContent } from '../utils/shared-links.ts';
 import { runHealthCheck, isBusyPoolHealthFailure } from '../healthcheck/index.ts';
@@ -347,7 +347,17 @@ export class QuickResearchOrchestrator {
             if (this.config.KNOWLEDGE_STORE_MODE !== 'none') {
             const ksService = await getService<IKnowledgeStoreService>(ServiceNames.KNOWLEDGE_STORE, ctx, container);
             if (ksService.isReady()) {
-              const writer = await getService<IWriterQueue>(ServiceNames.WRITER_QUEUE, ctx, container);
+              // Resolve directly from ksService rather than the WRITER_QUEUE DI
+              // registration — that registration caches the first IWriterQueue it
+              // is ever handed forever, so it goes stale after a Knowledge
+              // Mode/cwd change disposes and rebuilds ksService's internal writer
+              // queue (see research-orchestration-service.ts's storeLinkDescriptions
+              // for the full explanation). ksService.getWriterQueue() always
+              // reflects what initialize() just settled on.
+              const writer = await ksService.getWriterQueue();
+              if (!writer) {
+                logger.debug('[QuickOrchestrator] Writer queue unavailable, skipping link descriptions');
+              } else {
               const citations = parseCitations(result);
               if (citations.length === 0) {
                 logger.warn('[QuickOrchestrator] Researcher produced no parseable CITED LINKS — no descriptions stored for this session');
@@ -375,6 +385,7 @@ export class QuickResearchOrchestrator {
               // Drain so concurrent or subsequent sessions see these entries immediately
               // rather than relying solely on shutdownKnowledgeStore's drain.
               if (enqueued > 0) await writer.drain();
+              }
             }
             }
           } catch (err) {

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

@@ -23,7 +23,6 @@ import { clearSessionCircuitBreaker } from '../infrastructure/browser/browser-er
 import { getService, ServiceLifecycle, tryGetService, tryGetServiceContainerFromCtx } from '../core/service-registry.ts';
 import { ServiceNames } from '../core/service-interfaces.ts';
 import type {
-  IWriterQueue,
   IKnowledgeStoreService,
   IHealthRegistryService,
   IResearchOrchestration,
@@ -548,8 +547,22 @@ export class ResearchOrchestrationService implements IResearchOrchestration {
       }
 
       const synthesisService = await getService<IResearchSynthesisService>(ServiceNames.RESEARCH_SYNTHESIS_SERVICE, ctx, container);
-      const writer = await getService<IWriterQueue>(ServiceNames.WRITER_QUEUE, ctx, container);
-      
+      // Resolve the writer queue directly from the already-fresh ksService rather
+      // than through the WRITER_QUEUE DI registration: that registration caches the
+      // FIRST IWriterQueue object it is ever handed, forever — WriterQueue's own
+      // initialize() is a no-arg lifecycle no-op that never rebuilds its bound
+      // store/chunker, so a later Knowledge Mode/cwd change that disposes and
+      // rebuilds ksService's internal writer queue left every future getService()
+      // call here still returning the stale, disposed one (writes silently dropped
+      // via its "store is closing" guard). ksService.getWriterQueue() always
+      // reflects whatever initialize() just settled on, which the isReady() check
+      // above already confirmed is live.
+      const writer = await ksService.getWriterQueue();
+      if (!writer) {
+        logger.debug('[ResearchOrchestrationService] Writer queue unavailable, skipping link descriptions');
+        return;
+      }
+
       const roundPrefix = `${round}.`;
       let enqueued = 0;
       let researcherCount = 0;

package/src/sdk.ts

@@ -34,6 +34,7 @@ import { HeadlessObserver } from './orchestration/headless-observer.ts';
 import type { Model } from '@earendil-works/pi-ai';
 import { type ExtensionContext, ModelRegistry } from '@earendil-works/pi-coding-agent';
 import { logger, createLogger, setLogger } from './logger.ts';
+import { redactSecrets } from './utils/log-utils.ts';
 import { getConfig, createConfig, validateConfig, resetConfig, type Config } from './config.ts';
 import { metrics, MetricsRegistry, runWithRunRegistry } from './utils/metrics.ts';
 import type { IMetricsSnapshot, RunSummary } from './utils/metrics.ts';
@@ -633,10 +634,18 @@ export function getLastResearcherOutcome(): ResearcherOutcome | null {
  * Emit a single compact line summarizing a run's tracked errors, so they are visible in
  * the operator's log instead of silently accumulating. No-op when the run was clean.
  */
-function logRunErrorSummary(report: ErrorReport | null, depthLabel: string, status: 'success' | 'error'): void {
+export function logRunErrorSummary(report: ErrorReport | null, depthLabel: string, status: 'success' | 'error'): void {
   if (!report || report.totalErrors === 0) return;
+  // Redact BEFORE truncating to 48 chars: p.message is the RAW, unredacted
+  // first-seen error message (unlike p.signature, which extractSignature()
+  // already strips URLs from) — a scrape/navigation failure routinely echoes
+  // the failing URL verbatim, which can carry userinfo credentials
+  // (https://user:pass@host/...). A 48-char window makes landing mid-
+  // credential likely; truncating first would cut it before redactSecrets'
+  // patterns ever see the whole token. Same class of bug as the truncate-
+  // before-redact fix in log-utils.ts's redactSecrets itself.
   const top = report.patterns.slice(0, 3)
-    .map(p => `"${String(p.message ?? p.signature ?? 'error').slice(0, 48)}" ×${p.count}`)
+    .map(p => `"${redactSecrets(String(p.message ?? p.signature ?? 'error')).slice(0, 48)}" ×${p.count}`)
     .join(', ');
   logger.warn(`[SDK] run ${status} with ${report.totalErrors} tracked error(s) across ${report.uniquePatterns} pattern(s) [${depthLabel}]${top ? ` — top: ${top}` : ''}`);
 }

package/src/security/github-advisories.ts

@@ -102,11 +102,20 @@ export async function searchGitHubAdvisories(
 
       const [owner, name] = repoParts;
       // Constrain to GitHub's allowed owner/repo character set before interpolating
-      // into the API path. encodeURIComponent already neutralises traversal, but this
-      // rejects malformed input early instead of issuing a doomed request.
-      const repoNameRe = /^[A-Za-z0-9._-]+$/;
+      // into the API path. encodeURIComponent does NOT neutralise traversal here:
+      // '.' and '-' are unreserved characters it passes through unescaped, so an
+      // owner/name segment of exactly '.' or '..' survives encodeURIComponent
+      // intact and is then collapsed by URL/fetch's own path normalization BEFORE
+      // the request is sent — e.g. owner=".." turns "/repos/../rate_limit/..."
+      // into a request for "/rate_limit/...", escaping the intended
+      // /repos/{owner}/{name}/ scope entirely (verified against the real URL
+      // parser). The negative lookahead rejects a segment that is ENTIRELY dots
+      // (the only shape path normalization treats as a traversal token) while
+      // still allowing legitimate names that merely contain dots (node.js,
+      // socket.io).
+      const repoNameRe = /^(?!\.+$)[A-Za-z0-9._-]+$/;
       if (!repoNameRe.test(owner!) || !repoNameRe.test(name!)) {
-        throw new Error(`Invalid repo format: "${options.repo}". Owner and name may only contain letters, digits, '.', '_' and '-'.`);
+        throw new Error(`Invalid repo format: "${options.repo}". Owner and name may only contain letters, digits, '.', '_' and '-', and cannot be all dots.`);
       }
       const url = `${GITHUB_API_BASE}/repos/${encodeURIComponent(owner!)}/${encodeURIComponent(name!)}/security-advisories?per_page=${perPage}`;
 

package/src/security/osv-types.ts

@@ -237,7 +237,7 @@ export function mapOsvItemToVulnerability(item: OsvVulnerability): Vulnerability
       for (const cwe of item.database_specific.cwe) {
         if (typeof cwe === 'string') {
           cwes.push(cwe);
-        } else if (typeof cwe === 'object' && typeof (cwe as { id?: string }).id === 'string') {
+        } else if (typeof cwe === 'object' && cwe !== null && typeof (cwe as { id?: string }).id === 'string') {
           cwes.push((cwe as { id: string }).id);
         }
       }

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

@@ -374,15 +374,50 @@ export function installSkill(toolIds: string[], opts: InstallOptions = {}): Inst
               continue;
             }
             fs.unlinkSync(absSkillPath);
-            fs.symlinkSync(source, absSkillPath, process.platform === 'win32' ? 'junction' : 'dir');
-            upsertEntry(manifest, { tool: id, path: absSkillPath, type: 'symlink', source, createdAt: now, ...(skillVersion ? { version: skillVersion } : {}) });
-            results.push({ tool: id, path: absSkillPath, type: 'symlink', status: 'installed', message: 're-pointed stale symlink to current source' });
+            try {
+              fs.symlinkSync(source, absSkillPath, process.platform === 'win32' ? 'junction' : 'dir');
+              upsertEntry(manifest, { tool: id, path: absSkillPath, type: 'symlink', source, createdAt: now, ...(skillVersion ? { version: skillVersion } : {}) });
+              results.push({ tool: id, path: absSkillPath, type: 'symlink', status: 'installed', message: 're-pointed stale symlink to current source' });
+            } catch (relinkErr: any) {
+              // The old link is already gone at this point (unlinkSync above
+              // succeeded) — letting this escape to the outer catch below
+              // silently fell through to reporting 'already-installed' for a
+              // path that no longer existed on disk at all. Windows junctions
+              // cannot cross volumes, so a package relocated to a different
+              // drive by an update hits exactly this. Mirror the fresh-install
+              // path's fallback: try a copy rather than leaving the skill
+              // MISSING while claiming success.
+              try {
+                copyDir(source, absSkillPath);
+                upsertEntry(manifest, { tool: id, path: absSkillPath, type: 'copy', source, createdAt: now, ...(skillVersion ? { version: skillVersion } : {}) });
+                results.push({ tool: id, path: absSkillPath, type: 'copy', status: 'installed', message: `symlink re-point unavailable (${relinkErr?.code ?? relinkErr?.message}); copied instead` });
+              } catch (copyErr: any) {
+                results.push({ tool: id, path: absSkillPath, type: 'symlink', status: 'error', message: `symlink re-point failed (${relinkErr?.code ?? relinkErr?.message}) and the copy fallback also failed: ${copyErr?.message ?? String(copyErr)}` });
+              }
+            }
             continue;
           }
         }
-      } catch { /* fall through to already-installed below */ }
+      } catch { /* fall through to already-installed below — lstat/readlink failed (e.g. a TOCTOU race) */ }
       results.push({ tool: id, path: absSkillPath, type, status: 'already-installed' });
-      upsertEntry(manifest, { tool: id, path: absSkillPath, type: isSymlinkPresent(absSkillPath) ? 'symlink' : 'copy', source, createdAt: now, ...(skillVersion ? { version: skillVersion } : {}) });
+      {
+        const isSymlinkNow = isSymlinkPresent(absSkillPath);
+        // A symlink always reflects the live package, so re-stamping the
+        // current version here is accurate. An owned COPY's on-disk content
+        // is NOT touched by this branch — stamping it with the current
+        // version anyway would falsely mark it "up to date," permanently
+        // defeating reconcileSkillInstalls's staleness refresh (which
+        // compares e.version against the current version) on every future
+        // run, since this branch runs on every ordinary re-install/re-check.
+        // Preserve whatever version (if any) was already recorded instead,
+        // so an actually-stale copy still reads as stale until it is really
+        // refreshed.
+        const existingEntry = manifest.entries.find(e => e.path === absSkillPath);
+        const versionField = isSymlinkNow
+          ? (skillVersion ? { version: skillVersion } : {})
+          : (existingEntry?.version ? { version: existingEntry.version } : {});
+        upsertEntry(manifest, { tool: id, path: absSkillPath, type: isSymlinkNow ? 'symlink' : 'copy', source, createdAt: now, ...versionField });
+      }
       continue;
     }
     if (fs.existsSync(absSkillPath) || isSymlinkPresent(absSkillPath)) {
@@ -612,10 +647,38 @@ export function reconcileSkillInstalls(opts: InstallOptions = {}): ReconcileResu
         // Re-point to the current package source (handles update/reinstall).
         try {
           fs.unlinkSync(e.path);
+        } catch { keep.push(e); continue; /* old link untouched; retry next startup */ }
+        try {
           fs.symlinkSync(source, e.path, process.platform === 'win32' ? 'junction' : 'dir');
           keep.push({ ...e, type: 'symlink', source });
           result.repointed.push(e.path);
-        } catch { keep.push(e); /* leave entry; retry next startup */ }
+        } catch {
+          // The old link is already gone at this point (unlinkSync above
+          // succeeded). Mirror installSkill()'s fallback: try a copy rather than
+          // leaving the skill MISSING on disk while the manifest still claims
+          // it's installed (e.g. a Windows cross-volume junction failure).
+          // Stage into a dot-prefixed temp dir and rename into place, same as
+          // the copy-refresh path above — copying directly into e.path left a
+          // partial, SKILL.md-less directory permanently orphaned on disk
+          // (unrecognized by isOwnedCopy) when copyDir failed partway (disk
+          // full, interrupted process).
+          const dir = path.dirname(e.path);
+          const base = path.basename(e.path);
+          const suffix = crypto.randomBytes(4).toString('hex');
+          const fresh = path.join(dir, `.${base}.new-${suffix}`);
+          try {
+            copyDir(source, fresh);
+            fs.renameSync(fresh, e.path);
+            keep.push({ ...e, type: 'copy', source });
+            result.repointed.push(e.path);
+          } catch {
+            try { fs.rmSync(fresh, { recursive: true, force: true }); } catch { /* best effort */ }
+            // Both the re-point and the copy fallback failed — the skill really
+            // is gone from disk now. Drop the entry instead of leaving the
+            // manifest claiming a missing skill is still installed.
+            result.pruned.push(e.path);
+          }
+        }
       } else if (!targetLive) {
         // Dangling with no resolvable source (package fully removed): remove the
         // dead link and drop the entry so the agent's skills dir stays clean.

package/src/stackexchange/index.ts

@@ -22,6 +22,8 @@ import {
 import {
   formatUsersCompact,
   formatSitesCompact,
+  formatQuestionsCompact,
+  formatAnswersCompact,
 } from './output/compact.ts';
 import type { ExtensionContext, AgentToolResult } from '@earendil-works/pi-coding-agent';
 import { logger } from '../logger.ts';
@@ -416,6 +418,19 @@ function formatCompact(result: unknown): string {
         return formatCompactQuestions(result as Question[]);
       }
     }
+  } else if (typeof result === 'object' && result !== null) {
+    if ('question' in result && 'answers' in result) {
+      // command=get's single-question-with-answers shape — mirrors
+      // formatTable's equivalent branch. Without this, format=compact fell
+      // through to the raw JSON.stringify fallback below for this command,
+      // producing an uncurated dump instead of a compact rendering.
+      const r = result as { question: Question; answers: Answer[] };
+      let output = formatQuestionsCompact([r.question]);
+      if (r.answers.length > 0) {
+        output += `\n${formatAnswersCompact(r.answers)}`;
+      }
+      return output;
+    }
   }
   return JSON.stringify(result);
 }

package/src/stackexchange/rest-client.ts

@@ -8,6 +8,7 @@ import { logger } from '../logger.ts';
 import { CircuitBreaker } from '../utils/circuit-breaker.ts';
 import { metrics } from '../utils/metrics.ts';
 import { readJsonCapped, BodyTooLargeError } from '../utils/http-body.ts';
+import { createTimeoutSignal } from '../web-research/retry-utils.ts';
 
 const API_BASE = 'https://api.stackexchange.com/2.3';
 
@@ -88,32 +89,27 @@ export class StackExchangeClient {
         url.searchParams.set('site', 'stackoverflow.com');
       }
 
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => {
-        controller.abort();
-      }, this._timeout);
-
-      // Chain the signal if provided
-      const abortHandler = () => {
-        clearTimeout(timeoutId);
-        controller.abort();
-      };
-      if (signal) {
-        signal.addEventListener('abort', abortHandler, { once: true });
-      }
+      // createTimeoutSignal combines the timeout with an already-provided caller
+      // signal via AbortSignal.any, which — unlike a plain `signal.addEventListener
+      // ('abort', ...)` — correctly produces an already-aborted combined signal
+      // when the caller's signal is aborted BEFORE this call even starts (that
+      // 'abort' event already fired; a listener added afterward never sees it, so
+      // the request went to the network anyway despite the caller having already
+      // cancelled). Matches the same pattern used by the security/*.ts clients.
+      const requestSignal = createTimeoutSignal(this._timeout, signal);
 
       try {
         const response = await fetch(url.toString(), {
           method: options.method,
-          signal: controller.signal,
+          signal: requestSignal,
           headers: {
             'Accept': 'application/json',
           },
         });
 
-        // NB: the timeout is cleared in `finally`, not here. Clearing it now —
-        // when only the headers have arrived — would leave the body read
-        // (readJsonCapped below) with no timeout, so a stalled body could hang
+        // NB: requestSignal stays armed through the body read below (readJsonCapped) —
+        // createTimeoutSignal's underlying timer isn't cleared just because fetch()
+        // resolved with headers, so a stalled body still aborts rather than hanging
         // for the whole process lifetime.
 
         // The SE API returns a structured JSON wrapper (with error_id) even for
@@ -193,13 +189,6 @@ export class StackExchangeClient {
         }
 
         throw error;
-      } finally {
-        // Single clear point: covers both the success and error paths and keeps
-        // the timeout armed across the body read above.
-        clearTimeout(timeoutId);
-        if (signal) {
-          signal.removeEventListener('abort', abortHandler);
-        }
       }
     });
   }

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

@@ -24,6 +24,7 @@ import { ServiceNames } from '../core/service-interfaces.ts';
 import type { IResearchOrchestration, IResearchSynthesisService } from '../core/service-interfaces.ts';
 import { metrics, MetricsRegistry, runWithRunRegistry } from '../utils/metrics.ts';
 import { createResearchRunId, logger, createLogger, isVerboseFromEnv, runWithLogger } from '../logger.ts';
+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';
@@ -507,14 +508,14 @@ export function createResearchTool(iface?: ConfigInterface): ToolDefinition {
             return {
                 content: [{
                     type: 'text',
-                    text: `[SYSTEM MESSAGE]: The research operation was halted gracefully because an API rate limit (HTTP 429) was reached. Please inform the user that the operation was stopped due to provider rate limits and they should wait a moment before trying again.\n\nDetails: ${String(error)}`
+                    text: `[SYSTEM MESSAGE]: The research operation was halted gracefully because an API rate limit (HTTP 429) was reached. Please inform the user that the operation was stopped due to provider rate limits and they should wait a moment before trying again.\n\nDetails: ${redactSecrets(String(error))}`
                 }],
                 details: {}
             };
         }
 
         logger.error('[research] run failed', error);
-        return { content: [{ type: 'text', text: `Research failed: ${String(error)}` }], details: {} };
+        return { content: [{ type: 'text', text: `Research failed: ${redactSecrets(String(error))}` }], details: {} };
       } finally {
         // Guarantees panel teardown even when the run fails before the inner
         // research loop is reached (e.g. health-check failure), where the inner

package/src/tools/scrape.ts

@@ -24,6 +24,7 @@ import {
   MAX_SCRAPE_CONTENT_CHARS_PER_DOC,
 } from '../constants.ts';
 import { truncateWithMarker } from '../utils/text-utils.ts';
+import { redactSecrets } from '../utils/log-utils.ts';
 import { type Config, getConfig } from '../config.ts';
 import { getService, tryGetServiceContainerFromCtx } from '../core/service-registry.ts';
 import { ServiceNames } from '../core/service-interfaces.ts';
@@ -261,16 +262,17 @@ export function createScrapeTool(options: {
       const concurrency = p.maxConcurrency || defaultConcurrency;
       
       try {
-        const results = await scrape(urlsToFetch, concurrency, signal, options.config, getGlobalState().researchId, (result) => {
+        const results = await scrape(urlsToFetch, concurrency, signal, config, getGlobalState().researchId, (result) => {
           options.onUrlScrapeResult?.(result.url, result.success);
         }, container);
         freshResults = Array.isArray(results) ? results : [];
       } catch (error) {
-          logger.error(`[scrape tool] Scrape failed: ${error instanceof Error ? error.message : String(error)}`);
+          const message = error instanceof Error ? error.message : String(error);
+          logger.error(`[scrape tool] Scrape failed: ${message}`);
           metrics.increment('tool_scrape_calls_total', 1, { status: 'error' });
           return {
-            content: [{ type: 'text', text: `# Scrape Failed\n\n${error instanceof Error ? error.message : String(error)}` }],
-            details: { error: String(error) },
+            content: [{ type: 'text', text: `# Scrape Failed\n\n${redactSecrets(message)}` }],
+            details: { error: redactSecrets(String(error)) },
           };
       }
 

package/src/tools/security.ts

@@ -13,6 +13,15 @@ import { getMaxGatheringCalls } from '../constants.ts';
 import { metrics } from '../utils/metrics.ts';
 import type { SecuritySearchParams } from '../security/types.ts';
 
+const MAX_DESCRIPTION_CHARS = 300;
+
+/** Truncates an advisory description for the markdown summary line. */
+function truncateDescription(description: string): string {
+  return description.length > MAX_DESCRIPTION_CHARS
+    ? `${description.substring(0, MAX_DESCRIPTION_CHARS)}...`
+    : description;
+}
+
 export function createSecuritySearchTool(options: {
   ctx: ExtensionContext;
   tracker: ToolUsageTracker;
@@ -229,7 +238,7 @@ export function createSecuritySearchTool(options: {
               }
             }
             const description = vuln.description;
-            markdown += `- **Description:** ${description.length > 300 ? `${description.substring(0, 300)}...` : description}\n`;
+            markdown += `- **Description:** ${truncateDescription(description)}\n`;
             if (vuln.knownExploited === true) {
               markdown += '- **[Actively Exploited]**\n';
             }
@@ -270,7 +279,7 @@ export function createSecuritySearchTool(options: {
               markdown += `- **Product:** ${vuln.product}\n`;
             }
             const description = vuln.description;
-            markdown += `- **Description:** ${description.length > 300 ? `${description.substring(0, 300)}...` : description}\n`;
+            markdown += `- **Description:** ${truncateDescription(description)}\n`;
             if (vuln.dueDate !== undefined) {
               markdown += `- **Due Date:** ${vuln.dueDate}\n`;
             }
@@ -310,7 +319,7 @@ export function createSecuritySearchTool(options: {
             }
             markdown += `- **Summary:** ${adv.summary}\n`;
             const description = adv.description ?? '';
-            markdown += `- **Description:** ${description.length > 300 ? `${description.substring(0, 300)}...` : description}\n`;
+            markdown += `- **Description:** ${truncateDescription(description)}\n`;
             if (adv.published) {
               markdown += `- **Published:** ${adv.published}\n`;
             }
@@ -344,7 +353,7 @@ export function createSecuritySearchTool(options: {
             markdown += `### ${vuln.id}\n`;
             markdown += `- **Severity:** ${vuln.severity}\n`;
             const description = vuln.description;
-            markdown += `- **Description:** ${description.length > 300 ? `${description.substring(0, 300)}...` : description}\n`;
+            markdown += `- **Description:** ${truncateDescription(description)}\n`;
             if (vuln.affectedProducts && vuln.affectedProducts.length > 0) {
               markdown += `- **Affected:** ${vuln.affectedProducts.join(', ')}\n`;
             }

package/src/utils/input-validation.ts

@@ -89,13 +89,3 @@ export function validateAndSanitizeQuery(query: string): string {
 
   return sanitizeQuery(query);
 }
-
-/**
- * Validate complexity level
- *
- * @param complexity - The complexity level to validate
- * @returns True if valid, false otherwise
- */
-export function validateComplexity(complexity: number): boolean {
-  return complexity === 0 || complexity === 1 || complexity === 2 || complexity === 3;
-}

package/src/utils/json-utils.ts

@@ -356,81 +356,3 @@ export function extractJson<T = unknown>(
     error: 'No valid JSON found using any extraction method',
   };
 }
-
-/**
- * Result of string array normalization
- */
-export interface NormalizeArrayResult {
-  /** Normalized strings */
-  strings: string[];
-  /** Count of items that were skipped (empty after normalization) */
-  skippedCount: number;
-  /** Count of items that were objects and needed extraction */
-  extractedCount: number;
-  /** Warnings about any issues */
-  warnings: string[];
-}
-
-/**
- * Normalize string array with detailed feedback
- *
- * Normalizes an array of values to strings with detailed feedback
- * about what was normalized and any issues.
- *
- * @param arr - Array of values to normalize
- * @returns Detailed normalization result
- */
-export function normalizeStringArrayDetailed(
-  arr: unknown[]
-): NormalizeArrayResult {
-  const strings: string[] = [];
-  const warnings: string[] = [];
-  let skippedCount = 0;
-  let extractedCount = 0;
-
-  arr.forEach((item, index) => {
-    if (typeof item === 'string') {
-      const trimmed = item.trim();
-      if (trimmed.length > 0) {
-        strings.push(trimmed);
-      } else {
-        skippedCount++;
-        warnings.push(`Item ${index}: empty string`);
-      }
-    } else if (item !== null && typeof item === 'object') {
-      extractedCount++;
-      const obj = item as Record<string, unknown>;
-      const candidate = obj['query'] ?? obj['topic'] ?? obj['text'] ?? obj['task'];
-      
-      if (typeof candidate === 'string') {
-        const trimmed = candidate.trim();
-        if (trimmed.length > 0) {
-          strings.push(trimmed);
-        } else {
-          skippedCount++;
-          warnings.push(`Item ${index}: object extracted empty string`);
-        }
-      } else {
-        // No recognized key, stringify the whole object
-        const stringified = JSON.stringify(item);
-        if (stringified.length > 0) {
-          strings.push(stringified);
-          warnings.push(`Item ${index}: no recognized key, stringified object`);
-        } else {
-          skippedCount++;
-          warnings.push(`Item ${index}: object stringified to empty`);
-        }
-      }
-    } else {
-      const stringified = String(item).trim();
-      if (stringified.length > 0) {
-        strings.push(stringified);
-      } else {
-        skippedCount++;
-        warnings.push(`Item ${index}: ${typeof item} converted to empty string`);
-      }
-    }
-  });
-
-  return { strings, skippedCount, extractedCount, warnings };
-}

package/src/utils/log-rotation.ts

@@ -10,6 +10,25 @@ export interface RotationLogger {
   log(...args: unknown[]): void;
 }
 
+// Numeric equivalent of the 'a' flag string (O_WRONLY|O_APPEND|O_CREAT), with
+// O_NOFOLLOW added when the platform defines it (not available on Windows) so
+// the open refuses to follow a symlink an attacker with write access to the
+// log directory could plant at this path in the window between the preceding
+// unlink/rename and this reopen — defense-in-depth on top of an already-narrow
+// threat model (it requires local write access to this directory to begin with).
+const APPEND_CREATE_NOFOLLOW_FLAGS =
+  fs.constants.O_WRONLY | fs.constants.O_APPEND | fs.constants.O_CREAT |
+  (typeof fs.constants.O_NOFOLLOW === 'number' ? fs.constants.O_NOFOLLOW : 0);
+
+/** Best-effort (re)create `filePath` with `mode`, refusing to follow a symlink
+ * planted at the path. Failures are swallowed by design — see call sites.
+ * Exported for unit testing of the symlink-refusal behavior. */
+export function touchOwnerOnly(filePath: string, mode: number): void {
+  try {
+    fs.closeSync(fs.openSync(filePath, APPEND_CREATE_NOFOLLOW_FLAGS, mode));
+  } catch { /* best-effort — the next append recreates the file */ }
+}
+
 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
@@ -30,9 +49,7 @@ export class LogRotation {
         // Same rationale as the post-rotation recreate in rotateLogFile: the
         // unlink discarded the 0o600 file, and a umask-default recreate by the
         // next append would drop the owner-only posture.
-        try {
-          fs.closeSync(fs.openSync(logFile, 'a', 0o600));
-        } catch { /* best-effort — the next append recreates the file */ }
+        touchOwnerOnly(logFile, 0o600);
         // And, as there, re-stamp the mode: a concurrent append landing between
         // the unlink and the open makes the creation-time 0o600 a no-op.
         try {
@@ -94,9 +111,7 @@ export class LogRotation {
       // world-traversable tmpdir, silently dropping the owner-only posture Logger
       // establishes at construction. Mode applies only at creation, so this is
       // harmless where a file already exists or mode semantics differ (win32).
-      try {
-        fs.closeSync(fs.openSync(logFile, 'a', 0o600));
-      } catch { /* best-effort — the next append recreates the file */ }
+      touchOwnerOnly(logFile, 0o600);
       // The mode above applies only if THIS open created the file. Several
       // processes append to this consolidated log, so a concurrent async append
       // can recreate it at umask perms between the rename and the open, turning