@link-assistant/hive-mind 2.10.0 → 2.10.2

package/src/github.lib.mjs

@@ -7,8 +7,8 @@ import { log, maskToken, cleanErrorMessage, isENOSPC, ghCmdRetry } from './lib.m
 import { reportError } from './sentry.lib.mjs';
 import { describeRequestedThinking, githubLimits, timeouts } from './config.lib.mjs';
 import { batchCheckPullRequestsForIssues as batchCheckPRs, batchCheckArchivedRepositories as batchCheckArchived } from './github.batch.lib.mjs';
-import { isSafeToken, isHexInSafeContext, getGitHubTokensFromFiles, getGitHubTokensFromCommand, sanitizeOutput, sanitizeLogContent } from './token-sanitization.lib.mjs';
-export { isSafeToken, isHexInSafeContext, getGitHubTokensFromFiles, getGitHubTokensFromCommand, sanitizeOutput, sanitizeLogContent }; // Re-export for backward compatibility
+import { isSafeToken, isHexInSafeContext, getGitHubTokensFromFiles, getGitHubTokensFromCommand, sanitizeOutput, sanitizeLogContent, sanitizeForPublication, writeSanitizedPublicationFile } from './token-sanitization.lib.mjs';
+export { isSafeToken, isHexInSafeContext, getGitHubTokensFromFiles, getGitHubTokensFromCommand, sanitizeOutput, sanitizeLogContent, sanitizeForPublication, writeSanitizedPublicationFile }; // Re-export for backward compatibility
 import { uploadLogWithGhUploadLog } from './log-upload.lib.mjs';
 import { formatResetTimeWithRelative } from './usage-limit.lib.mjs'; // See: https://github.com/link-assistant/hive-mind/issues/1236
 // Import model info helpers (Issue #1225)
@@ -336,7 +336,6 @@ export async function attachLogToGitHub(options) {
     repo,
     $,
     log,
-    sanitizeLogContent,
     verbose = false,
     errorMessage,
     customTitle = `🤖 ${SOLUTION_DRAFT_LOG_MARKER}`,
@@ -452,7 +451,7 @@ export async function attachLogToGitHub(options) {
     if (verbose) {
       await log('  🔍 Sanitizing log content to mask GitHub tokens...', { verbose: true });
     }
-    let logContent = await sanitizeLogContent(rawLogContent);
+    let logContent = await sanitizeForPublication(rawLogContent);
 
     // Escape code blocks in the log content to prevent them from breaking markdown formatting
     if (verbose) {
@@ -637,17 +636,21 @@ ${logContent}
         // Create temp log file with sanitized content (no compression, just gh-upload-log)
         const tempLogFile = `/tmp/solution-draft-log-${targetType}-${Date.now()}.txt`;
         // Use the original sanitized content for upload since it's a plain text file
-        await fs.writeFile(tempLogFile, await sanitizeLogContent(rawLogContent));
+        await writeSanitizedPublicationFile(tempLogFile, rawLogContent);
 
         // Use gh-upload-log default auto mode and shared repository fallback.
         const uploadDescription = `Solution draft log for https://github.com/${owner}/${repo}/${targetType === 'pr' ? 'pull' : 'issues'}/${targetNumber}`;
-        const uploadResult = await uploadLogWithGhUploadLog({
-          logFile: tempLogFile,
-          isPublic: isPublicRepo,
-          description: uploadDescription,
-          verbose,
-        });
-        await fs.unlink(tempLogFile).catch(() => {});
+        let uploadResult;
+        try {
+          uploadResult = await uploadLogWithGhUploadLog({
+            logFile: tempLogFile,
+            isPublic: isPublicRepo,
+            description: uploadDescription,
+            verbose,
+          });
+        } finally {
+          await fs.unlink(tempLogFile).catch(() => {});
+        }
 
         if (uploadResult.success) {
           // Use rawUrl for direct file access (single chunk) or url for repository (multiple chunks)
@@ -782,12 +785,16 @@ ${sessionNote}
 *${NOW_WORKING_SESSION_IS_ENDED_MARKER}, feel free to review and add any feedback on the solution draft.*`;
           }
           const tempCommentFile = `/tmp/log-upload-comment-${targetType}-${Date.now()}.md`;
-          await fs.writeFile(tempCommentFile, logUploadComment);
+          await writeSanitizedPublicationFile(tempCommentFile, logUploadComment);
           // Issue #1625: post via postTrackedCommentFromFile so the returned
           // comment ID is registered in-memory and excluded from the
           // "did the AI post anything?" check.
-          const posted = await postTrackedCommentFromFile({ $, owner, repo, targetNumber, bodyFile: tempCommentFile });
-          await fs.unlink(tempCommentFile).catch(() => {});
+          let posted;
+          try {
+            posted = await postTrackedCommentFromFile({ $, owner, repo, targetNumber, bodyFile: tempCommentFile });
+          } finally {
+            await fs.unlink(tempCommentFile).catch(() => {});
+          }
           if (posted.ok) {
             const status = getLogUploadTerminalStatus({ errorMessage, errorDuringExecution, isUsageLimit });
             await log(`  ${status.emoji} ${status.label} uploaded to ${targetName} as ${isPublicRepo ? 'public' : 'private'} ${uploadTypeLabel}${chunkInfo}${posted.commentId ? ` (comment id=${posted.commentId})` : ''}`);
@@ -846,12 +853,16 @@ async function attachRegularComment(options, logComment) {
   const logStats = await fs.stat(logFile);
 
   const tempFile = `/tmp/log-comment-${targetType}-${Date.now()}.md`;
-  await fs.writeFile(tempFile, logComment);
+  await writeSanitizedPublicationFile(tempFile, logComment);
 
   // Issue #1625: track the posted comment ID so it's excluded from the
   // AI-authored-comment check in --auto-attach-solution-summary.
-  const posted = await postTrackedCommentFromFile({ $, owner, repo, targetNumber, bodyFile: tempFile });
-  await fs.unlink(tempFile).catch(() => {});
+  let posted;
+  try {
+    posted = await postTrackedCommentFromFile({ $, owner, repo, targetNumber, bodyFile: tempFile });
+  } finally {
+    await fs.unlink(tempFile).catch(() => {});
+  }
 
   if (posted.ok) {
     const status = getLogUploadTerminalStatus({ errorMessage, errorDuringExecution, isUsageLimit });

package/src/hive-screens.mjs

@@ -13,6 +13,9 @@
  */
 
 import { runHiveScreens } from './hive-screens.lib.mjs';
+import { setupStdioLogInterceptor } from './lib.mjs';
+
+setupStdioLogInterceptor();
 
 const exitCode = await runHiveScreens(process.argv.slice(2));
 process.exit(exitCode);

package/src/instrument.mjs

@@ -1,5 +1,17 @@
 // Lazy-load config only when needed to avoid loading use-m at module initialization
 // This prevents network fetches that can hang during --help or --version
+import { sanitizeCredentialText } from './credential-sanitization-core.lib.mjs';
+
+const sanitizeEventValue = (value, seen = new WeakSet()) => {
+  if (typeof value === 'string') return sanitizeCredentialText(value);
+  if (!value || typeof value !== 'object') return value;
+  if (seen.has(value)) return value;
+  seen.add(value);
+  for (const [key, item] of Object.entries(value)) {
+    value[key] = sanitizeEventValue(item, seen);
+  }
+  return value;
+};
 
 // Check if Sentry should be disabled
 const shouldDisableSentry = () => {
@@ -86,6 +98,8 @@ if (!shouldDisableSentry()) {
 
       // Before send hook to filter out sensitive data
       beforeSend(event) {
+        sanitizeEventValue(event);
+
         // Filter out sensitive environment variables
         if (event.contexts && event.contexts.runtime && event.contexts.runtime.env) {
           const sensitiveKeys = ['API_KEY', 'TOKEN', 'SECRET', 'PASSWORD', 'ANTHROPIC'];

package/src/interactive-mode.lib.mjs

@@ -45,12 +45,12 @@ import { formatInteractiveMcpServersList, getInteractiveMcpDiagnostics } from '.
 // Use the session-started marker as the single source of truth for the
 // header string, keeping posting and filtering in lock-step.
 import { INTERACTIVE_SESSION_STARTED_MARKER, trackToolCommentId } from './tool-comments.lib.mjs';
-// Issue #1745: every comment body posted by the AI bridge MUST flow through
-// sanitizeCommentBody() before leaving the process. The leak in
+// Issue #1745/#2111: every comment body posted by the AI bridge MUST flow
+// through the strict publication sanitizer before leaving the process. The leak in
 // xlab2016/space_db_private#20 happened because raw bash-tool stdout
 // (including TELEGRAM_BOT_TOKEN=...) was published verbatim. See
 // docs/case-studies/issue-1745/analysis.md for the full timeline.
-import { containsKnownToken, getAllKnownLocalTokens, sanitizeCommentBody } from './token-sanitization.lib.mjs';
+import { containsKnownToken, getAllKnownLocalTokens, sanitizeForPublication } from './token-sanitization.lib.mjs';
 import { reportInteractiveLeak } from './telegram-leak-notifier.lib.mjs';
 
 /**
@@ -73,15 +73,6 @@ export const createInteractiveHandler = options => {
     log,
     verbose = false,
     execFile: execFileFn,
-    // Issue #1745: dangerous-skip flags. All default to false; passing them
-    // through lets the operator opt out of pattern-based sanitization (for
-    // controlled debugging in private repos) while keeping active-token
-    // masking on by default.
-    skipOutputSanitization = false,
-    skipActiveTokensOutputSanitization = false,
-    // Pre-existing user content carve-out (issue body / non-bot comments /
-    // pre-existing code). When provided, sanitizer leaves these tokens untouched.
-    excludeTokens = [],
     // Issue #1843: when true (default), base64 tool-result images are embedded
     // inline; when false they degrade to a metadata note. See createImageRenderer.
     imageUploadEnabled = true,
@@ -158,39 +149,33 @@ export const createInteractiveHandler = options => {
       hits = [];
     }
 
-    let sanitized;
     try {
-      sanitized = await sanitizeCommentBody(body, {
-        knownTokens,
-        skipOutputSanitization,
-        skipActiveTokensOutputSanitization,
-        excludeTokens,
-      });
-    } catch (err) {
-      await log(`⚠️ Interactive mode: sanitizeCommentBody failed: ${err.message} — falling back to raw body MASKED`);
-      // Fail closed: if sanitization fails entirely, drop the body to a safe
-      // placeholder rather than leaking. Better to lose detail than secrets.
-      sanitized = '[redacted: sanitization failed]';
-    }
+      const sanitized = await sanitizeForPublication(body);
 
-    if (hits.length > 0) {
-      await log(`🚨 Interactive mode: known-local token(s) detected in outbound comment — sanitizer masked them. Sources: ${hits.map(h => h.source).join(', ')}`);
-      try {
-        await reportInteractiveLeak({
-          owner,
-          repo,
-          prNumber,
-          tokenHits: hits,
-          log,
-        });
-      } catch (err) {
-        if (verbose) {
-          await log(`⚠️ Interactive mode: leak notifier failed: ${err.message}`, { verbose: true });
+      if (hits.length > 0) {
+        await log(`🚨 Interactive mode: known-local token(s) detected in outbound comment — sanitizer masked them. Sources: ${hits.map(h => h.source).join(', ')}`);
+        try {
+          await reportInteractiveLeak({
+            owner,
+            repo,
+            prNumber,
+            tokenHits: hits,
+            log,
+          });
+        } catch (err) {
+          if (verbose) {
+            await log(`⚠️ Interactive mode: leak notifier failed: ${err.message}`, { verbose: true });
+          }
         }
       }
-    }
 
-    return sanitized;
+      return sanitized;
+    } catch (error) {
+      // Publication is an external trust boundary. Legacy skip/exclusion
+      // options accepted by createInteractiveHandler must never weaken it.
+      await log('⚠️ Interactive mode: credential sanitization failed; GitHub mutation blocked.');
+      throw error;
+    }
   };
 
   /**

package/src/lib.mjs

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
 import { ensureUseM } from './use-m-bootstrap.lib.mjs';
+import { createCredentialStreamSanitizer, maskToken, sanitizeCredentialText } from './credential-sanitization-core.lib.mjs';
+
+export { maskToken };
 
 // Shared library functions for hive-mind project
 
@@ -36,7 +39,8 @@ if (typeof globalThis.use === 'undefined') {
   await ensureUseM();
 }
 
-const fs = (await use('fs')).promises;
+const fsModule = await use('fs');
+const fs = fsModule.promises;
 
 // Global reference for log file (can be set by importing module)
 export let logFile = null;
@@ -83,15 +87,20 @@ export const log = async (message, options = {}) => {
     return;
   }
 
+  const sanitizedMessage = sanitizeCredentialText(message);
+
   // Write to file if log file is set
   // Issue #1572: Handle multi-line messages by timestamping each line,
   // so continuation lines don't appear without timestamps in the log file
   if (logFile) {
     const timestamp = new Date().toISOString();
     const prefix = `[${timestamp}] [${level.toUpperCase()}]`;
-    const lines = String(message).split('\n');
+    const lines = sanitizedMessage.split('\n');
     const logMessage = lines.map(line => `${prefix} ${line}`).join('\n');
-    await fs.appendFile(logFile, logMessage + '\n').catch(error => {
+    try {
+      await fs.appendFile(logFile, logMessage + '\n', { mode: 0o600 });
+      await fs.chmod(logFile, 0o600);
+    } catch (error) {
       // Silent fail for file append errors to avoid infinite loop
       // but report to Sentry in verbose mode
       if (global.verboseMode) {
@@ -101,7 +110,7 @@ export const log = async (message, options = {}) => {
           logFile,
         });
       }
-    });
+    }
   }
 
   // Write to console based on level
@@ -110,15 +119,15 @@ export const log = async (message, options = {}) => {
   try {
     switch (level) {
       case 'error':
-        console.error(message);
+        console.error(sanitizedMessage);
         break;
       case 'warning':
       case 'warn':
-        console.warn(message);
+        console.warn(sanitizedMessage);
         break;
       case 'info':
       default:
-        console.log(message);
+        console.log(sanitizedMessage);
         break;
     }
   } finally {
@@ -151,18 +160,20 @@ export const setupVerboseLogInterceptor = () => {
     if (logFile && args.length > 0) {
       const firstArg = String(args[0]);
       if (firstArg.includes('[VERBOSE]')) {
-        const message = args.map(a => String(a)).join(' ');
+        const message = sanitizeCredentialText(args.map(a => String(a)).join(' '));
         const logMessage = `[${new Date().toISOString()}] [VERBOSE] ${message}`;
         _writingFromLog = true;
-        fs.appendFile(logFile, logMessage + '\n').catch(() => {
-          // Silent fail to avoid infinite loops
-        });
+        fs.appendFile(logFile, logMessage + '\n', { mode: 0o600 })
+          .then(() => fs.chmod(logFile, 0o600))
+          .catch(() => {
+            // Silent fail to avoid infinite loops
+          });
       }
     }
 
     // Always call original console.log (with guard flag set if [VERBOSE])
     try {
-      originalConsoleLog(...args);
+      originalConsoleLog(...args.map(value => (typeof value === 'string' || Buffer.isBuffer(value) ? sanitizeCredentialText(value) : value)));
     } finally {
       _writingFromLog = false;
     }
@@ -206,9 +217,12 @@ const invokeWriteCallback = (callback, error = null) => {
 const appendInternalDiagnostic = async message => {
   if (!logFile) return;
   const prefix = `[${new Date().toISOString()}] [INTERNAL]`;
-  await fs.appendFile(logFile, `${prefix} ${message}\n`).catch(() => {
-    // Silent fail to avoid recursive logging errors
-  });
+  await fs
+    .appendFile(logFile, `${prefix} ${sanitizeCredentialText(message)}\n`, { mode: 0o600 })
+    .then(() => fs.chmod(logFile, 0o600))
+    .catch(() => {
+      // Silent fail to avoid recursive logging errors
+    });
 };
 
 const formatStreamDiagnostic = stream => {
@@ -278,14 +292,51 @@ export const setupStdioLogInterceptor = () => {
 
   const originalStdoutWrite = process.stdout.write.bind(process.stdout);
   const originalStderrWrite = process.stderr.write.bind(process.stderr);
+  const stdoutSanitizer = createCredentialStreamSanitizer();
+  const stderrSanitizer = createCredentialStreamSanitizer();
   installBrokenPipeGuard(process.stdout, 'stdout');
   installBrokenPipeGuard(process.stderr, 'stderr');
 
+  // Node does not guarantee that the final write contains a newline. Flush
+  // retained records on both graceful and explicit exits so buffering never
+  // drops the sanitized tail of terminal output or its persistent log.
+  const flushPendingRecord = (sanitizer, originalWrite, streamName) => {
+    const sanitizedChunk = sanitizer.flush();
+    if (!sanitizedChunk) return;
+    try {
+      originalWrite(sanitizedChunk);
+    } catch (error) {
+      if (!isBrokenPipeError(error)) throw error;
+    }
+    if (logFile && sanitizedChunk.trim()) {
+      try {
+        const logMessage = `[${new Date().toISOString()}] [${streamName.toUpperCase()}] ${sanitizedChunk}`;
+        fsModule.appendFileSync(logFile, logMessage + (sanitizedChunk.endsWith('\n') ? '' : '\n'), { mode: 0o600 });
+        fsModule.chmodSync(logFile, 0o600);
+      } catch {
+        // Exit-time logging cannot safely report another error.
+      }
+    }
+  };
+  const flushPendingOutput = () => {
+    flushPendingRecord(stdoutSanitizer, originalStdoutWrite, 'stdout');
+    flushPendingRecord(stderrSanitizer, originalStderrWrite, 'stderr');
+  };
+  process.once('beforeExit', flushPendingOutput);
+  process.once('exit', flushPendingOutput);
+
   process.stdout.write = (chunk, encoding, callback) => {
-    // Always write to terminal first, unless the output pipe is already broken.
+    const normalizedCallback = normalizeWriteCallback(encoding, callback);
+    const sanitizedChunk = stdoutSanitizer.write(chunk);
+    if (!sanitizedChunk) {
+      invokeWriteCallback(normalizedCallback);
+      return true;
+    }
+
+    // Write only the completed, sanitized record to the terminal.
     const result = safeTerminalWrite({
       originalWrite: originalStdoutWrite,
-      chunk,
+      chunk: sanitizedChunk,
       encoding,
       callback,
       streamName: 'stdout',
@@ -293,12 +344,14 @@ export const setupStdioLogInterceptor = () => {
 
     // Also append to log file if set, but skip if this write originated from log()
     if (logFile && !_writingFromLog) {
-      const text = typeof chunk === 'string' ? chunk : chunk.toString(encoding || 'utf8');
+      const text = sanitizedChunk;
       if (text.trim()) {
         const logMessage = `[${new Date().toISOString()}] [STDOUT] ${text.replace(/\n$/, '')}`;
-        fs.appendFile(logFile, logMessage + '\n').catch(() => {
-          // Silent fail to avoid infinite loops
-        });
+        fs.appendFile(logFile, logMessage + '\n', { mode: 0o600 })
+          .then(() => fs.chmod(logFile, 0o600))
+          .catch(() => {
+            // Silent fail to avoid infinite loops
+          });
       }
     }
 
@@ -306,10 +359,17 @@ export const setupStdioLogInterceptor = () => {
   };
 
   process.stderr.write = (chunk, encoding, callback) => {
-    // Always write to terminal first, unless the output pipe is already broken.
+    const normalizedCallback = normalizeWriteCallback(encoding, callback);
+    const sanitizedChunk = stderrSanitizer.write(chunk);
+    if (!sanitizedChunk) {
+      invokeWriteCallback(normalizedCallback);
+      return true;
+    }
+
+    // Write only the completed, sanitized record to the terminal.
     const result = safeTerminalWrite({
       originalWrite: originalStderrWrite,
-      chunk,
+      chunk: sanitizedChunk,
       encoding,
       callback,
       streamName: 'stderr',
@@ -317,12 +377,14 @@ export const setupStdioLogInterceptor = () => {
 
     // Also append to log file if set, but skip if this write originated from log()
     if (logFile && !_writingFromLog) {
-      const text = typeof chunk === 'string' ? chunk : chunk.toString(encoding || 'utf8');
+      const text = sanitizedChunk;
       if (text.trim()) {
         const logMessage = `[${new Date().toISOString()}] [STDERR] ${text.replace(/\n$/, '')}`;
-        fs.appendFile(logFile, logMessage + '\n').catch(() => {
-          // Silent fail to avoid infinite loops
-        });
+        fs.appendFile(logFile, logMessage + '\n', { mode: 0o600 })
+          .then(() => fs.chmod(logFile, 0o600))
+          .catch(() => {
+            // Silent fail to avoid infinite loops
+          });
       }
     }
 
@@ -330,29 +392,6 @@ export const setupStdioLogInterceptor = () => {
   };
 };
 
-/**
- * Mask sensitive tokens in text
- * @param {string} token - Token to mask
- * @param {Object} options - Masking options
- * @param {number} [options.minLength=12] - Minimum length to mask
- * @param {number} [options.startChars=3] - Number of characters to show at start
- * @param {number} [options.endChars=3] - Number of characters to show at end
- * @returns {string} Masked token
- */
-export const maskToken = (token, options = {}) => {
-  const { minLength = 12, startChars = 3, endChars = 3 } = options;
-
-  if (!token || token.length < minLength) {
-    return token; // Don't mask very short strings
-  }
-
-  const start = token.substring(0, startChars);
-  const end = token.substring(token.length - endChars);
-  const middle = '*'.repeat(Math.max(token.length - (startChars + endChars), 3));
-
-  return start + middle + end;
-};
-
 /**
  * Format timestamps for use in filenames
  * @param {Date} [date=new Date()] - Date to format

package/src/log-upload.lib.mjs

@@ -1,5 +1,9 @@
 #!/usr/bin/env node
 import { ensureUseM } from './use-m-bootstrap.lib.mjs';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { sanitizeForPublication } from './token-sanitization.lib.mjs';
 
 // Log upload module for hive-mind
 // Uses gh-upload-log for uploading log files to GitHub
@@ -142,14 +146,24 @@ export const parseGhUploadLogOutput = outputValue => {
  * @param {boolean} [options.verbose=false] - Enable verbose logging
  * @returns {Promise<{success: boolean, url: string|null, rawUrl: string|null, type: 'gist'|'repository'|null, chunks: number, repositoryName?: string|null, repositoryPath?: string|null}>}
  */
-export const uploadLogWithGhUploadLog = async ({ logFile, isPublic, description, verbose = false }) => {
+export const uploadLogWithGhUploadLog = async ({ logFile, isPublic, description, verbose = false, runUpload = runGhUploadLogCommand }) => {
   const result = { success: false, url: null, rawUrl: null, type: null, chunks: 1 };
+  let privateTempDirectory = null;
 
   try {
+    const exactSourceBytes = await fs.readFile(logFile, 'utf8');
+    const sanitizedLog = await sanitizeForPublication(exactSourceBytes);
+    const sanitizedDescription = description ? await sanitizeForPublication(description) : description;
+    privateTempDirectory = await fs.mkdtemp(path.join(os.tmpdir(), 'hive-mind-log-upload-'));
+    await fs.chmod(privateTempDirectory, 0o700);
+    const privateLogFile = path.join(privateTempDirectory, 'sanitized.log');
+    await fs.writeFile(privateLogFile, sanitizedLog, { encoding: 'utf8', mode: 0o600 });
+    await fs.chmod(privateLogFile, 0o600);
+
     const commandArgs = buildGhUploadLogArgs({
-      logFile,
+      logFile: privateLogFile,
       isPublic,
-      description,
+      description: sanitizedDescription,
       verbose,
     });
 
@@ -157,7 +171,7 @@ export const uploadLogWithGhUploadLog = async ({ logFile, isPublic, description,
       await log(`  📤 Running: ${formatGhUploadLogCommand(commandArgs)}`, { verbose: true });
     }
 
-    const uploadResult = await runGhUploadLogCommand(commandArgs);
+    const uploadResult = await runUpload(commandArgs);
     const output = (uploadResult.stdout?.toString() || '') + (uploadResult.stderr?.toString() || '');
 
     if (uploadResult.code !== 0) {
@@ -291,6 +305,10 @@ export const uploadLogWithGhUploadLog = async ({ logFile, isPublic, description,
     });
     await log(`  ❌ Error running gh-upload-log: ${error.message}`);
     return result;
+  } finally {
+    if (privateTempDirectory) {
+      await fs.rm(privateTempDirectory, { recursive: true, force: true }).catch(() => {});
+    }
   }
 };
 

package/src/post-finish-sanitization-sweep.lib.mjs

@@ -21,7 +21,7 @@
  * @module post-finish-sanitization-sweep
  */
 
-import { sanitizeOutput, getSanitizationStats } from './token-sanitization.lib.mjs';
+import { sanitizeForPublication, getSanitizationStats } from './token-sanitization.lib.mjs';
 import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): caller passes $ already wrapped through wrapDollarWithGhRetry
 
 /**
@@ -57,7 +57,7 @@ const detectBotLogin = async $ => {
  * @param {Object}   [args.sanitizationOptions] forwarded to sanitizeOutput
  * @returns {Promise<{scanned:number, edited:number, errors:number}>}
  */
-export const sweepPrConversationComments = async ({ $, owner, repo, prNumber, botLogin, log = async () => {}, sanitizationOptions = {} }) => {
+export const sweepPrConversationComments = async ({ $, owner, repo, prNumber, botLogin, log = async () => {}, sanitizationOptions: _sanitizationOptions = {} }) => {
   const stats = { scanned: 0, edited: 0, errors: 0 };
   let response;
   try {
@@ -86,7 +86,7 @@ export const sweepPrConversationComments = async ({ $, owner, repo, prNumber, bo
     stats.scanned++;
     let sanitized;
     try {
-      sanitized = await sanitizeOutput(c.body, sanitizationOptions);
+      sanitized = await sanitizeForPublication(c.body);
     } catch (err) {
       await log(`⚠️ post-finish sweep: sanitize comment ${c.id} failed: ${err.message || err}`);
       stats.errors++;
@@ -116,7 +116,7 @@ export const sweepPrConversationComments = async ({ $, owner, repo, prNumber, bo
  * @param {Object} args
  * @returns {Promise<{scanned:number, edited:number, errors:number}>}
  */
-export const sweepPrDescription = async ({ $, owner, repo, prNumber, log = async () => {}, sanitizationOptions = {} }) => {
+export const sweepPrDescription = async ({ $, owner, repo, prNumber, log = async () => {}, sanitizationOptions: _sanitizationOptions = {} }) => {
   const stats = { scanned: 0, edited: 0, errors: 0 };
   let response;
   try {
@@ -142,7 +142,7 @@ export const sweepPrDescription = async ({ $, owner, repo, prNumber, log = async
   stats.scanned++;
   let sanitized;
   try {
-    sanitized = await sanitizeOutput(body, sanitizationOptions);
+    sanitized = await sanitizeForPublication(body);
   } catch (err) {
     await log(`⚠️ post-finish sweep: sanitize PR body failed: ${err.message || err}`);
     stats.errors++;

package/src/review.mjs

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
 import { ensureUseM } from './use-m-bootstrap.lib.mjs';
+import { log, setLogFile, getLogFile, formatAligned, extractToolErrorCore, setupStdioLogInterceptor } from './lib.mjs';
+
+setupStdioLogInterceptor();
 
 // Early exit paths - handle these before loading all modules to speed up testing
 const earlyArgs = process.argv.slice(2);
@@ -44,7 +47,6 @@ const path = (await use('path')).default;
 const fs = (await use('fs')).promises;
 
 // Import shared functions from lib.mjs to follow DRY principle
-import { log, setLogFile, getLogFile, formatAligned, extractToolErrorCore } from './lib.mjs';
 import { parseCliArgumentsWithLino } from './cli-arguments.lib.mjs';
 import { reportError } from './sentry.lib.mjs';
 import * as memoryCheck from './memory-check.mjs';