@lincoln504/pi-research 1.3.3 → 1.3.4

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

@@ -45,12 +45,7 @@ function formatArg(arg) {
   return String(arg);
 }
 function redactSecrets(message) {
-  let keep = MAX_LOG_MESSAGE_LENGTH;
-  if (message.length > keep) {
-    const lastKeptUnit = message.charCodeAt(keep - 1);
-    if (lastKeptUnit >= 55296 && lastKeptUnit <= 56319) keep -= 1;
-  }
-  let out = message.length > MAX_LOG_MESSAGE_LENGTH ? `${message.slice(0, keep)}\u2026[truncated ${message.length - keep} chars]` : message;
+  let out = message;
   out = out.replace(ANSI_PATTERN, "");
   out = out.replace(URL_CREDENTIALS_PATTERN, "$1[REDACTED]@");
   out = out.replace(JWT_PATTERN, "[REDACTED]");
@@ -61,6 +56,14 @@ function redactSecrets(message) {
   out = out.replace(KNOWN_TOKEN_PATTERN, "[REDACTED]");
   out = out.replace(PROVIDER_TOKEN_PATTERN, "[REDACTED]");
   out = out.replace(LONG_HEX_SECRET_PATTERN, "[REDACTED]");
+  let keep = MAX_LOG_MESSAGE_LENGTH;
+  if (out.length > keep) {
+    const lastKeptUnit = out.charCodeAt(keep - 1);
+    if (lastKeptUnit >= 55296 && lastKeptUnit <= 56319) keep -= 1;
+  }
+  if (out.length > MAX_LOG_MESSAGE_LENGTH) {
+    out = `${out.slice(0, keep)}\u2026[truncated ${out.length - keep} chars]`;
+  }
   return out;
 }
 function stripTerminalEscapes(message) {
@@ -75,7 +78,7 @@ var init_log_utils = __esm({
     ANSI_PATTERN = /\x1b\[[0-9;]*[A-Za-z]/g;
     URL_CREDENTIALS_PATTERN = /([a-z][a-z0-9+.-]*:\/\/)[^/\s:@]+:[^/\s:@]+@/gi;
     COOKIE_HEADER_PATTERN = /\b(set[_-]?cookie|cookie)\b(["']?\s*[:=]\s*["']?)([^\r\n]+)/gi;
-    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;
+    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|key)\b(["']?\s*[:=]\s*["']?)([^\s"',&)]+)/gi;
     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;
     JWT_PATTERN = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
     BASIC_AUTH_PATTERN = /\bBasic\s+[A-Za-z0-9+/]{16,}={0,2}/gi;
@@ -588,7 +591,10 @@ async function captureStdio(logFile, hasSufficientDiskSpace, task, sessionId) {
     unkeyedCaptureDepth++;
     isAnyLoggerCapturingOutput = true;
   }
-  const decoder = new TextDecoder();
+  const stderrDecoder = new TextDecoder();
+  const stdoutDecoder = new TextDecoder();
+  const fd1SyncDecoder = new TextDecoder();
+  const fd2SyncDecoder = new TextDecoder();
   const originalStderrWrite = process.stderr.write;
   const originalStdoutWrite = process.stdout.write;
   const originalFsWriteSync = fs4.writeSync;
@@ -634,7 +640,11 @@ async function captureStdio(logFile, hasSufficientDiskSpace, task, sessionId) {
   console.debug = createConsolePatch("debug", logFile, hasSufficientDiskSpace);
   process.stderr.write = (chunk, encodingOrCb, callback) => {
     const cb = typeof encodingOrCb === "function" ? encodingOrCb : callback;
-    const message = typeof chunk === "string" ? chunk : decoder.decode(chunk);
+    const message = typeof chunk === "string" ? chunk : stderrDecoder.decode(chunk, { stream: true });
+    if (message.length === 0) {
+      if (typeof cb === "function") cb();
+      return true;
+    }
     if (!hasSufficientDiskSpace()) {
       if (typeof cb === "function") cb();
       return true;
@@ -655,7 +665,7 @@ async function captureStdio(logFile, hasSufficientDiskSpace, task, sessionId) {
     return true;
   };
   process.stdout.write = (chunk, encodingOrCb, callback) => {
-    const message = typeof chunk === "string" ? chunk : decoder.decode(chunk);
+    const message = typeof chunk === "string" ? chunk : stdoutDecoder.decode(chunk, { stream: true });
     const isNative = isNativeLog(message);
     const complexTui = isComplexTui(message);
     const boxDrawing = isBoxDrawing(message);
@@ -709,7 +719,11 @@ async function captureStdio(logFile, hasSufficientDiskSpace, task, sessionId) {
     if (!descriptor || (descriptor.writable || descriptor.set)) {
       fs4.writeSync = (fd, chunk, ...args) => {
         if (fd === 1 || fd === 2) {
-          const message = typeof chunk === "string" ? chunk : decoder.decode(chunk);
+          const fdDecoder = fd === 1 ? fd1SyncDecoder : fd2SyncDecoder;
+          const message = typeof chunk === "string" ? chunk : fdDecoder.decode(chunk, { stream: true });
+          if (fd === 2 && message.length === 0) {
+            return typeof chunk === "string" ? Buffer.from(chunk).length : chunk.length;
+          }
           const isNative = isNativeLog(message);
           const boxDrawing = isBoxDrawing(message);
           const complexTui = isComplexTui(message);
@@ -1489,6 +1503,7 @@ function isBenignScrapeFailure(error) {
   return msg.startsWith("Fetch blocked:") || // bot-protection interstitial (Cloudflare, DDoS-Guard, …)
   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
   /^HTTP \d{3}\b/.test(msg) || // remote 4xx/5xx status
   isCloudflareBlockError(error) || isTaskTimeoutError(error) || isPoolShutdownError(error);
 }
@@ -1914,32 +1929,29 @@ async function createPageSafe(context2) {
   const currentLock = pageCreationLock;
   pageCreationLock = currentLock.then(() => nextLock);
   await currentLock;
+  const pagePromise = context2.newPage();
+  pagePromise.then(release, release);
+  pagePromise.catch((err) => logToDebugFile2("DEBUG", `[ThreadWorker] Background page creation rejection: ${err.message}`));
+  let timeoutId;
   try {
-    const pagePromise = context2.newPage();
-    pagePromise.catch((err) => logToDebugFile2("DEBUG", `[ThreadWorker] Background page creation rejection: ${err.message}`));
-    let timeoutId;
-    try {
-      const result = await Promise.race([
-        pagePromise,
-        new Promise((_, reject) => {
-          timeoutId = setTimeout(() => reject(new Error("Browser page creation timed out after 60000ms")), 6e4);
-        })
-      ]);
-      if (timeoutId) clearTimeout(timeoutId);
-      return result;
-    } catch (err) {
-      if (timeoutId) clearTimeout(timeoutId);
-      pagePromise.then((p) => {
-        try {
-          p?.close?.();
-        } catch {
-        }
-      }).catch(() => {
-      });
-      throw err;
-    }
-  } finally {
-    release();
+    const result = await Promise.race([
+      pagePromise,
+      new Promise((_, reject) => {
+        timeoutId = setTimeout(() => reject(new Error("Browser page creation timed out after 60000ms")), 6e4);
+      })
+    ]);
+    if (timeoutId) clearTimeout(timeoutId);
+    return result;
+  } catch (err) {
+    if (timeoutId) clearTimeout(timeoutId);
+    pagePromise.then((p) => {
+      try {
+        p?.close?.();
+      } catch {
+      }
+    }).catch(() => {
+    });
+    throw err;
   }
 }
 function setWorkerId2(id) {
@@ -2339,6 +2351,7 @@ init_logger();
 
 // src/utils/url-utils.ts
 init_logger();
+init_log_utils();
 
 // src/config.ts
 var ConfigSchema = Type.Object({
@@ -2508,6 +2521,7 @@ var initPromise = null;
 var workerId3 = "";
 var activeTaskCount = 0;
 var resetPending = false;
+var resetPendingForBrowser = null;
 function setWorkerId3(id) {
   workerId3 = id;
 }
@@ -2518,7 +2532,11 @@ function taskFinished() {
   activeTaskCount = Math.max(0, activeTaskCount - 1);
   if (activeTaskCount === 0 && resetPending) {
     resetPending = false;
-    doResetBrowser();
+    const capturedBrowser = resetPendingForBrowser;
+    resetPendingForBrowser = null;
+    if (browser === capturedBrowser) {
+      doResetBrowser();
+    }
   }
 }
 var isBrowserConnected = () => {
@@ -2655,6 +2673,7 @@ function doResetBrowser() {
 function resetBrowser() {
   if (activeTaskCount > 1) {
     resetPending = true;
+    resetPendingForBrowser = browser;
     return;
   }
   doResetBrowser();

package/src/infrastructure/knowledge-store-service.ts

@@ -311,6 +311,17 @@ export class KnowledgeStoreService implements IKnowledgeStoreService {
       } catch {
         // init failed; its own catch already reset state — nothing to wait on.
       }
+      // Re-check: a SECOND concurrent dispose() call can reach this same point
+      // (its own _disposalPromise check above also saw null, before either of
+      // us had published one) and, if it settles the await first, publish its
+      // own disposal while we were still awaiting. Without this, both calls
+      // would go on to capture the SAME embedder/store/writerQueue/initLock
+      // references below and each independently call .dispose()/.close() on
+      // them — the same double-teardown-of-one-instance class of bug fixed at
+      // the ServiceContainer level (disposeAll() vs clear()/replace()).
+      if (this._disposalPromise) {
+        return this._disposalPromise;
+      }
     }
 
     this.lifecycle = ServiceLifecycle.DISPOSING;
@@ -330,7 +341,10 @@ export class KnowledgeStoreService implements IKnowledgeStoreService {
     const writerQueue = this._writerQueue;
     const initLock = this._initLock;
 
-    this._disposalPromise = (async () => {
+    // Named locally (mirrors initialize()'s initPromise) so the finally below
+    // can identity-check before clearing — see there for why.
+    let disposePromise: Promise<void> | null = null;
+    disposePromise = (async () => {
       try {
         if (writerQueue) {
           await writerQueue.dispose?.();
@@ -370,9 +384,20 @@ export class KnowledgeStoreService implements IKnowledgeStoreService {
         logger.error('[KnowledgeStoreService] Error during disposal:', err);
       } finally {
         this.lifecycle = ServiceLifecycle.DISPOSED;
-        this._disposalPromise = null;
+        // Identity-guarded, mirroring initialize()'s own marker clear (see its
+        // finally): only the disposal that still owns _disposalPromise may
+        // null it. The re-check above closes the common race, but this is the
+        // same defense-in-depth initialize() uses — without it, a stale
+        // closure's completion could null a NEWER disposal's still-in-flight
+        // marker, making a concurrent initialize() believe nothing is
+        // disposing and rebuild components while that newer disposal is still
+        // tearing them down.
+        if (this._disposalPromise === disposePromise) {
+          this._disposalPromise = null;
+        }
       }
     })();
+    this._disposalPromise = disposePromise;
 
     return this._disposalPromise;
   }

package/src/knowledge/chunker.ts

@@ -209,12 +209,25 @@ export class Chunker {
       // pair's high half is guaranteed already present in the chunk just
       // pushed, so skipping the low half here loses nothing, it just narrows
       // this chunk's overlap by one code unit instead of widening it.
+      //
+      // The push-forward bound is `<= end`, not `< end`: landing exactly on
+      // `end` (start === end, zero overlap for this transition) is a
+      // perfectly safe position — `end` is always a valid index up to
+      // text.length, and the NEXT chunk's own bounds are recomputed fresh
+      // from `start` at the top of the loop, independent of this `end`. A
+      // strict `<` excluded that boundary case, so at tight targetSize/
+      // overlap ratios (e.g. targetSize:2, overlap:1, straddling a surrogate
+      // pair) BOTH escapes could be simultaneously blocked — the pull-back
+      // correctly refused (it would violate forward-progress) and the
+      // push-forward wrongly refused too (start+1 landed exactly on `end`) —
+      // leaving `start` unmoved on the lone low surrogate, corrupting the
+      // next chunk's opening character.
       if (start > 0) {
         const code = text.charCodeAt(start);
         if (code >= 0xdc00 && code <= 0xdfff) {
           if (start - 1 > iterationStart) {
             start -= 1;
-          } else if (start + 1 < end) {
+          } else if (start + 1 <= end) {
             start += 1;
           }
         }

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/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)) {

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/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 };
-}