threadlines 0.2.25 → 0.4.0

package/dist/git/diff.js

@@ -1,7 +1,4 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRepoUrl = getRepoUrl;
 exports.getHeadCommitSha = getHeadCommitSha;
@@ -9,7 +6,6 @@ exports.getCommitMessage = getCommitMessage;
 exports.getCommitAuthor = getCommitAuthor;
 exports.getPRDiff = getPRDiff;
 exports.getCommitDiff = getCommitDiff;
-const simple_git_1 = __importDefault(require("simple-git"));
 const child_process_1 = require("child_process");
 const logger_1 = require("../utils/logger");
 // =============================================================================
@@ -88,18 +84,33 @@ async function getHeadCommitSha(repoRoot) {
 }
 /**
  * Get commit message for a specific commit SHA
- * Returns full commit message (subject + body) or null if commit not found
+ *
+ * Fails loudly if commit cannot be retrieved (commit not found, git error, etc.).
+ * This function is only called when a commit is expected to exist:
+ * - In CI environments (always has HEAD commit)
+ * - In local environment with --commit flag (user explicitly provided SHA)
+ *
+ * @param repoRoot - Path to the repository root
+ * @param sha - Commit SHA to get message for
+ * @returns Full commit message (subject + body)
+ * @throws Error if commit cannot be retrieved
  */
 async function getCommitMessage(repoRoot, sha) {
-    const git = (0, simple_git_1.default)(repoRoot);
     try {
         // Get full commit message (subject + body)
-        const message = await git.show([sha, '--format=%B', '--no-patch']);
-        return message.trim() || null;
+        const message = (0, child_process_1.execSync)(`git show --format=%B --no-patch ${sha}`, {
+            encoding: 'utf-8',
+            cwd: repoRoot
+        }).trim();
+        if (!message) {
+            throw new Error(`Commit ${sha} exists but has no message`);
+        }
+        return message;
     }
-    catch {
-        // Commit not found or invalid
-        return null;
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to get commit message for ${sha}: ${errorMessage}\n` +
+            `This commit should exist (called from CI or with --commit flag).`);
     }
 }
 /**
@@ -180,16 +191,19 @@ async function getCommitAuthor(repoRoot, sha) {
  * @param logger - Optional logger for debug output
  */
 async function getPRDiff(repoRoot, targetBranch, logger) {
-    const git = (0, simple_git_1.default)(repoRoot);
     // Fetch target branch on-demand (works with shallow clones)
     logger?.debug(`Fetching target branch: origin/${targetBranch}`);
     try {
-        await git.fetch(['origin', `${targetBranch}:refs/remotes/origin/${targetBranch}`, '--depth=1']);
+        (0, child_process_1.execSync)(`git fetch origin ${targetBranch}:refs/remotes/origin/${targetBranch} --depth=1`, {
+            cwd: repoRoot,
+            stdio: 'pipe' // Suppress fetch output
+        });
     }
     catch (fetchError) {
+        const errorMessage = fetchError instanceof Error ? fetchError.message : String(fetchError);
         throw new Error(`Failed to fetch target branch origin/${targetBranch}. ` +
             `This is required for PR/MR diff comparison. ` +
-            `Error: ${fetchError instanceof Error ? fetchError.message : 'Unknown error'}`);
+            `Error: ${errorMessage}`);
     }
     // Try three dots (merge base) first - shows only developer's changes
     // Falls back to two dots (direct comparison) if shallow clone prevents merge base calculation
@@ -200,9 +214,16 @@ async function getPRDiff(repoRoot, targetBranch, logger) {
         // This isolates developer changes by comparing against merge base
         // Works when we have enough history (full clones or GitHub's merge commits)
         logger?.debug(`Attempting three-dots diff (merge base): origin/${targetBranch}...HEAD`);
-        diff = await git.diff([`origin/${targetBranch}...HEAD`, '-U200']);
-        const diffSummary = await git.diffSummary([`origin/${targetBranch}...HEAD`]);
-        changedFiles = diffSummary.files.map(f => f.file);
+        diff = (0, child_process_1.execSync)(`git diff origin/${targetBranch}...HEAD -U200`, {
+            encoding: 'utf-8',
+            cwd: repoRoot
+        });
+        // Get changed files using git diff --name-only
+        const changedFilesOutput = (0, child_process_1.execSync)(`git diff --name-only origin/${targetBranch}...HEAD`, {
+            encoding: 'utf-8',
+            cwd: repoRoot
+        }).trim();
+        changedFiles = changedFilesOutput ? changedFilesOutput.split('\n') : [];
     }
     catch (error) {
         // Step 2: Fallback to "Risky" Diff (Two Dots)
@@ -215,9 +236,15 @@ async function getPRDiff(repoRoot, targetBranch, logger) {
         logger?.debug(`Fallback error: ${errorMessage}`);
         // Use two dots (direct comparison) - shows all differences between tips
         logger?.debug(`Using two-dots diff (direct comparison): origin/${targetBranch}..HEAD`);
-        diff = await git.diff([`origin/${targetBranch}..HEAD`, '-U200']);
-        const diffSummary = await git.diffSummary([`origin/${targetBranch}..HEAD`]);
-        changedFiles = diffSummary.files.map(f => f.file);
+        diff = (0, child_process_1.execSync)(`git diff origin/${targetBranch}..HEAD -U200`, {
+            encoding: 'utf-8',
+            cwd: repoRoot
+        });
+        const changedFilesOutput = (0, child_process_1.execSync)(`git diff --name-only origin/${targetBranch}..HEAD`, {
+            encoding: 'utf-8',
+            cwd: repoRoot
+        }).trim();
+        changedFiles = changedFilesOutput ? changedFilesOutput.split('\n') : [];
     }
     return {
         diff: diff || '',
@@ -250,7 +277,6 @@ async function getPRDiff(repoRoot, targetBranch, logger) {
  * @param sha - Commit SHA to get diff for (defaults to HEAD)
  */
 async function getCommitDiff(repoRoot, sha = 'HEAD') {
-    const git = (0, simple_git_1.default)(repoRoot);
     // Fetch parent commit on-demand to ensure git show can generate a proper diff
     // This works regardless of CI checkout depth settings (depth=1 or depth=2)
     // If parent is already available, fetch is fast/no-op; if not, we fetch it
@@ -295,7 +321,10 @@ async function getCommitDiff(repoRoot, sha = 'HEAD') {
     // If we get here, parentSha is guaranteed to be a valid 40-character SHA
     try {
         // Fetch just this one commit (depth=1 is fine, we only need the parent)
-        await git.fetch(['origin', parentSha, '--depth=1']);
+        (0, child_process_1.execSync)(`git fetch origin ${parentSha} --depth=1`, {
+            cwd: repoRoot,
+            stdio: 'pipe' // Suppress fetch output
+        });
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
@@ -312,10 +341,16 @@ async function getCommitDiff(repoRoot, sha = 'HEAD') {
     let changedFiles;
     try {
         // Use git diff to compare parent against HEAD (plumbing command, ignores shallow boundaries)
-        diff = await git.diff([`${parentSha}..${sha}`, '-U200']);
+        diff = (0, child_process_1.execSync)(`git diff ${parentSha}..${sha} -U200`, {
+            encoding: 'utf-8',
+            cwd: repoRoot
+        });
         // Get changed files using git diff --name-only
-        const diffSummary = await git.diffSummary([`${parentSha}..${sha}`]);
-        changedFiles = diffSummary.files.map(f => f.file);
+        const changedFilesOutput = (0, child_process_1.execSync)(`git diff --name-only ${parentSha}..${sha}`, {
+            encoding: 'utf-8',
+            cwd: repoRoot
+        }).trim();
+        changedFiles = changedFilesOutput ? changedFilesOutput.split('\n') : [];
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : 'Unknown error';

package/dist/git/local.js

@@ -11,21 +11,55 @@
  * - branchName: string
  * - commitAuthor: { name: string; email: string }
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLocalContext = getLocalContext;
-const simple_git_1 = __importDefault(require("simple-git"));
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const diff_1 = require("./diff");
+const logger_1 = require("../utils/logger");
 /**
  * Gets all Local context
  */
 async function getLocalContext(repoRoot, commitSha) {
-    const git = (0, simple_git_1.default)(repoRoot);
     // Check if we're in a git repo
-    const isRepo = await git.checkIsRepo();
-    if (!isRepo) {
+    try {
+        (0, child_process_1.execSync)('git rev-parse --git-dir', { cwd: repoRoot, stdio: 'ignore' });
+    }
+    catch {
         throw new Error('Not a git repository. Threadline requires a git repository.');
     }
     // Get all Local context
@@ -37,13 +71,10 @@ async function getLocalContext(repoRoot, commitSha) {
     const commitAuthor = commitSha
         ? await getCommitAuthorFromGit(repoRoot, commitSha)
         : await getCommitAuthorFromConfig(repoRoot);
-    // Get commit message if we have a SHA
+    // Get commit message if we have a SHA (fails loudly if commit doesn't exist)
     let commitMessage;
     if (commitSha) {
-        const message = await (0, diff_1.getCommitMessage)(repoRoot, commitSha);
-        if (message) {
-            commitMessage = message;
-        }
+        commitMessage = await (0, diff_1.getCommitMessage)(repoRoot, commitSha);
     }
     return {
         diff,
@@ -64,45 +95,162 @@ async function getLocalContext(repoRoot, commitSha) {
  * or review unstaged changes if nothing is staged.
  */
 async function getDiff(repoRoot) {
-    const git = (0, simple_git_1.default)(repoRoot);
-    // Get git status to determine what changes exist
-    const status = await git.status();
+    // Get git status in porcelain format to determine what changes exist
+    // Porcelain format: XY filename
+    // X = staged status, Y = unstaged status
+    // ' ' = no change, 'M' = modified, 'A' = added, 'D' = deleted, etc.
+    // '?' = untracked (only in Y position, X is always '?' too)
+    const statusOutput = (0, child_process_1.execSync)('git status --porcelain', {
+        encoding: 'utf-8',
+        cwd: repoRoot
+    }).trim();
+    const lines = statusOutput ? statusOutput.split('\n') : [];
+    const staged = [];
+    const unstaged = [];
+    const untracked = [];
+    for (const line of lines) {
+        const stagedStatus = line[0];
+        const unstagedStatus = line[1];
+        // Collect untracked files separately (they need special handling)
+        if (stagedStatus === '?' && unstagedStatus === '?') {
+            // Format: "?? filename" - skip 3 characters
+            const file = line.slice(3);
+            untracked.push(file);
+            continue;
+        }
+        // For tracked files, the format can be:
+        // - "M filename" (staged, no leading space) - skip 2 characters
+        // - " M filename" (unstaged, leading space) - skip 3 characters
+        // - "MM filename" (both staged and unstaged) - skip 3 characters
+        let file;
+        if (stagedStatus !== ' ' && unstagedStatus === ' ') {
+            // Staged only: "M filename" - skip 2 characters (M + space)
+            file = line.slice(2);
+        }
+        else {
+            // Unstaged or both: " M filename" or "MM filename" - skip 3 characters
+            file = line.slice(3);
+        }
+        if (stagedStatus !== ' ') {
+            staged.push(file);
+        }
+        if (unstagedStatus !== ' ' && unstagedStatus !== '?') {
+            unstaged.push(file);
+        }
+    }
     let diff;
     let changedFiles;
-    // Priority 1: Use staged changes if available
-    if (status.staged.length > 0) {
-        diff = await git.diff(['--cached', '-U200']);
-        // status.staged is an array of strings (file paths)
-        changedFiles = status.staged;
+    // Check if there are actually staged files (use git diff as source of truth)
+    // git status parsing can be inconsistent, so we verify with git diff
+    const stagedFilesOutput = (0, child_process_1.execSync)('git diff --cached --name-only', {
+        encoding: 'utf-8',
+        cwd: repoRoot
+    }).trim();
+    const actualStagedFiles = stagedFilesOutput ? stagedFilesOutput.split('\n') : [];
+    // Workflow A: Developer has staged files - check ONLY staged files
+    // (Ignore unstaged and untracked - developer explicitly chose to check staged)
+    if (actualStagedFiles.length > 0) {
+        diff = (0, child_process_1.execSync)('git diff --cached -U200', {
+            encoding: 'utf-8',
+            cwd: repoRoot
+        });
+        changedFiles = actualStagedFiles;
+        // If staged files exist but diff is empty, something is wrong
+        if (!diff || diff.trim() === '') {
+            throw new Error(`Staged files exist but diff is empty. ` +
+                `This may indicate binary files, whitespace-only changes, or a git issue. ` +
+                `Staged files: ${actualStagedFiles.join(', ')}`);
+        }
+        logger_1.logger.info(`Checking STAGED changes (${changedFiles.length} file(s))`);
+        return {
+            diff: diff || '',
+            changedFiles
+        };
     }
-    // Priority 2: Use unstaged changes if no staged changes
-    else if (status.files.length > 0) {
-        diff = await git.diff(['-U200']);
-        changedFiles = status.files
-            .filter(f => f.working_dir !== ' ' || f.index !== ' ')
-            .map(f => f.path);
+    // No staged files - log clearly and continue to unstaged/untracked
+    if (staged.length > 0) {
+        // git status showed staged files but git diff doesn't - they were likely unstaged
+        logger_1.logger.info(`No staged files detected (files may have been unstaged), checking unstaged/untracked files instead.`);
     }
-    // No changes at all
     else {
+        logger_1.logger.info(`No staged files, checking unstaged/untracked files.`);
+    }
+    // Workflow B: Developer hasn't staged files - check unstaged + untracked files
+    // (Untracked files are conceptually "unstaged" - files being worked on but not committed)
+    if (unstaged.length > 0 || untracked.length > 0) {
+        // Get unstaged diff if there are unstaged files
+        if (unstaged.length > 0) {
+            diff = (0, child_process_1.execSync)('git diff -U200', {
+                encoding: 'utf-8',
+                cwd: repoRoot
+            });
+            const changedFilesOutput = (0, child_process_1.execSync)('git diff --name-only', {
+                encoding: 'utf-8',
+                cwd: repoRoot
+            }).trim();
+            changedFiles = changedFilesOutput ? changedFilesOutput.split('\n') : [];
+        }
+        else {
+            diff = '';
+            changedFiles = [];
+        }
+        // Handle untracked files: read their content and create artificial diffs
+        // Fails loudly if any untracked file cannot be read (permissions, filesystem errors, etc.)
+        const untrackedDiffs = [];
+        const untrackedFileList = [];
+        for (const file of untracked) {
+            const fullPath = path.resolve(repoRoot, file);
+            // Skip if it's a directory (git status can show directories)
+            const stats = fs.statSync(fullPath);
+            if (!stats.isFile()) {
+                continue;
+            }
+            // Read file content - fails loudly on any error (permissions, encoding, etc.)
+            const content = fs.readFileSync(fullPath, 'utf-8');
+            // Normalize path to forward slashes for cross-platform consistency
+            const normalizedPath = file.replace(/\\/g, '/');
+            // Create artificial diff (all lines as additions, similar to getFileContent)
+            const lines = content.split('\n');
+            const fileDiff = lines.map((line) => `+${line}`).join('\n');
+            // Add git diff header (matches format expected by server's filterDiffByFiles)
+            const diffHeader = `diff --git a/${normalizedPath} b/${normalizedPath}\n--- /dev/null\n+++ b/${normalizedPath}\n@@ -0,0 +1,${lines.length} @@\n`;
+            untrackedDiffs.push(diffHeader + fileDiff);
+            untrackedFileList.push(normalizedPath);
+        }
+        // Combine unstaged changes with untracked files
+        const combinedDiff = untrackedDiffs.length > 0
+            ? (diff ? diff + '\n' : '') + untrackedDiffs.join('\n')
+            : diff;
+        const allChangedFiles = [...changedFiles, ...untrackedFileList];
+        const unstagedCount = changedFiles.length;
+        const untrackedCount = untrackedFileList.length;
+        if (unstagedCount > 0 && untrackedCount > 0) {
+            logger_1.logger.info(`Checking UNSTAGED changes (${unstagedCount} file(s)) + ${untrackedCount} untracked file(s)`);
+        }
+        else if (unstagedCount > 0) {
+            logger_1.logger.info(`Checking UNSTAGED changes (${unstagedCount} file(s))`);
+        }
+        else {
+            logger_1.logger.info(`Checking UNTRACKED files (${untrackedCount} file(s))`);
+        }
         return {
-            diff: '',
-            changedFiles: []
+            diff: combinedDiff || '',
+            changedFiles: allChangedFiles
         };
     }
-    return {
-        diff: diff || '',
-        changedFiles
-    };
+    // No changes at all - fail loudly
+    throw new Error('No changes detected. Stage files with "git add" or modify files to run threadlines.');
 }
 /**
  * Gets branch name for local environment
  * (Uses git command directly - works in local because not in detached HEAD state)
  */
 async function getBranchName(repoRoot) {
-    const git = (0, simple_git_1.default)(repoRoot);
     try {
-        const branchSummary = await git.branchLocal();
-        const currentBranch = branchSummary.current;
+        const currentBranch = (0, child_process_1.execSync)('git branch --show-current', {
+            encoding: 'utf-8',
+            cwd: repoRoot
+        }).trim();
         if (!currentBranch) {
             throw new Error('Could not determine current branch. Are you in a git repository?');
         }
@@ -120,17 +268,22 @@ async function getBranchName(repoRoot) {
  * No fallbacks - if git config is not set or fails, throws an error.
  */
 async function getCommitAuthorFromConfig(repoRoot) {
-    const git = (0, simple_git_1.default)(repoRoot);
     try {
-        const name = await git.getConfig('user.name');
-        const email = await git.getConfig('user.email');
-        if (!name.value || !email.value) {
+        const name = (0, child_process_1.execSync)('git config --get user.name', {
+            encoding: 'utf-8',
+            cwd: repoRoot
+        }).trim();
+        const email = (0, child_process_1.execSync)('git config --get user.email', {
+            encoding: 'utf-8',
+            cwd: repoRoot
+        }).trim();
+        if (!name || !email) {
             throw new Error('Git config user.name or user.email is not set. ' +
                 'Run: git config user.name "Your Name" && git config user.email "your.email@example.com"');
         }
         return {
-            name: name.value.trim(),
-            email: email.value.trim()
+            name: name,
+            email: email
         };
     }
     catch (error) {

package/dist/llm/prompt-builder.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Prompt Builder for LLM Threadline Checks
+ *
+ * Builds prompts for OpenAI API calls to check code changes against threadline guidelines.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPrompt = buildPrompt;
+function buildPrompt(threadline, diff, matchingFiles) {
+    // Build context files section if available
+    const contextFilesSection = threadline.contextContent && Object.keys(threadline.contextContent).length > 0
+        ? `Context Files:\n${Object.entries(threadline.contextContent)
+            .map(([file, content]) => `\n--- ${file} ---\n${content}`)
+            .join('\n')}\n\n`
+        : '';
+    return `You are a code quality checker focused EXCLUSIVELY on: ${threadline.id}
+
+CRITICAL: You must ONLY check for violations of THIS SPECIFIC threadline. Do NOT flag other code quality issues, style problems, or unrelated concerns. 
+If the code does not violate THIS threadline's specific rules, return "compliant" even if other issues exist.
+
+Threadline Guidelines:
+${threadline.content}
+
+${contextFilesSection}Code Changes (Git Diff Format):
+${diff}
+
+Changed Files:
+${matchingFiles.join('\n')}
+
+Review the code changes AGAINST ONLY THE THREADLINE GUIDELINES ABOVE.
+
+YOUR OBJECTIVES:
+1. Detect new violations being introduced in the code changes
+2. Review whether engineers have successfully addressed earlier violations
+
+This is why it's important to look very carefully at the diff structure. You'll come across diffs that introduce new violations. You will also come across some that address earlier violations. The diff structure should allow you to tell which is which, because lines starting with '-' are removed in favour of lines with '+'.
+
+CRITICAL CHECK BEFORE FLAGGING VIOLATIONS:
+Before commenting on or flagging a violation in any line, look at the FIRST CHARACTER of that line:
+* If it's a "-", the code is deleted.
+  → Only flag violations in lines starting with "+" (new code being added)
+* If the first character is "+", this is NEW code being added - flag violations here if they violate the threadline
+* If the line doesn't start with "+" or "-" (context lines), these are UNCHANGED - do NOT flag violations here
+* Some violations may not be line-specific (e.g., file-level patterns, overall structure) - include those in your reasoning as well
+
+
+IMPORTANT:
+- Only flag violations of the specific rules defined in this threadline
+- Ignore all other code quality issues, style problems, or unrelated concerns
+- Focus on understanding the diff structure to distinguish between new violations and fixes
+
+Return JSON only with this exact structure:
+{
+  "status": "compliant" | "attention" | "not_relevant",
+  "reasoning": "explanation with file paths and line numbers embedded in the text (e.g., 'app/api/checks/route.ts:8 - The addition of...')",
+  "file_references": [file paths where violations occur - MUST match files from the diff, include ONLY files with violations]
+}
+
+CRITICAL: For each violation, you MUST:
+1. Embed the file path and line number(s) directly in your reasoning text (e.g., "app/api/checks/route.ts:8 - The addition of 'c.files_changed_counts' violates...")
+2. For line-specific violations, include the line number (e.g., "file.ts:42")
+3. For file-level or pattern violations, just include the file path (e.g., "file.ts")
+4. Include ONLY files that actually contain violations in "file_references" array
+5. Do NOT include files that don't have violations, even if they appear in the diff
+6. The "file_references" array should be a simple list of file paths - no line numbers needed there since they're in the reasoning
+
+Status meanings:
+- "compliant": Code follows THIS threadline's guidelines, no violations found (even if other issues exist)
+- "attention": Code DIRECTLY violates THIS threadline's specific guidelines
+- "not_relevant": This threadline doesn't apply to these files/changes (e.g., wrong file type, no matching code patterns)
+`;
+}

package/dist/processors/expert.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processThreadlines = processThreadlines;
+const single_expert_1 = require("./single-expert");
+const logger_1 = require("../utils/logger");
+const EXPERT_TIMEOUT = 40000; // 40 seconds
+async function processThreadlines(request) {
+    const { threadlines, diff, files, apiKey, model, serviceTier, contextLinesForLLM } = request;
+    // Determine LLM model (same for all threadlines in this check)
+    const llmModel = `${model} ${serviceTier}`;
+    // Create promises with timeout
+    const promises = threadlines.map(threadline => {
+        let timeoutId = null;
+        let resolved = false;
+        const timeoutPromise = new Promise((resolve) => {
+            timeoutId = setTimeout(() => {
+                // Only log and resolve if we haven't already resolved
+                if (!resolved) {
+                    logger_1.logger.error(`Request timed out after ${EXPERT_TIMEOUT / 1000}s for threadline: ${threadline.id}`);
+                    resolved = true;
+                    resolve({
+                        expertId: threadline.id,
+                        status: 'error',
+                        reasoning: `Error: Request timed out after ${EXPERT_TIMEOUT / 1000}s`,
+                        error: {
+                            message: `Request timed out after ${EXPERT_TIMEOUT / 1000}s`,
+                            type: 'timeout'
+                        },
+                        fileReferences: [],
+                        relevantFiles: [],
+                        filteredDiff: '',
+                        filesInFilteredDiff: [],
+                        actualModel: undefined
+                    });
+                }
+            }, EXPERT_TIMEOUT);
+        });
+        const actualPromise = (0, single_expert_1.processThreadline)(threadline, diff, files, apiKey, model, serviceTier, contextLinesForLLM).then(result => {
+            // Mark as resolved and clear timeout if it hasn't fired yet
+            resolved = true;
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            return result;
+        });
+        return Promise.race([actualPromise, timeoutPromise]);
+    });
+    // Wait for all (some may timeout)
+    const results = await Promise.allSettled(promises);
+    // Process results
+    const expertResults = [];
+    let completed = 0;
+    let timedOut = 0;
+    let errors = 0;
+    let actualModelFromResponse;
+    for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        const threadline = threadlines[i];
+        if (result.status === 'fulfilled') {
+            const expertResult = result.value;
+            // Check status directly - errors and timeouts are now 'error' status
+            if (expertResult.status === 'error') {
+                // Check if it's a timeout (has error.type === 'timeout')
+                if ('error' in expertResult && expertResult.error?.type === 'timeout') {
+                    timedOut++;
+                }
+                else {
+                    errors++;
+                }
+            }
+            else {
+                completed++;
+            }
+            expertResults.push(expertResult);
+            // Capture actual model from first successful result (all threadlines use same model)
+            if (!actualModelFromResponse && 'actualModel' in expertResult && expertResult.actualModel) {
+                actualModelFromResponse = expertResult.actualModel;
+            }
+        }
+        else {
+            errors++;
+            expertResults.push({
+                expertId: threadline.id,
+                status: 'error',
+                reasoning: `Error: ${result.reason?.message || 'Unknown error'}`,
+                error: {
+                    message: result.reason?.message || 'Unknown error',
+                    rawResponse: result.reason
+                },
+                fileReferences: [],
+                relevantFiles: [],
+                filteredDiff: '',
+                filesInFilteredDiff: []
+            });
+        }
+    }
+    // Use actual model from OpenAI response, append service tier
+    let modelToStore;
+    if (actualModelFromResponse) {
+        modelToStore = `${actualModelFromResponse} ${serviceTier}`;
+    }
+    else {
+        // All calls failed - log prominently and preserve requested model for debugging
+        logger_1.logger.error(`No successful LLM responses received. Requested model: ${llmModel}`);
+        logger_1.logger.error(`Completed: ${completed}, Timed out: ${timedOut}, Errors: ${errors}`);
+        // Store requested model so we can debug what was attempted
+        modelToStore = `${llmModel} (no successful responses)`;
+    }
+    // Return all results - CLI will handle filtering/display
+    return {
+        results: expertResults,
+        metadata: {
+            totalThreadlines: threadlines.length,
+            completed,
+            timedOut,
+            errors,
+            llmModel: modelToStore
+        }
+    };
+}