@in-the-loop-labs/pair-review 3.7.2 → 3.9.0

package/src/routes/mcp.js

@@ -4,7 +4,7 @@ const { McpServer } = require('@modelcontextprotocol/sdk/server/mcp.js');
 const { StreamableHTTPServerTransport } = require('@modelcontextprotocol/sdk/server/streamableHttp.js');
 const { z } = require('zod');
 const { v4: uuidv4 } = require('uuid');
-const { ReviewRepository, CommentRepository, AnalysisRunRepository, RepoSettingsRepository, PRMetadataRepository, query } = require('../database');
+const { ReviewRepository, CommentRepository, AnalysisRunRepository, RepoSettingsRepository, PRMetadataRepository } = require('../database');
 const { renderPromptForSkill } = require('../ai/prompts/render-for-skill');
 const Analyzer = require('../ai/analyzer');
 const { getTierForModel } = require('../ai/provider');
@@ -393,33 +393,15 @@ function createMCPServer(db, options = {}) {
         };
       }
 
-      // Build parameterized WHERE conditions
-      const params = [runId];
-      const conditions = ["ai_run_id = ?", "source = 'ai'", 'ai_level IS NULL', '(is_raw = 0 OR is_raw IS NULL)'];
-
-      if (args.status) {
-        conditions.push('status = ?');
-        params.push(args.status);
-      } else {
-        // Exclude dismissed by default — dismissed suggestions were explicitly
-        // rejected by the reviewer and would be noise for an iterating agent.
-        conditions.push("status IN ('active', 'adopted')");
-      }
-
-      if (args.file) {
-        conditions.push('file = ?');
-        params.push(args.file);
-      }
-
-      const filtered = await query(db, `
-        SELECT
-          id, ai_run_id, ai_level, ai_confidence,
-          file, line_start, line_end, type, title, body,
-          reasoning, status, is_file_level, severity, created_at
-        FROM comments
-        WHERE ${conditions.join('\n          AND ')}
-        ORDER BY file, line_start
-      `, params);
+      // Resolve the run's consolidated final suggestions via the shared
+      // CommentRepository query. When the caller passes an explicit `status`,
+      // filter by just that one; otherwise default to active + adopted
+      // (excluding dismissed — those were explicitly rejected by the reviewer
+      // and would be noise for an iterating agent).
+      const filtered = await new CommentRepository(db).getFinalSuggestionsByRunId(runId, {
+        statuses: args.status ? [args.status] : ['active', 'adopted'],
+        file: args.file || null,
+      });
 
       return {
         content: [{
@@ -453,7 +435,10 @@ function createMCPServer(db, options = {}) {
     'Start an AI analysis within pair-review for local or PR changes. ' +
     'Returns immediately with tracking IDs so the caller can poll for completion. ' +
     'For local mode, provide (path + headSha). For PR mode, provide (repo + prNumber). ' +
-    'Use get_ai_analysis_runs with limit=1 to poll for completion, then get_ai_suggestions to fetch results.',
+    'Use get_ai_analysis_runs with limit=1 to poll for completion, then get_ai_suggestions to fetch results. ' +
+    'Note: this tool runs a single provider/model only — it does NOT dispatch a repo\'s ' +
+    'configured default council (repo_settings.default_council_id), unlike the CLI ' +
+    '(--headless) and the web "Analyze" action. To run a council, use the web UI or the CLI.',
     {
       ...reviewLookupSchema,
       customInstructions: z.string().max(5000).optional()
@@ -586,7 +571,16 @@ function createMCPServer(db, options = {}) {
             logger.warn(`Could not generate or persist diff for local review ${reviewId}: ${diffError.message}`);
           }
 
-          // Resolve provider and model
+          // Resolve provider and model.
+          //
+          // INTENTIONAL DIVERGENCE (documented in the tool description): MCP
+          // resolves a single provider/model here and does NOT consult
+          // resolveReviewConfig()/repo_settings.default_council_id, so a repo's
+          // default council is ignored on this path (the CLI --headless and the
+          // web "Analyze" action DO honor it). This ladder is also env-first
+          // (PAIR_REVIEW_* over repo defaults), matching review-config.js's
+          // _buildSingleSelection. Routing this through resolveReviewConfig (and
+          // adding council dispatch) is a deliberate follow-up, not an oversight.
           const repoSettings = repository ? await repoSettingsRepo.getRepoSettings(repository) : null;
           const provider = process.env.PAIR_REVIEW_PROVIDER || repoSettings?.default_provider || config.default_provider || config.provider || 'claude';
           const model = process.env.PAIR_REVIEW_MODEL || repoSettings?.default_model || config.default_model || config.model || 'opus';
@@ -741,7 +735,10 @@ function createMCPServer(db, options = {}) {
           // Get or create review record
           const { review } = await reviewRepo.getOrCreate({ prNumber, repository });
 
-          // Resolve provider and model
+          // Resolve provider and model. INTENTIONAL DIVERGENCE: single
+          // provider/model only — no resolveReviewConfig / default-council
+          // dispatch (see the local branch above and the tool description). The
+          // env-first ladder matches review-config.js's _buildSingleSelection.
           const repoSettings = await repoSettingsRepo.getRepoSettings(repository);
           const provider = process.env.PAIR_REVIEW_PROVIDER || repoSettings?.default_provider || config.default_provider || config.provider || 'claude';
           const model = process.env.PAIR_REVIEW_MODEL || repoSettings?.default_model || config.default_model || config.model || 'opus';

package/src/routes/pr.js

@@ -55,6 +55,7 @@ const { parseHunks } = require('../utils/diff-hunks');
 const { hashHunk } = require('../ai/hunk-hashing');
 const { resolveOriginalFileContentSpecs } = require('../utils/diff-file-content');
 const { validateCouncilConfig, normalizeCouncilConfig } = require('./councils');
+const { resolveReviewConfig } = require('../review-config');
 const { TIERS, TIER_ALIASES, VALID_TIERS, resolveTier } = require('../ai/prompts/config');
 const { getProviderClass, createProvider } = require('../ai/provider');
 const { CommentRepository } = require('../database');
@@ -2038,6 +2039,84 @@ async function handleExecutablePRAnalysis(req, res, {
   });
 }
 
+/**
+ * Launch a PR-mode council analysis.
+ *
+ * Shared by the explicit council endpoint (`POST .../analyses/council`) and the
+ * plain-analyze default path (`POST .../analyses`) when a repo's
+ * `default_council_id` resolves to a council and the request made no explicit
+ * single-model pick. Both entry points build the same modeContext and call
+ * `analysesRouter.launchCouncilAnalysis`, so council dispatch is not duplicated.
+ *
+ * Caller is responsible for resolving + validating `councilConfig`/`configType`
+ * and persisting any request instructions before calling this.
+ *
+ * @returns {{ analysisId: string, runId: string }}
+ */
+async function launchPrCouncilAnalysis(req, {
+  repository, owner, repo, prNumber, prMetadata, worktreePath,
+  review, reviewRepo, repoSettings, councilConfig, councilId, configType,
+  repoInstructions, requestInstructions, excludePrevious
+}) {
+  const db = req.app.get('db');
+  const prCouncilConfig = req.app.get('config') || {};
+
+  const { providerOverrides: councilProviderOverrides, providerOverridesMap: councilProviderOverridesMap } =
+    buildCouncilProviderOverrides(prCouncilConfig, repository, repoSettings);
+
+  // Build a GitHubClient for analyzer-side dedup pre-fetch (PR mode only).
+  let councilGithubClient;
+  try {
+    const resolved = resolveBindingForRequest(req, repository);
+    councilGithubClient = resolved ? new GitHubClient(resolved.binding) : undefined;
+  } catch (configErr) {
+    logger.warn(`Skipping GitHub dedup pre-fetch (council): ${configErr.message}`);
+    councilGithubClient = undefined;
+  }
+  if (councilGithubClient) {
+    logger.debug(`analyzer githubClient wired for ${owner}/${repo}#${prNumber} (council)`);
+  }
+
+  return analysesRouter.launchCouncilAnalysis(
+    db,
+    {
+      reviewId: review.id,
+      worktreePath,
+      prMetadata,
+      changedFiles: null,
+      repository,
+      headSha: prMetadata.head_sha,
+      logLabel: `PR #${prNumber}`,
+      initialStatusExtra: { prNumber, reviewType: 'pr' },
+      config: prCouncilConfig,
+      excludePrevious,
+      serverPort: req.socket.localPort,
+      githubClient: councilGithubClient,
+      poolLifecycle: req.app.get('poolLifecycle'),
+      providerOverrides: councilProviderOverrides,
+      providerOverridesMap: councilProviderOverridesMap,
+      hookContext: {
+        mode: 'pr',
+        prContext: {
+          number: prNumber, owner, repo,
+          author: prMetadata.author, baseBranch: prMetadata.base_branch,
+          headBranch: prMetadata.head_branch,
+          baseSha: prMetadata.base_sha || null, headSha: prMetadata.head_sha || null,
+        },
+      },
+      onSuccess: async (result) => {
+        if (result.summary) {
+          await reviewRepo.upsertSummary(prNumber, repository, result.summary);
+        }
+      }
+    },
+    councilConfig,
+    councilId,
+    { globalInstructions: prCouncilConfig.globalInstructions || null, repoInstructions, requestInstructions },
+    configType
+  );
+}
+
 /**
  * Trigger AI analysis for a PR
  */
@@ -2165,6 +2244,40 @@ router.post('/api/pr/:owner/:repo/:number/analyses', async (req, res) => {
 
     const { review } = await reviewRepo.getOrCreate({ prNumber, repository });
 
+    // Repo default-council parity: when the request makes NO explicit single-model
+    // pick (no provider/model in the body), honor the repo's saved
+    // default_council_id by dispatching to the same council path the explicit
+    // council endpoint uses. An explicit provider/model in the request always
+    // wins and falls through to the single-provider path unchanged below.
+    // For repos with no default_council_id the resolver returns type:'single' and
+    // we fall through, so single-provider behavior is byte-identical to before.
+    if (!requestProvider && !requestModel) {
+      const reviewConfig = await resolveReviewConfig(
+        db,
+        repository,
+        { provider: requestProvider, model: requestModel },
+        appConfig
+      );
+      if (reviewConfig.type === 'council') {
+        logger.log('API', `Honoring repo default council for ${repository}: ${reviewConfig.council.name}`, 'cyan');
+        const { analysisId: councilAnalysisId, runId: councilRunId } = await launchPrCouncilAnalysis(req, {
+          repository, owner, repo, prNumber, prMetadata, worktreePath,
+          review, reviewRepo, repoSettings: fetchedRepoSettings,
+          councilConfig: reviewConfig.councilConfig,
+          councilId: reviewConfig.council.id,
+          configType: reviewConfig.configType,
+          repoInstructions, requestInstructions, excludePrevious
+        });
+        return res.json({
+          analysisId: councilAnalysisId,
+          runId: councilRunId,
+          status: 'started',
+          message: 'Council analysis started in background',
+          isCouncil: true
+        });
+      }
+    }
+
     // Resolve load_skills across all config tiers
     const providerLoadSkills = appConfig.providers?.[provider]?.load_skills;
     const loadSkills = resolveLoadSkills(appConfig, repository, fetchedRepoSettings, providerLoadSkills);
@@ -2518,62 +2631,11 @@ router.post('/api/pr/:owner/:repo/:number/analyses/council', async (req, res) =>
       await reviewRepo.upsertCustomInstructions(prNumber, repository, requestInstructions);
     }
 
-    const prCouncilConfig = req.app.get('config') || {};
-
-    const { providerOverrides: councilProviderOverrides, providerOverridesMap: councilProviderOverridesMap } =
-      buildCouncilProviderOverrides(prCouncilConfig, repository, repoSettings);
-
-    // Build a GitHubClient for analyzer-side dedup pre-fetch (PR mode only).
-    let councilGithubClient;
-    try {
-      const resolved = resolveBindingForRequest(req, repository);
-      councilGithubClient = resolved ? new GitHubClient(resolved.binding) : undefined;
-    } catch (configErr) {
-      logger.warn(`Skipping GitHub dedup pre-fetch (council): ${configErr.message}`);
-      councilGithubClient = undefined;
-    }
-    if (councilGithubClient) {
-      logger.debug(`analyzer githubClient wired for ${owner}/${repo}#${prNumber} (council)`);
-    }
-
-    const { analysisId, runId } = await analysesRouter.launchCouncilAnalysis(
-      db,
-      {
-        reviewId: review.id,
-        worktreePath,
-        prMetadata,
-        changedFiles: null,
-        repository,
-        headSha: prMetadata.head_sha,
-        logLabel: `PR #${prNumber}`,
-        initialStatusExtra: { prNumber, reviewType: 'pr' },
-        config: prCouncilConfig,
-        excludePrevious,
-        serverPort: req.socket.localPort,
-        githubClient: councilGithubClient,
-        poolLifecycle: req.app.get('poolLifecycle'),
-        providerOverrides: councilProviderOverrides,
-        providerOverridesMap: councilProviderOverridesMap,
-        hookContext: {
-          mode: 'pr',
-          prContext: {
-            number: prNumber, owner, repo,
-            author: prMetadata.author, baseBranch: prMetadata.base_branch,
-            headBranch: prMetadata.head_branch,
-            baseSha: prMetadata.base_sha || null, headSha: prMetadata.head_sha || null,
-          },
-        },
-        onSuccess: async (result) => {
-          if (result.summary) {
-            await reviewRepo.upsertSummary(prNumber, repository, result.summary);
-          }
-        }
-      },
-      councilConfig,
-      councilId,
-      { globalInstructions: prCouncilConfig.globalInstructions || null, repoInstructions, requestInstructions },
-      configType
-    );
+    const { analysisId, runId } = await launchPrCouncilAnalysis(req, {
+      repository, owner, repo, prNumber, prMetadata, worktreePath,
+      review, reviewRepo, repoSettings, councilConfig, councilId, configType,
+      repoInstructions, requestInstructions, excludePrevious
+    });
 
     res.json({
       analysisId,

package/src/single-port.js

@@ -5,6 +5,8 @@ const semver = require('semver');
 const { PRArgumentParser } = require('./github/parser');
 const logger = require('./utils/logger');
 const { rejectUrlLikeLocalReviewPath } = require('./utils/local-path-input');
+const { normalizeRepository } = require('./utils/paths');
+const { buildInteractiveAnalysisConfig } = require('./interactive-analysis-config');
 const { version: packageVersion } = require('../package.json');
 
 const HEALTH_TIMEOUT_MS = 2000;
@@ -17,7 +19,9 @@ const defaults = {
   open: (...args) => process.env.PAIR_REVIEW_NO_OPEN
     ? Promise.resolve()
     : import('open').then(({ default: open }) => open(...args)),
-  PRArgumentParser
+  PRArgumentParser,
+  // Injected so the delegation handoff can be stubbed in tests without a DB.
+  buildInteractiveAnalysisConfig
 };
 
 /**
@@ -85,6 +89,71 @@ function notifyVersion(port, currentVersion, _deps) {
   req.end();
 }
 
+/**
+ * Hand a resolved analysis config off to a DIFFERENT (already-running) pair-review
+ * process by POSTing it to its `/api/bulk-analysis-configs` endpoint, returning the
+ * short id the server assigns. This is the cross-process counterpart to the
+ * in-process `createBulkAnalysisConfig` store: the CLI invocation and the running
+ * server do not share memory, so a `--instructions` payload can only reach the
+ * server's store over HTTP.
+ *
+ * Rejects (does NOT swallow) on transport error, timeout, non-2xx status, or an
+ * unparseable/idless body — the caller converts that into a loud failure rather
+ * than silently dropping the instructions.
+ *
+ * @param {number} port
+ * @param {Object} analysisConfig - Resolved config (single or council snapshot)
+ * @param {object} [_deps] - Dependency overrides for testing
+ * @returns {Promise<string>} The stored analysis-config id
+ */
+function storeAnalysisConfigRemote(port, analysisConfig, _deps) {
+  const deps = { ...defaults, ..._deps };
+  const payload = JSON.stringify({ analysisConfig });
+  return new Promise((resolve, reject) => {
+    const req = deps.httpRequest({
+      hostname: 'localhost',
+      port,
+      path: '/api/bulk-analysis-configs',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(payload)
+      },
+      timeout: HEALTH_TIMEOUT_MS
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        let body = null;
+        try {
+          body = data ? JSON.parse(data) : null;
+        } catch {
+          return reject(new Error(
+            `Invalid response from pair-review server on port ${port} while storing analysis config.`
+          ));
+        }
+        const status = res.statusCode || 0;
+        if (status >= 200 && status < 300 && body && body.id) {
+          resolve(body.id);
+        } else {
+          const detail = (body && body.error) || `unexpected status ${status}`;
+          reject(new Error(`Failed to store analysis config on the running server: ${detail}`));
+        }
+      });
+    });
+
+    req.on('error', (err) => {
+      reject(new Error(`Failed to reach pair-review server on port ${port}: ${err.message}`));
+    });
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error(`Timed out storing analysis config on pair-review server (port ${port}).`));
+    });
+    req.write(payload);
+    req.end();
+  });
+}
+
 /**
  * Build the URL to delegate to an existing server.
  * @param {number} port
@@ -95,18 +164,36 @@ function notifyVersion(port, currentVersion, _deps) {
  * @param {number} [context.number]
  * @param {string} [context.localPath]
  * @param {boolean} [context.analyze] - Whether to trigger auto-analysis
+ * @param {string} [context.councilId] - Resolved council id for council auto-analysis
+ * @param {string} [context.analysisConfigId] - Stored analysis-config id (encodes
+ *   the resolved provider/model or council snapshot PLUS custom instructions). When
+ *   present it supersedes `councilId` — the id already carries the council selection,
+ *   mirroring the cold-start precedence in handlePullRequest/handleLocalReview.
  * @returns {string} Full URL
  */
 function buildDelegationUrl(port, mode, context = {}) {
   const base = `http://localhost:${port}`;
   if (mode === 'pr') {
     let url = `${base}/pr/${context.owner}/${context.repo}/${context.number}`;
-    if (context.analyze) url += '?analyze=true';
+    const query = [];
+    if (context.analyze) query.push('analyze=true');
+    if (context.analysisConfigId) {
+      query.push(`analysisConfigId=${encodeURIComponent(context.analysisConfigId)}`);
+    } else if (context.councilId) {
+      query.push(`council=${encodeURIComponent(context.councilId)}`);
+    }
+    if (query.length) url += `?${query.join('&')}`;
     return url;
   }
   if (mode === 'local') {
+    // The `?path=` segment is always present, so analyze/config append with `&`.
     let url = `${base}/local?path=${encodeURIComponent(context.localPath)}`;
     if (context.analyze) url += '&analyze=true';
+    if (context.analysisConfigId) {
+      url += `&analysisConfigId=${encodeURIComponent(context.analysisConfigId)}`;
+    } else if (context.councilId) {
+      url += `&council=${encodeURIComponent(context.councilId)}`;
+    }
     return url;
   }
   return `${base}/`;
@@ -137,11 +224,29 @@ async function parsePRArgsForDelegation(prArgs, config = null, _deps) {
  * @param {object} flags - Parsed CLI flags
  * @param {string[]} prArgs - PR arguments from CLI
  * @param {object} [_deps] - Dependency overrides for testing
+ * @param {object} [options] - Pre-resolved values from the caller
+ * @param {string|null} [options.councilId] - Resolved council id (the caller
+ *   resolves `flags.council` against the DB before delegation, since this
+ *   module has no DB access). When set, the delegated URL carries
+ *   `&council=<id>` and auto-analysis is forced on.
+ * @param {object|null} [options.db] - Open DB handle. Required to carry
+ *   `--instructions` across delegation: the analysis config (provider/model or
+ *   council snapshot + instructions) is resolved here and POSTed to the running
+ *   server, whose returned id is threaded as `analysisConfigId`. Without it, the
+ *   handoff is skipped and only `councilId`/`analyze` flow through (prior shape).
+ * @param {string|null} [options.localRepository] - owner/repo for local-mode
+ *   repo-default resolution (the caller resolves it via getRepositoryName, the
+ *   same value the cold-start session uses; PR mode derives it from prArgs here).
  * @returns {Promise<boolean>} true if delegated, false if should start fresh
  */
-async function attemptDelegation(config, flags, prArgs, _deps) {
+async function attemptDelegation(config, flags, prArgs, _deps, options = {}) {
   const deps = { ...defaults, ..._deps };
   const port = config.port;
+  const councilId = options.councilId || null;
+  // A council selection implies analysis: the browser-side council
+  // auto-analysis is gated on the `council` param + `analyze=true`, mirroring
+  // the cold-start URL built in handlePullRequest/handleLocalReview.
+  const analyze = !!(flags.ai || flags.council);
 
   const result = await detectRunningServer(port, _deps);
 
@@ -159,15 +264,35 @@ async function attemptDelegation(config, flags, prArgs, _deps) {
   // Server is running — delegate to it
   deps.logger.info(`Existing pair-review server detected on port ${port} (v${result.version})`);
 
+  // Resolve + hand off the analysis config (provider/model or council snapshot +
+  // custom instructions) to the RUNNING server so a delegated `--ai`/`--council`
+  // run with `--instructions` honors them instead of silently dropping them. The
+  // build is gated on an analyzing mode + an open DB; it returns null when no
+  // instructions were supplied, in which case we fall back to the bare
+  // councilId/analyze params (unchanged prior behavior). A failed POST throws —
+  // the contract is loud-fail, never silent drop.
+  const handoffAnalysisConfigId = async (repository) => {
+    if (!analyze || !options.db) return null;
+    const analysisConfig = await deps.buildInteractiveAnalysisConfig({
+      db: options.db, config, flags, repository
+    });
+    if (!analysisConfig) return null;
+    deps.logger.info('Handing off analysis configuration (with instructions) to the running server');
+    return storeAnalysisConfigRemote(port, analysisConfig, _deps);
+  };
+
   // Determine mode and build URL
   let url;
   if (flags.local) {
     rejectUrlLikeLocalReviewPath(flags.localPath);
     const targetPath = path.resolve(flags.localPath || process.cwd());
-    url = buildDelegationUrl(port, 'local', { localPath: targetPath, analyze: flags.ai });
+    const analysisConfigId = await handoffAnalysisConfigId(options.localRepository || null);
+    url = buildDelegationUrl(port, 'local', { localPath: targetPath, analyze, councilId, analysisConfigId });
   } else if (prArgs.length > 0) {
     const prInfo = await parsePRArgsForDelegation(prArgs, config, _deps);
-    url = buildDelegationUrl(port, 'pr', { ...prInfo, analyze: flags.ai });
+    const repository = normalizeRepository(prInfo.owner, prInfo.repo);
+    const analysisConfigId = await handoffAnalysisConfigId(repository);
+    url = buildDelegationUrl(port, 'pr', { ...prInfo, analyze, councilId, analysisConfigId });
   } else {
     url = buildDelegationUrl(port, 'server');
   }
@@ -189,6 +314,7 @@ async function attemptDelegation(config, flags, prArgs, _deps) {
 module.exports = {
   detectRunningServer,
   notifyVersion,
+  storeAnalysisConfigRemote,
   buildDelegationUrl,
   parsePRArgsForDelegation,
   attemptDelegation,

package/src/utils/logger.js

@@ -30,6 +30,7 @@ class AILogger {
     this.enabled = true;
     this.debugEnabled = false;
     this.streamDebugEnabled = false;
+    this.quietEnabled = false;
     this._stdout = process.stdout;
   }
 
@@ -74,6 +75,26 @@ class AILogger {
     return this.streamDebugEnabled;
   }
 
+  /**
+   * Enable or disable quiet mode.
+   * Quiet suppresses chatty progress output (info/success/log/section) while
+   * still allowing warn and error through. Used in headless --json mode (the
+   * machine-readable sink for coding agents) so stderr carries only genuine
+   * warnings and errors, not progress narration.
+   * @param {boolean} enabled - Whether quiet mode should be enabled
+   */
+  setQuietEnabled(enabled) {
+    this.quietEnabled = enabled;
+  }
+
+  /**
+   * Check if quiet mode is enabled
+   * @returns {boolean} Whether quiet mode is enabled
+   */
+  isQuietEnabled() {
+    return this.quietEnabled;
+  }
+
   /**
    * Log debug message (only shown when debug is enabled)
    */
@@ -105,7 +126,7 @@ class AILogger {
    * Log AI analysis info
    */
   info(message) {
-    if (!this.enabled) return;
+    if (!this.enabled || this.quietEnabled) return;
     const timestamp = new Date().toISOString().split('T')[1].split('.')[0];
     this._stdout.write(
       `${COLORS.cyan}[${timestamp}]${COLORS.reset} ` +
@@ -118,7 +139,7 @@ class AILogger {
    * Log AI analysis success
    */
   success(message) {
-    if (!this.enabled) return;
+    if (!this.enabled || this.quietEnabled) return;
     const timestamp = new Date().toISOString().split('T')[1].split('.')[0];
     this._stdout.write(
       `${COLORS.cyan}[${timestamp}]${COLORS.reset} ` +
@@ -167,7 +188,7 @@ class AILogger {
    * Log with custom prefix
    */
   log(prefix, message, color = 'blue') {
-    if (!this.enabled) return;
+    if (!this.enabled || this.quietEnabled) return;
     const timestamp = new Date().toISOString().split('T')[1].split('.')[0];
     const prefixColor = COLORS[color] || COLORS.blue;
     this._stdout.write(
@@ -181,7 +202,7 @@ class AILogger {
    * Start a progress section
    */
   section(title) {
-    if (!this.enabled) return;
+    if (!this.enabled || this.quietEnabled) return;
     this._stdout.write(
       `\n${COLORS.bright}${COLORS.cyan}${'─'.repeat(60)}${COLORS.reset}\n` +
       `${COLORS.bright}${COLORS.cyan}▶ ${title}${COLORS.reset}\n` +