@in-the-loop-labs/pair-review 3.3.4 → 3.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@in-the-loop-labs/pair-review",
-  "version": "3.3.4",
+  "version": "3.3.6",
   "description": "Your AI-powered code review partner - Close the feedback loop with AI coding agents",
   "main": "src/server.js",
   "bin": {

package/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "pair-review",
-  "version": "3.3.4",
+  "version": "3.3.6",
   "description": "pair-review app integration — Open PRs and local changes in the pair-review web UI, run server-side AI analysis, and address review feedback. Requires the pair-review MCP server.",
   "author": {
     "name": "in-the-loop-labs",

package/plugin-code-critic/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "code-critic",
-  "version": "3.3.4",
+  "version": "3.3.6",
   "description": "AI-powered code review analysis — Run three-level AI analysis and implement-review-fix loops directly in your coding agent. Works standalone, no server required.",
   "author": {
     "name": "in-the-loop-labs",

package/public/js/repo-settings.js

@@ -157,7 +157,9 @@ class RepoSettingsPage {
           const newProvider = this.providers[newProviderId];
 
           if (oldProvider && newProvider) {
-            const currentModel = oldProvider.models.find(m => m.id === this.currentSettings.default_model);
+            // Match by id or alias so legacy model IDs still resolve their tier
+            // when the user switches providers.
+            const currentModel = this.findModelWithAliases(oldProvider, this.currentSettings.default_model);
             if (currentModel) {
               const matchingModel = newProvider.models.find(m => m.tier === currentModel.tier);
               const defaultModel = newProvider.models.find(m => m.default);
@@ -619,6 +621,22 @@ class RepoSettingsPage {
     this.selectedProvider = providerId;
   }
 
+  /**
+   * Look up a model by ID within a provider, matching both canonical `id` and
+   * `aliases`. Historical repo settings may still reference legacy model IDs
+   * (e.g. `gpt-5.4` before reasoning-effort variants were introduced); those
+   * must still resolve to the canonical model so the UI shows the correct
+   * selection instead of silently falling back to the provider default.
+   *
+   * @param {Object} provider - Provider object with a `models` array
+   * @param {string} modelId - Model ID to look up (may be an alias)
+   * @returns {Object|undefined} Matching model definition, or undefined if not found
+   */
+  findModelWithAliases(provider, modelId) {
+    if (!provider || !provider.models || !modelId) return undefined;
+    return provider.models.find(m => m.id === modelId || m.aliases?.includes(modelId));
+  }
+
   /**
    * Render model select dropdown for the currently selected provider
    */
@@ -654,9 +672,10 @@ class RepoSettingsPage {
       return;
     }
 
-    // Find the selected model, fall back to default or first
+    // Find the selected model, fall back to default or first. Match aliases
+    // so legacy model IDs still render the canonical card.
     const modelId = this.currentSettings.default_model;
-    const model = provider.models.find(m => m.id === modelId)
+    const model = this.findModelWithAliases(provider, modelId)
       || provider.models.find(m => m.default)
       || provider.models[0];
 
@@ -691,7 +710,9 @@ class RepoSettingsPage {
     if (!provider) {
       return { providerName: providerId || 'Unknown', modelName: modelId || 'Unknown' };
     }
-    const model = provider.models?.find(m => m.id === modelId);
+    // Match aliases so historical council/voice configs that stored a legacy
+    // model ID still show the canonical model's display name.
+    const model = this.findModelWithAliases(provider, modelId);
     return {
       providerName: provider.name,
       modelName: model ? model.name : (modelId || 'Unknown')
@@ -1166,11 +1187,20 @@ class RepoSettingsPage {
     this.selectProvider(providerId);
     this.renderProviderSelect();
 
-    // Validate saved model exists in current provider
+    // Validate saved model exists in current provider. Match aliases so legacy
+    // model IDs (e.g. `gpt-5.4` recorded before reasoning-effort variants) keep
+    // resolving to the canonical model; if matched via alias, canonicalize the
+    // stored ID so the dropdown selects the right option and the next save
+    // writes the canonical ID back.
     const provider = this.providers[this.selectedProvider];
     if (provider) {
-      const modelExists = provider.models.some(m => m.id === this.currentSettings.default_model);
-      if (!modelExists) {
+      const matchedModel = this.findModelWithAliases(provider, this.currentSettings.default_model);
+      if (matchedModel) {
+        if (matchedModel.id !== this.currentSettings.default_model) {
+          this.currentSettings.default_model = matchedModel.id;
+          this.originalSettings.default_model = matchedModel.id;
+        }
+      } else {
         const fallbackModel = provider.models.find(m => m.default) || provider.models[0];
         if (fallbackModel) {
           this.currentSettings.default_model = fallbackModel.id;

package/src/ai/claude-provider.js

@@ -24,17 +24,28 @@ const CLAUDE_MODELS = [
     id: 'opus-4.7-xhigh',
     cli_model: 'claude-opus-4-7',
     env: { CLAUDE_CODE_EFFORT_LEVEL: 'xhigh' },
-    name: 'Opus 4.7 xhigh',
+    name: 'Opus 4.7 XHigh',
     tier: 'thorough',
     tagline: 'Latest Gen',
     description: 'Opus 4.7 (latest) with extra-high effort',
     badge: 'Latest',
     badgeClass: 'badge-power'
   },
+  {
+    id: 'opus-4.7-high',
+    cli_model: 'claude-opus-4-7',
+    env: { CLAUDE_CODE_EFFORT_LEVEL: 'high' },
+    name: 'Opus 4.7 High',
+    tier: 'thorough',
+    tagline: 'Latest Gen',
+    description: 'Opus 4.7 (latest) with high effort',
+    badge: 'Latest',
+    badgeClass: 'badge-power'
+  },
   {
     id: 'opus',
     aliases: ['opus-4.6-high'],
-    cli_model: 'opus-4-6',
+    cli_model: 'claude-opus-4-6',
     env: { CLAUDE_CODE_EFFORT_LEVEL: 'high' },
     name: 'Opus 4.6 High',
     tier: 'thorough',
@@ -65,7 +76,7 @@ const CLAUDE_MODELS = [
   },
   {
     id: 'opus-4.6-low',
-    cli_model: 'opus-4-6',
+    cli_model: 'claude-opus-4-6',
     env: { CLAUDE_CODE_EFFORT_LEVEL: 'low' },
     name: 'Opus 4.6 Low',
     tier: 'balanced',
@@ -76,7 +87,7 @@ const CLAUDE_MODELS = [
   },
   {
     id: 'opus-4.6-medium',
-    cli_model: 'opus-4-6',
+    cli_model: 'claude-opus-4-6',
     env: { CLAUDE_CODE_EFFORT_LEVEL: 'medium' },
     name: 'Opus 4.6 Medium',
     tier: 'balanced',
@@ -87,7 +98,7 @@ const CLAUDE_MODELS = [
   },
   {
     id: 'opus-4.6-1m',
-    cli_model: 'opus-4-6[1m]',
+    cli_model: 'claude-opus-4-6[1m]',
     name: 'Opus 4.6 1M',
     tier: 'balanced',
     tagline: 'Extended Context',

package/src/ai/codex-provider.js

@@ -23,31 +23,65 @@ const BIN_DIR = path.join(__dirname, '..', '..', 'bin');
  * Based on OpenAI Codex Models guide (developers.openai.com/codex/models)
  * - gpt-5.4-nano: Cheapest model ($0.20/$1.25 per MTok), good for surface scans
  * - gpt-5.4-mini: Fast with 400k context ($0.75/$4.50 per MTok)
- * - gpt-5.4: Flagship model combining coding, reasoning, and agentic workflows
  * - gpt-5.3-codex: Industry-leading coding model for complex engineering tasks
+ * - gpt-5.4 / gpt-5.5: Exposed only via -high / -xhigh reasoning variants so the
+ *   selected effort level is always explicit.
+ *
+ * Reasoning-effort variants (-high / -xhigh) use `cli_model` to pass the base
+ * model ID to `codex exec -m` and add `-c model_reasoning_effort="..."` via
+ * extra_args so Codex picks up the effort level through its config override.
  *
  * Deprecated (April 2026): gpt-5.1-codex-mini, gpt-5.1-codex-max, gpt-5.1-codex
  */
 const CODEX_MODELS = [
   {
-    id: 'gpt-5.4-nano',
-    name: 'GPT-5.4 Nano',
-    tier: 'fast',
-    tagline: 'Cheapest',
-    description: 'Ultra-low-cost surface scans for style issues, obvious bugs, and lint-level feedback.',
-    badge: 'Cheapest',
-    badgeClass: 'badge-speed'
-  },
-  {
-    id: 'gpt-5.4-mini',
-    name: 'GPT-5.4 Mini',
-    tier: 'balanced',
-    tagline: 'Best Balance',
-    description: 'Fast reviews with 400k context—good balance of speed and capability for everyday PR review.',
+    id: 'gpt-5.4-high',
+    // Alias keeps results/councils saved under the previous bare `gpt-5.4`
+    // model ID resolving to the now-explicit high-effort variant.
+    aliases: ['gpt-5.4'],
+    cli_model: 'gpt-5.4',
+    extra_args: ['-c', 'model_reasoning_effort="high"'],
+    name: 'GPT-5.4 High',
+    tier: 'thorough',
+    tagline: 'Deep Review',
+    description: 'GPT-5.4 with high reasoning effort for complex multi-file reviews, architectural consistency, and subtle behavioral regressions.',
     badge: 'Recommended',
     badgeClass: 'badge-recommended',
     default: true
   },
+  {
+    id: 'gpt-5.4-xhigh',
+    cli_model: 'gpt-5.4',
+    extra_args: ['-c', 'model_reasoning_effort="xhigh"'],
+    name: 'GPT-5.4 XHigh',
+    tier: 'thorough',
+    tagline: 'Max Depth',
+    description: 'GPT-5.4 with extra-high reasoning effort for difficult reviews that need broad context, careful tradeoff analysis, and deeper issue validation.',
+    badge: 'Extra High',
+    badgeClass: 'badge-power'
+  },
+  {
+    id: 'gpt-5.5-high',
+    cli_model: 'gpt-5.5',
+    extra_args: ['-c', 'model_reasoning_effort="high"'],
+    name: 'GPT-5.5 High',
+    tier: 'thorough',
+    tagline: 'Latest Deep',
+    description: 'Latest-generation GPT model with high reasoning effort for demanding PR reviews, strong code understanding, and careful cross-file analysis.',
+    badge: 'High Effort',
+    badgeClass: 'badge-power'
+  },
+  {
+    id: 'gpt-5.5-xhigh',
+    cli_model: 'gpt-5.5',
+    extra_args: ['-c', 'model_reasoning_effort="xhigh"'],
+    name: 'GPT-5.5 XHigh',
+    tier: 'thorough',
+    tagline: 'Frontier Depth',
+    description: 'GPT-5.5 with extra-high reasoning effort for the hardest reviews: architecture, concurrency, security-sensitive changes, and large codebase context.',
+    badge: 'Max Reasoning',
+    badgeClass: 'badge-power'
+  },
   {
     id: 'gpt-5.3-codex',
     name: 'GPT-5.3 Codex',
@@ -58,13 +92,22 @@ const CODEX_MODELS = [
     badgeClass: 'badge-power'
   },
   {
-    id: 'gpt-5.4',
-    name: 'GPT-5.4',
-    tier: 'thorough',
-    tagline: 'Latest Gen',
-    description: 'Flagship model combining coding, reasoning, and agentic workflows for complex architectural reviews.',
-    badge: 'Most Thorough',
-    badgeClass: 'badge-power'
+    id: 'gpt-5.4-mini',
+    name: 'GPT-5.4 Mini',
+    tier: 'balanced',
+    tagline: 'Best Balance',
+    description: 'Fast reviews with 400k context—good balance of speed and capability for everyday PR review.',
+    badge: 'Fast',
+    badgeClass: 'badge-speed'
+  },
+  {
+    id: 'gpt-5.4-nano',
+    name: 'GPT-5.4 Nano',
+    tier: 'fast',
+    tagline: 'Cheapest',
+    description: 'Ultra-low-cost surface scans for style issues, obvious bugs, and lint-level feedback.',
+    badge: 'Cheapest',
+    badgeClass: 'badge-speed'
   }
 ];
 
@@ -78,7 +121,7 @@ class CodexProvider extends AIProvider {
    * @param {Object} configOverrides.env - Additional environment variables
    * @param {Object[]} configOverrides.models - Custom model definitions
    */
-  constructor(model = 'gpt-5.4-mini', configOverrides = {}) {
+  constructor(model = 'gpt-5.4-high', configOverrides = {}) {
     super(model);
 
     // Command precedence: ENV > config > default
@@ -127,27 +170,70 @@ class CodexProvider extends AIProvider {
     // same two-tier pattern as chat-providers.js: args replaces, extra_args appends.
     const defaultShellEnvArgs = ['-c', 'allow_login_shell=false', '-c', 'shell_environment_policy.include_only=["PATH","HOME","USER","GH_TOKEN","GITHUB_TOKEN"]'];
     const configArgs = configOverrides.args || defaultShellEnvArgs;
-    const baseArgs = ['exec', '-m', model, '--json', ...sandboxArgs, ...configArgs, '-'];
-    const providerArgs = configOverrides.extra_args || [];
-    const modelConfig = configOverrides.models?.find(m => m.id === model);
-    const modelArgs = modelConfig?.extra_args || [];
 
-    // Merge env: provider env + model env
-    this.extraEnv = {
-      ...(configOverrides.env || {}),
-      ...(modelConfig?.env || {})
-    };
+    // Resolve cli_model + extra_args + env from built-in model, provider config,
+    // and per-model config. This is what lets reasoning variants like
+    // gpt-5.4-high pass `-m gpt-5.4` plus `-c model_reasoning_effort="high"`.
+    const { cliModel, extraArgs, env } = this._resolveModelConfig(model);
+
+    // IMPORTANT: `-` (stdin marker) must come LAST, after any extra_args.
+    // Reasoning variants contribute `-c model_reasoning_effort="..."` via
+    // extraArgs; if '-' were placed inside baseArgs those flags would land
+    // after the positional stdin marker and be ignored. `buildArgsForModel`
+    // enforces the same invariant for the extraction path.
+    const baseArgs = ['exec', '-m', cliModel, '--json', ...sandboxArgs, ...configArgs];
+
+    this.extraEnv = env;
 
     if (this.useShell) {
       // In shell mode, build full command string with args
-      this.command = `${codexCmd} ${quoteShellArgs([...baseArgs, ...providerArgs, ...modelArgs]).join(' ')}`;
+      this.command = `${codexCmd} ${quoteShellArgs([...baseArgs, ...extraArgs, '-']).join(' ')}`;
       this.args = [];
     } else {
       this.command = codexCmd;
-      this.args = [...baseArgs, ...providerArgs, ...modelArgs];
+      this.args = [...baseArgs, ...extraArgs, '-'];
     }
   }
 
+  /**
+   * Resolve model configuration by looking up built-in and config override definitions.
+   * Produces the CLI model ID (for `-m`), merged extra_args, and merged env.
+   *
+   * Precedence for cli_model: config model > built-in model > modelId.
+   * `cli_model` lets reasoning-effort variants (e.g. `gpt-5.4-high`) pass the
+   * base model (`gpt-5.4`) to `codex exec -m` while adding reasoning overrides
+   * via extra_args.
+   *
+   * @param {string} modelId
+   * @returns {{ builtIn: Object|undefined, configModel: Object|undefined, cliModel: string, extraArgs: string[], env: Object }}
+   * @private
+   */
+  _resolveModelConfig(modelId) {
+    const configOverrides = this.configOverrides || {};
+
+    const builtIn = CODEX_MODELS.find(m => m.id === modelId || (m.aliases && m.aliases.includes(modelId)));
+    const configModel = configOverrides.models?.find(m => m.id === modelId);
+
+    const cliModel = configModel?.cli_model !== undefined
+      ? configModel.cli_model
+      : (builtIn?.cli_model !== undefined ? builtIn.cli_model : modelId);
+
+    // Three-way merge for extra_args: built-in model → provider config → per-model config
+    const builtInArgs = builtIn?.extra_args || [];
+    const providerArgs = configOverrides.extra_args || [];
+    const configModelArgs = configModel?.extra_args || [];
+    const extraArgs = [...builtInArgs, ...providerArgs, ...configModelArgs];
+
+    // Three-way merge for env: built-in model → provider config → per-model config
+    const env = {
+      ...(builtIn?.env || {}),
+      ...(configOverrides.env || {}),
+      ...(configModel?.env || {})
+    };
+
+    return { builtIn, configModel, cliModel, extraArgs, env };
+  }
+
   /**
    * Execute Codex CLI with a prompt
    * @param {string} prompt - The prompt to send to Codex
@@ -572,17 +658,16 @@ class CodexProvider extends AIProvider {
    * @returns {string[]} Complete args array for the CLI
    */
   buildArgsForModel(model) {
+    // Resolve cli_model + merged extra_args so reasoning-effort variants behave
+    // the same for extraction as they do for the main analysis call.
+    const { cliModel, extraArgs } = this._resolveModelConfig(model);
+
     // Base args for extraction (read-only sandbox, no shell access needed)
     // Note: '-' (stdin marker) must come LAST, after any extra_args
-    const baseArgs = ['exec', '-m', model, '--json', '--sandbox', 'read-only', '--full-auto'];
-    // Provider-level extra_args (from configOverrides)
-    const providerArgs = this.configOverrides?.extra_args || [];
-    // Model-specific extra_args (from the model config for the given model)
-    const modelConfig = this.configOverrides?.models?.find(m => m.id === model);
-    const modelArgs = modelConfig?.extra_args || [];
+    const baseArgs = ['exec', '-m', cliModel, '--json', '--sandbox', 'read-only', '--full-auto'];
 
     // Append stdin marker '-' at the end after all other args
-    return [...baseArgs, ...providerArgs, ...modelArgs, '-'];
+    return [...baseArgs, ...extraArgs, '-'];
   }
 
   /**
@@ -598,20 +683,25 @@ class CodexProvider extends AIProvider {
 
     // Build args consistently using the shared method, applying provider and model extra_args
     const args = this.buildArgsForModel(model);
+    // Surface merged env (built-in + provider + per-model) so the extraction
+    // spawn matches the contract used by other providers.
+    const { env } = this._resolveModelConfig(model);
 
     if (useShell) {
       return {
         command: `${codexCmd} ${quoteShellArgs(args).join(' ')}`,
         args: [],
         useShell: true,
-        promptViaStdin: true
+        promptViaStdin: true,
+        env
       };
     }
     return {
       command: codexCmd,
       args,
       useShell: false,
-      promptViaStdin: true
+      promptViaStdin: true,
+      env
     };
   }
 
@@ -700,7 +790,7 @@ class CodexProvider extends AIProvider {
   }
 
   static getDefaultModel() {
-    return 'gpt-5.4-mini';
+    return 'gpt-5.4-high';
   }
 
   static getInstallInstructions() {

package/src/ai/index.js

@@ -21,7 +21,8 @@ const {
   inferModelDefaults,
   resolveDefaultModel,
   prettifyModelId,
-  createAliasedProviderClass
+  createAliasedProviderClass,
+  getTierForModel
 } = require('./provider');
 
 // Load the availability checking module
@@ -73,6 +74,7 @@ module.exports = {
   inferModelDefaults,
   resolveDefaultModel,
   prettifyModelId,
+  getTierForModel,
 
   // Provider factories
   createExecutableProviderClass,

package/src/ai/pi-provider.js

@@ -25,7 +25,7 @@ const { AIProvider, registerProvider, quoteShellArgs } = require('./provider');
 const logger = require('../utils/logger');
 const { extractJSON } = require('../utils/json-extractor');
 const { CancellationError, isAnalysisCancelled } = require('../routes/shared');
-const { StreamParser, parsePiLine, createPiLineParser } = require('./stream-parser');
+const { createPiLineParser } = require('./stream-parser');
 
 // Directory containing bin scripts (git-diff-lines, etc.)
 const BIN_DIR = path.join(__dirname, '..', '..', 'bin');
@@ -42,6 +42,16 @@ const REVIEW_SKILL_PATH = path.join(__dirname, '..', '..', '.pi', 'skills', 'rev
 // in parallel for diverse multi-perspective code review
 const ROULETTE_SKILL_PATH = path.join(__dirname, '..', '..', '.pi', 'skills', 'review-roulette', 'SKILL.md');
 
+// Keep raw stream capture bounded so large JSONL sessions cannot exhaust V8's
+// maximum string size. Assistant text is still extracted incrementally from all
+// complete JSONL lines and used as the primary parse/fallback input.
+const MAX_PI_CAPTURED_STDOUT_CHARS = 5 * 1024 * 1024;
+const MAX_PI_CAPTURED_STDERR_CHARS = 1 * 1024 * 1024;
+const MAX_PI_LINE_CHARS = 2 * 1024 * 1024;
+const PI_STDERR_HEAD_CHARS = 128 * 1024;
+const PI_STDERR_TAIL_CHARS = MAX_PI_CAPTURED_STDERR_CHARS - PI_STDERR_HEAD_CHARS;
+const PI_TRUNCATED_LINE_MARKER = '...[line truncated]...';
+
 /**
  * Pi model definitions
  *
@@ -122,6 +132,324 @@ function extractAssistantText(content, seenTexts) {
   return text;
 }
 
+/**
+ * Determine whether a parsed JSON object looks like a Pi JSONL event envelope
+ * rather than a final review result payload.
+ *
+ * @param {Object} value - Parsed JSON object
+ * @returns {boolean} True when the object appears to be a Pi event
+ */
+function isPiEventEnvelope(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return false;
+  }
+
+  if (typeof value.type !== 'string') {
+    return false;
+  }
+
+  if (
+    value.message ||
+    Array.isArray(value.messages) ||
+    value.assistantMessageEvent ||
+    value.toolName ||
+    value.toolCallId ||
+    Object.hasOwn(value, 'partialResult') ||
+    Object.hasOwn(value, 'result') ||
+    Object.hasOwn(value, 'version')
+  ) {
+    return true;
+  }
+
+  return /_(start|update|end)$/.test(value.type) || value.type === 'session';
+}
+
+/**
+ * Append a chunk to a captured stream buffer without exceeding the configured
+ * maximum. Returns the updated buffer and whether truncation occurred.
+ *
+ * @param {string} existing - Existing captured output
+ * @param {string} chunk - New output chunk
+ * @param {number} maxChars - Maximum number of chars to retain
+ * @returns {{value: string, truncated: boolean}}
+ */
+function appendWithLimit(existing, chunk, maxChars) {
+  if (!chunk || maxChars <= 0) {
+    return { value: existing, truncated: false };
+  }
+
+  const remaining = maxChars - existing.length;
+  if (remaining <= 0) {
+    return { value: existing, truncated: true };
+  }
+
+  if (chunk.length <= remaining) {
+    return { value: existing + chunk, truncated: false };
+  }
+
+  return {
+    value: existing + chunk.slice(0, remaining),
+    truncated: true
+  };
+}
+
+/**
+ * Append a chunk to a bounded head+tail buffer so error logs preserve both the
+ * start and end of noisy stderr output.
+ *
+ * @param {{head: string, tail: string, headFull: boolean, omittedChars: number}} buffer - Buffer state
+ * @param {string} chunk - New stderr chunk
+ * @param {number} maxHeadChars - Max chars to retain from the start
+ * @param {number} maxTailChars - Max chars to retain from the end
+ */
+function appendHeadTailBuffer(buffer, chunk, maxHeadChars, maxTailChars) {
+  if (!chunk) return;
+
+  if (!buffer.headFull) {
+    const remainingHead = maxHeadChars - buffer.head.length;
+    if (chunk.length <= remainingHead) {
+      buffer.head += chunk;
+      if (buffer.head.length >= maxHeadChars) {
+        buffer.headFull = true;
+      }
+      return;
+    }
+
+    const safeHead = Math.max(remainingHead, 0);
+    buffer.head += chunk.slice(0, safeHead);
+    buffer.headFull = true;
+
+    const overflow = chunk.slice(safeHead);
+    if (overflow.length > maxTailChars) {
+      buffer.omittedChars += overflow.length - maxTailChars;
+      buffer.tail = overflow.slice(-maxTailChars);
+    } else {
+      buffer.tail = overflow;
+    }
+    return;
+  }
+
+  const combinedTail = buffer.tail + chunk;
+  if (combinedTail.length > maxTailChars) {
+    buffer.omittedChars += combinedTail.length - maxTailChars;
+    buffer.tail = combinedTail.slice(-maxTailChars);
+  } else {
+    buffer.tail = combinedTail;
+  }
+}
+
+/**
+ * Render a bounded head+tail buffer as a string for logs and error messages.
+ *
+ * @param {{head: string, tail: string, headFull: boolean, omittedChars: number}} buffer - Buffer state
+ * @returns {string} Formatted stderr capture
+ */
+function formatHeadTailBuffer(buffer) {
+  if (buffer.omittedChars === 0) {
+    return `${buffer.head}${buffer.tail}`;
+  }
+
+  return `${buffer.head}\n...[${buffer.omittedChars} chars omitted]...\n${buffer.tail}`;
+}
+
+/**
+ * Extract final assistant text from a Pi JSONL event.
+ *
+ * @param {Object} event - Parsed Pi event object
+ * @param {Set<string>} seenTexts - Set tracking already-seen text blocks
+ * @returns {string} Extracted text from the event
+ */
+function extractPiEventText(event, seenTexts) {
+  let text = '';
+
+  if (event.type === 'message_end' && event.message?.role === 'assistant') {
+    text += extractAssistantText(event.message.content, seenTexts);
+  }
+
+  if (event.type === 'turn_end' && event.message?.role === 'assistant') {
+    text += extractAssistantText(event.message.content, seenTexts);
+  }
+
+  if (event.type === 'agent_end' && Array.isArray(event.messages)) {
+    for (const msg of event.messages) {
+      if (msg.role === 'assistant') {
+        text += extractAssistantText(msg.content, seenTexts);
+      }
+    }
+  }
+
+  return text;
+}
+
+/**
+ * Accumulate only raw lines that could plausibly help the direct JSON fallback.
+ * Pi JSONL event envelopes are intentionally excluded because they are noisy
+ * transport records, not the final review result.
+ *
+ * @param {string} line - One stdout line
+ * @param {{rawOutput: string, rawOutputTruncated: boolean}} state - Parse state
+ * @param {string} levelPrefix - Prefix used in logs
+ * @param {{status: 'parsed', value: Object} | {status: 'failed'}} [parseResult] - Optional parse result reuse
+ */
+function accumulatePiRawFallbackLine(line, state, levelPrefix, parseResult) {
+  if (!line?.trim()) return;
+
+  let parsed;
+  let parseFailed = false;
+
+  if (parseResult?.status === 'parsed') {
+    parsed = parseResult.value;
+  } else if (parseResult?.status === 'failed') {
+    parseFailed = true;
+  } else {
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      parseFailed = true;
+    }
+  }
+
+  if (!parseFailed && isPiEventEnvelope(parsed)) {
+    return;
+  }
+
+  const capture = appendWithLimit(state.rawOutput, `${line}\n`, MAX_PI_CAPTURED_STDOUT_CHARS);
+  state.rawOutput = capture.value;
+
+  if (capture.truncated && !state.rawOutputTruncated) {
+    state.rawOutputTruncated = true;
+    logger.warn(
+      `${levelPrefix} Pi CLI raw-output fallback exceeded ${MAX_PI_CAPTURED_STDOUT_CHARS} chars; retaining only the first ${MAX_PI_CAPTURED_STDOUT_CHARS} chars`
+    );
+  }
+}
+
+/**
+ * Parse a single Pi JSONL line into accumulated assistant text.
+ *
+ * @param {string} line - One JSONL line
+ * @param {{textContent: string, seenTexts: Set<string>, rawOutput: string, rawOutputTruncated: boolean}} state - Parse state
+ * @param {string} levelPrefix - Prefix used in logs
+ */
+function accumulatePiResponseLine(line, state, levelPrefix) {
+  if (!line?.trim()) return;
+
+  let parseResult;
+  try {
+    const event = JSON.parse(line);
+    state.textContent += extractPiEventText(event, state.seenTexts);
+    parseResult = { status: 'parsed', value: event };
+  } catch {
+    logger.debug(`${levelPrefix} Skipping malformed JSONL line: ${line.substring(0, 100)}`);
+    parseResult = { status: 'failed' };
+  }
+
+  accumulatePiRawFallbackLine(line, state, levelPrefix, parseResult);
+}
+
+/**
+ * Append stdout data to the pending JSONL line buffer while capping any single
+ * unterminated line to avoid retaining multi-megabyte tool payloads in memory.
+ *
+ * @param {{buffer: string, lineTruncated: boolean, warningLogged: boolean}} state - Pending line state
+ * @param {string} chunk - New stdout chunk
+ * @param {string} levelPrefix - Prefix used in logs
+ * @returns {string[]} Complete lines extracted from the chunk
+ */
+function appendPiChunkToLineBuffer(state, chunk, levelPrefix) {
+  if (!chunk) return [];
+
+  const lines = [];
+  let cursor = 0;
+
+  while (cursor < chunk.length) {
+    if (state.lineTruncated) {
+      const nextNewline = chunk.indexOf('\n', cursor);
+      if (nextNewline === -1) {
+        return lines;
+      }
+
+      lines.push(state.buffer);
+      state.buffer = '';
+      state.lineTruncated = false;
+      cursor = nextNewline + 1;
+      continue;
+    }
+
+    const nextNewline = chunk.indexOf('\n', cursor);
+    const segmentEnd = nextNewline === -1 ? chunk.length : nextNewline;
+    const segment = chunk.slice(cursor, segmentEnd);
+    const remainingCapacity = MAX_PI_LINE_CHARS - state.buffer.length;
+
+    if (segment.length <= remainingCapacity) {
+      state.buffer += segment;
+      if (nextNewline !== -1) {
+        lines.push(state.buffer);
+        state.buffer = '';
+      }
+      cursor = segmentEnd + (nextNewline === -1 ? 0 : 1);
+      continue;
+    }
+
+    const safeCapacity = Math.max(remainingCapacity, 0);
+    state.buffer += segment.slice(0, safeCapacity) + PI_TRUNCATED_LINE_MARKER;
+    state.lineTruncated = true;
+
+    if (!state.warningLogged) {
+      state.warningLogged = true;
+      logger.warn(
+        `${levelPrefix} Pi CLI emitted a JSONL event longer than ${MAX_PI_LINE_CHARS} chars; truncating the pending line buffer until the next newline`
+      );
+    }
+
+    if (nextNewline !== -1) {
+      lines.push(state.buffer);
+      state.buffer = '';
+      state.lineTruncated = false;
+      cursor = nextNewline + 1;
+      continue;
+    }
+
+    return lines;
+  }
+
+  return lines;
+}
+
+/**
+ * Finalize Pi response parsing from incrementally extracted assistant text and
+ * a bounded raw-output fallback buffer.
+ *
+ * @param {Object} input - Parse inputs
+ * @param {string} input.textContent - Assistant text extracted from JSONL events
+ * @param {string} input.rawOutput - Bounded raw stdout capture
+ * @param {boolean} [input.rawOutputTruncated=false] - Whether raw stdout was truncated
+ * @param {string|number} level - Analysis level for logging
+ * @param {string} levelPrefix - Prefix used in logs
+ * @returns {{success: boolean, data?: Object, error?: string, textContent?: string}}
+ */
+function finalizePiResponseParsing({ textContent, rawOutput, rawOutputTruncated = false }, level, levelPrefix) {
+  if (textContent) {
+    const extracted = extractJSON(textContent, level);
+    if (extracted.success) {
+      return extracted;
+    }
+
+    logger.warn(`${levelPrefix} Text content is not JSON, treating as raw text`);
+    return { success: false, error: 'Text content is not valid JSON', textContent };
+  }
+
+  if (rawOutputTruncated) {
+    logger.warn(`${levelPrefix} Pi CLI raw-output fallback was truncated before assistant text could be recovered`);
+    return {
+      success: false,
+      error: 'Pi CLI raw-output fallback was truncated before assistant text could be recovered'
+    };
+  }
+
+  return extractJSON(rawOutput, level);
+}
+
 class PiProvider extends AIProvider {
   /**
    * @param {string|null} [model='default'] - Model identifier or null/undefined for default mode
@@ -298,12 +626,27 @@ class PiProvider extends AIProvider {
         logger.info(`${levelPrefix} Registered process ${pid} for analysis ${analysisId}`);
       }
 
-      let stdout = '';
-      let stderr = '';
+      const stderrCapture = {
+        head: '',
+        tail: '',
+        headFull: false,
+        omittedChars: 0
+      };
+      let stderrTruncated = false;
       let timeoutId = null;
       let settled = false;  // Guard against multiple resolve/reject calls
-      let lineBuffer = '';  // Buffer for incomplete JSONL lines
       let lineCount = 0;    // Count of JSONL lines received
+      const lineBufferState = {
+        buffer: '',
+        lineTruncated: false,
+        warningLogged: false
+      };
+      const responseState = {
+        textContent: '',
+        seenTexts: new Set(),
+        rawOutput: '',
+        rawOutputTruncated: false
+      };
 
       const settle = (fn, value) => {
         if (settled) return;
@@ -312,12 +655,21 @@ class PiProvider extends AIProvider {
         fn(value);
       };
 
-      // Set up side-channel stream parser for live progress events.
       // Use the buffered Pi line parser to accumulate text_delta fragments
       // before emitting, preventing the UI from being flooded with tiny updates.
-      const streamParser = onStreamEvent
-        ? new StreamParser(createPiLineParser(), onStreamEvent, { cwd })
-        : null;
+      const streamLineParser = onStreamEvent ? createPiLineParser() : null;
+      const emitStreamLine = (line) => {
+        if (!streamLineParser || !line?.trim()) return;
+
+        const event = streamLineParser(line, { cwd });
+        if (!event) return;
+
+        try {
+          onStreamEvent(event);
+        } catch (error) {
+          logger.warn(`${levelPrefix} Pi stream event callback error: ${error.message}`);
+        }
+      };
 
       // Set timeout
       if (timeout) {
@@ -331,30 +683,27 @@ class PiProvider extends AIProvider {
       // Stream and log JSONL lines as they arrive for debugging visibility
       pi.stdout.on('data', (data) => {
         const chunk = data.toString();
-        stdout += chunk;
-
-        // Feed side-channel stream parser for live progress events
-        if (streamParser) {
-          streamParser.feed(chunk);
-        }
-
-        lineBuffer += chunk;
-
-        // Process complete lines (JSONL - each line is a complete JSON object)
-        const lines = lineBuffer.split('\n');
-        // Keep the last incomplete line in the buffer
-        lineBuffer = lines.pop() || '';
+        const lines = appendPiChunkToLineBuffer(lineBufferState, chunk, levelPrefix);
 
         for (const line of lines) {
           if (!line.trim()) continue;
           lineCount++;
+          emitStreamLine(line);
           this.logStreamLine(line, lineCount, levelPrefix);
+          accumulatePiResponseLine(line, responseState, levelPrefix);
         }
       });
 
       // Collect stderr
       pi.stderr.on('data', (data) => {
-        stderr += data.toString();
+        const chunk = data.toString();
+        appendHeadTailBuffer(stderrCapture, chunk, PI_STDERR_HEAD_CHARS, PI_STDERR_TAIL_CHARS);
+        if (stderrCapture.omittedChars > 0 && !stderrTruncated) {
+          stderrTruncated = true;
+          logger.warn(
+            `${levelPrefix} Pi CLI stderr exceeded ${MAX_PI_CAPTURED_STDERR_CHARS} chars; retaining a head+tail excerpt (${stderrCapture.omittedChars} chars omitted so far)`
+          );
+        }
       });
 
       // Handle completion
@@ -362,11 +711,6 @@ class PiProvider extends AIProvider {
         cleanupTmpFile();
         if (settled) return;  // Already settled by timeout or error
 
-        // Flush any remaining stream parser buffer
-        if (streamParser) {
-          streamParser.flush();
-        }
-
         // Check for cancellation signals (SIGTERM=143, SIGKILL=137)
         const isCancellationCode = code === 143 || code === 137;
         if (isCancellationCode && analysisId && isAnalysisCancelled(analysisId)) {
@@ -383,6 +727,8 @@ class PiProvider extends AIProvider {
           return;
         }
 
+        const stderr = formatHeadTailBuffer(stderrCapture);
+
         // Always log stderr if present
         if (stderr.trim()) {
           if (code !== 0) {
@@ -399,15 +745,21 @@ class PiProvider extends AIProvider {
         }
 
         // Process any remaining buffered line
-        if (lineBuffer.trim()) {
+        if (lineBufferState.buffer.trim()) {
           lineCount++;
-          this.logStreamLine(lineBuffer, lineCount, levelPrefix);
+          emitStreamLine(lineBufferState.buffer);
+          this.logStreamLine(lineBufferState.buffer, lineCount, levelPrefix);
+          accumulatePiResponseLine(lineBufferState.buffer, responseState, levelPrefix);
         }
 
         logger.info(`${levelPrefix} Pi CLI completed - received ${lineCount} JSONL events`);
 
         // Parse the Pi JSONL response
-        const parsed = this.parsePiResponse(stdout, level, levelPrefix);
+        const parsed = finalizePiResponseParsing({
+          textContent: responseState.textContent,
+          rawOutput: responseState.rawOutput,
+          rawOutputTruncated: responseState.rawOutputTruncated
+        }, level, levelPrefix);
         if (parsed.success) {
           logger.success(`${levelPrefix} Successfully parsed JSON response`);
 
@@ -427,8 +779,8 @@ class PiProvider extends AIProvider {
           // Pass extracted text content to LLM fallback (not raw JSONL stdout).
           // The text content is the actual LLM response text extracted from JSONL
           // events and is much smaller and more relevant than the full JSONL stream.
-          const llmFallbackInput = parsed.textContent || stdout;
-          logger.info(`${levelPrefix} LLM fallback input length: ${llmFallbackInput.length} characters (${parsed.textContent ? 'text content' : 'raw stdout'})`);
+          const llmFallbackInput = parsed.textContent || responseState.rawOutput;
+          logger.info(`${levelPrefix} LLM fallback input length: ${llmFallbackInput.length} characters (${parsed.textContent ? 'text content' : 'raw fallback output'})`);
           logger.info(`${levelPrefix} Attempting LLM-based JSON extraction fallback...`);
 
           // Use async IIFE to handle the async LLM extraction
@@ -623,55 +975,22 @@ class PiProvider extends AIProvider {
     try {
       // Split by newlines and parse each JSON line
       const lines = stdout.trim().split('\n').filter(line => line.trim());
-      let textContent = '';
-      const seenTexts = new Set();
+      const responseState = {
+        textContent: '',
+        seenTexts: new Set(),
+        rawOutput: '',
+        rawOutputTruncated: false
+      };
 
       for (const line of lines) {
-        try {
-          const event = JSON.parse(line);
-
-          // Extract text from message_end events (complete assistant messages)
-          // These contain the full message with content blocks
-          if (event.type === 'message_end' && event.message?.role === 'assistant') {
-            textContent += extractAssistantText(event.message.content, seenTexts);
-          }
-
-          // Also collect text from turn_end events which include the message
-          // (dedup handled by the shared seenTexts Set)
-          if (event.type === 'turn_end' && event.message?.role === 'assistant') {
-            textContent += extractAssistantText(event.message.content, seenTexts);
-          }
-
-          // Fallback: agent_end events contain the full messages array
-          if (event.type === 'agent_end' && Array.isArray(event.messages)) {
-            for (const msg of event.messages) {
-              if (msg.role === 'assistant') {
-                textContent += extractAssistantText(msg.content, seenTexts);
-              }
-            }
-          }
-        } catch (lineError) {
-          // Skip malformed lines
-          logger.debug(`${levelPrefix} Skipping malformed JSONL line: ${line.substring(0, 100)}`);
-        }
+        accumulatePiResponseLine(line, responseState, levelPrefix);
       }
 
-      if (textContent) {
-        // Try to extract JSON from the accumulated text content
-        const extracted = extractJSON(textContent, level);
-        if (extracted.success) {
-          return extracted;
-        }
-
-        // If no JSON found, return with textContent so the caller can
-        // pass it (not raw JSONL stdout) to the LLM extraction fallback
-        logger.warn(`${levelPrefix} Text content is not JSON, treating as raw text`);
-        return { success: false, error: 'Text content is not valid JSON', textContent };
-      }
-
-      // No text content found, try extracting JSON directly from stdout
-      const extracted = extractJSON(stdout, level);
-      return extracted;
+      return finalizePiResponseParsing({
+        textContent: responseState.textContent,
+        rawOutput: responseState.rawOutput,
+        rawOutputTruncated: responseState.rawOutputTruncated
+      }, level, levelPrefix);
 
     } catch (parseError) {
       // stdout might not be valid JSONL at all, try extracting JSON from it
@@ -862,4 +1181,11 @@ class PiProvider extends AIProvider {
 registerProvider('pi', PiProvider);
 
 module.exports = PiProvider;
+// Test-only exports. Underscore prefix signals internal helpers that should
+// not be consumed from production code paths.
 module.exports._extractAssistantText = extractAssistantText;
+module.exports._isPiEventEnvelope = isPiEventEnvelope;
+module.exports._appendWithLimit = appendWithLimit;
+module.exports._appendHeadTailBuffer = appendHeadTailBuffer;
+module.exports._formatHeadTailBuffer = formatHeadTailBuffer;
+module.exports._finalizePiResponseParsing = finalizePiResponseParsing;

package/src/ai/provider.js

@@ -738,8 +738,11 @@ async function testProviderAvailability(providerId, timeout = 10000) {
 }
 
 /**
- * Get tier for a specific model from a provider
- * Queries the provider's model definitions (or config overrides) to find the tier
+ * Get tier for a specific model from a provider.
+ * Queries the provider's model definitions (or config overrides) to find the tier.
+ * Matches against both the canonical model `id` and any `aliases` so legacy
+ * model IDs (e.g. `gpt-5.4` before reasoning-effort variants were introduced)
+ * still resolve their tier for historical analysis runs.
  * @param {string} providerId - Provider ID (e.g., 'claude', 'gemini')
  * @param {string} modelId - Model ID (e.g., 'sonnet', 'gemini-2.5-pro')
  * @returns {string|null} Tier name or null if provider or model not found
@@ -754,7 +757,7 @@ function getTierForModel(providerId, modelId) {
   const overrides = providerConfigOverrides.get(providerId);
   const models = mergeModels(ProviderClass.getModels(), overrides?.models);
 
-  const model = models.find(m => m.id === modelId);
+  const model = models.find(m => m.id === modelId || m.aliases?.includes(modelId));
   return model?.tier || null;
 }
 

package/src/main.js

@@ -116,7 +116,7 @@ OPTIONS:
     --model <name>          Override the AI model. Claude Code is the default provider.
                             Available models: opus, sonnet, haiku (Claude Code);
                             also: opus-4.5, opus-4.6-low, opus-4.6-medium, opus-4.6-1m,
-                                  opus-4.7-xhigh
+                                  opus-4.7-high, opus-4.7-xhigh
                             or use provider-specific models with Gemini/Codex
     --use-checkout          Use current directory instead of creating worktree
                             (automatic in GitHub Actions)