triage-trip 0.1.0 → 0.1.3

package/README.md

@@ -1,146 +1,123 @@
-# `ai-blackbox`
+Markdown
+# triage-trip 
 
-> Autonomous AI Regression Triage & Provenance CLI. Pinpoint breaking contract changes introduced by AI coding tools in seconds.
+> Autonomous CLI to pinpoint and patch regressions introduced by AI code assistants (Cursor, Copilot).
 
-<p align="center">
-  <img src="./assets/demo.gif" alt="AI-Blackbox Demo" width="700">
-</p>
----
+![triage-trip Demo](assets/demo.gif)
 
 ## The Problem
+When you use AI coding assistants to refactor or draft features, errors often slip through:
+- Subtle schema property renames (`userId` ➔ `user_id`).
+- Dropped function arguments or breaking contract shifts.
+- Regressions that aren't caught until 3 commits later.
 
-AI coding assistants (Cursor, GitHub Copilot, Windsurf) dramatically accelerate drafting and refactoring code. However, they frequently cause **silent contract drift**:
-
-* An AI renames an object key or subtle schema attribute (e.g., `userId` ➔ `user_id`).
-* Standard linters and compilers pass because the syntax is completely valid.
-* Downstream modules crash 2–3 commits later with cryptic runtime errors (`TypeError: Cannot read properties of undefined`).
-* Developers spend 20–30 minutes manually inspecting multi-file diffs, running `git bisect`, and searching for what changed.
-
----
-
-## What `ai-blackbox` Does
-
-`ai-blackbox` connects the dots across your development environment to trace the exact lineage of a regression:
-
-```text
-[ User Prompt in IDE ] ➔ [ AI Generated Diff ] ➔ [ Git Commit ] ➔ [ Runtime Error ]
-                                                                          │
-                                                                   ai-blackbox triage
-                                                                          │
-                                                                          ▼
-                                                       • Exact Root Cause & Commit
-                                                       • Attributed AI Prompt
-                                                       • Semantic Contract Shift
-                                                       • Clean Unified Diff Patch
+Developers lose 30+ minutes digging through hundreds of lines of AI diffs trying to figure out which prompt broke the build.
 
-```
-
-1. **Inspects Git History:** Automatically reads uncommitted working changes and recent commits using `simple-git`.
-2. **Extracts AI Session Provenance:** Scans local IDE storage (e.g., Cursor's local SQLite database `state.vscdb`) to retrieve recent prompts and user instructions.
-3. **Triages Semantic Drift:** Correlates the runtime stack trace with recent AST modifications and prompts via the OpenAI API to deliver an instant diagnostic report.
+## How It Works
+`triage-trip` connects runtime failures back to their origin:
+1. **Reads Local Git Stream:** Analyzes unstaged changes and recent commit diffs.
+2. **Inspects Cursor Provenance:** Reads local IDE session SQLite databases (`state.vscdb`) to identify the exact human prompt that generated the regression.
+3. **Isolates Semantic Shifts:** Determines contract and schema breaks.
+4. **Interactive In-Memory Patching:** Applies clean unified diffs directly to your working tree via `git apply` with a single confirmation.
 
 ---
 
-## Installation
-
-### Prerequisites
+## Quick Start
 
-* **Node.js** (v18 or higher, ESM native)
-* An active **OpenAI API Key**
-
-### Local Setup
+Run instantly without global installation:
 
 ```bash
-# Clone the repository
-git clone https://github.com/your-username/ai-blackbox.git
-cd ai-blackbox
-
-# Install dependencies
-npm install
-
-# Link executable globally (optional for direct CLI access)
-npm link
+npx triage-trip triage "TypeError: Cannot read properties of undefined (reading 'toUpperCase')"
+Or install globally:
+
+Bash
+npm install -g triage-trip
+Environment Setup
+Set your preferred LLM API key:
+
+Bash
+export ANTHROPIC_API_KEY="your-anthropic-key"
+# or
+export OPENAI_API_KEY="your-openai-key"
+Usage
+Diagnose an Error Trace
+Bash
+triage-trip triage "Cannot read properties of undefined (reading 'toUpperCase')"
+Auto-Apply Patches Instantly
+Skip the confirmation prompt to patch immediately:
+
+Bash
+triage-trip triage "ReferenceError: getUserProfile is not defined" --yes
+Inspect More Commits
+Bash
+triage-trip triage "SyntaxError: Unexpected token" --commits 10
+License
+MIT
 
-```
-
-Set your OpenAI API key in your terminal environment or add it to a `.env` file:
-
-```bash
-export OPENAI_API_KEY="sk-..."
-
-```
 
 ---
 
-## Quickstart & Usage
-
-Run the triage engine directly against any runtime error message or stack trace:
+### Step 3: Commit and Publish
 
 ```bash
-# Via npm script
-node bin/cli.js triage "TypeError: Cannot read properties of undefined (reading 'toUpperCase')"
+# Stage the updated doc and new GIF
+git add README.md assets/demo.gif package.json bin/cli.js
 
-# Or globally (if linked)
-ai-blackbox triage "TypeError: Cannot read properties of undefined (reading 'toUpperCase')"
+# Commit
+git commit -m "docs: rebrand to triage-trip with new demo gif"
 
-```
+# Push to your remote
+git push origin main
 
-### Options
+# Publish live on npm
+npm publish --access public
 
-* `<query_or_error>` *(required)*: The error message or failing test description.
-* `-c, --commits <number>`: Number of recent commits to analyze (default: `5`).
 
----
+## Inspiration & Ecosystem
 
-## Example Output
+Large engineering organizations (like Uber with their internal autonomous debugging agents) have long relied on automated bisect and triage systems to catch regressions before they reach staging. 
 
-```markdown
-■ AI-Blackbox Triage Engine
+However, existing enterprise tooling wasn't built for the AI code assistant era. When an LLM refactors multi-file repositories in Cursor or Copilot, conventional stack traces don't tell you which human prompt caused the contract shift. 
 
-✔ Root cause isolated.
+`triage-trip` bridges that gap for every developer: a zero-overhead local CLI that brings automated root-cause isolation, Cursor prompt provenance, and in-memory patching right to your terminal.
 
-1. **Root Cause**: The error occurs in `app.js` at line 6, where `profile.userId` is accessed. 
-   The breaking change was introduced in commit `b83c577` ("refactor: update user schema"), 
-   which modified the `getUserProfile` function in `user.js`.
+## Security & Privacy
+- **Read-Only SQLite Access:** `triage-trip` reads local IDE databases (`state.vscdb`) in strict read-only mode (`readonly: true`). It never modifies editor settings or session files.
+- **Direct LLM Communication:** Your repository context and diffs are sent directly to Anthropic or OpenAI using your own local environment API keys. No intermediate servers, telemetry trackers, or external logging daemons.
 
-2. **Attributed Prompt**: "Rename userId to user_id across the returned profile object."
+## Compatibility
+- **IDEs:** Cursor (Full prompt provenance support via local Composer storage), VS Code / Windsurf (Git diff & contract triage)
+- **Platforms:** macOS, Linux, Windows (WSL / PowerShell)
+- **Runtime:** Node.js `>= 18.0.0`
 
-3. **The Shift**: The `getUserProfile` function now returns `user_id` instead of `userId`, 
-   causing `profile.userId` to evaluate to `undefined`.
+## CLI Options
 
-4. **Patch**:
---- a/app.js
-+++ b/app.js
-@@ -6,2 +6,2 @@
--  console.log(`Loading dashboard for user ID: ${profile.userId.toUpperCase()}`);
-+  console.log(`Loading dashboard for user ID: ${profile.user_id.toUpperCase()}`);
+| Flag | Default | Description |
+| :--- | :--- | :--- |
+| `-c, --commits <num>` | `5` | Number of recent commits to inspect alongside unstaged working diffs |
+| `-y, --yes` | `false` | Automatically apply the proposed patch without an interactive prompt |
+| `-V, --version` | | Display current version |
+| `-h, --help` | | Display help and usage options |
 
-```
+## Development
 
----
-
-## Project Structure
-
-```text
-ai-blackbox/
-├── bin/
-│   └── cli.js            # CLI commands & terminal output formatting (Commander, Ora, Picocolors)
-├── src/
-│   ├── git.js            # Working tree and commit diff extraction (simple-git)
-│   ├── cursor.js         # Cursor SQLite database parser (better-sqlite3)
-│   └── triage.js         # OpenAI triage diagnostic engine (GPT-4o)
-├── package.json
-└── README.md
+```bash
+git clone [https://github.com/arules3/triage-trip.git](https://github.com/arules3/triage-trip.git)
+cd triage-trip
+npm install
+npm link
 
-```
 
----
+## Current Status & Roadmap
 
-## Roadmap
+### What's Working Today (`v0.1.0`)
+- **Git Context Analysis:** Reads unstaged working tree diffs and recent commit logs.
+- **Cursor Prompt Provenance:** Direct read-only extraction from local `state.vscdb` to link regressions to specific Composer prompts.
+- **Root Cause Isolation:** LLM-assisted semantic contract shift detection.
+- **Interactive Patching:** Clean, in-memory `git apply` with user confirmation prompts (`--yes` fallback).
 
-* [x] Git diff & commit stream extraction
-* [x] Local SQLite prompt extraction for Cursor Composer
-* [x] OpenAI regression diagnostic engine
-* [ ] Auto-patch application flag (`--fix` via `git apply`)
-* [ ] Multi-IDE adapters (GitHub Copilot Chat, Windsurf Cascade, Claude Code)
-* [ ] GitHub Action runner for automated PR failure triage
+### On the Horizon
+- [ ] **Automated Test Verification:** Automatically run project test suites (`npm test`, `pytest`) to verify fixes before finalizing patches.
+- [ ] **Expanded IDE Provenance:** Support for Windsurf (`cascade`), VS Code Copilot Chat, and Claude Code logs.
+- [ ] **GitHub Action / CI Mode:** Comment directly on failed PR runs with the attributed prompt and proposed fix.
+- [ ] **Deterministic AST Diffing:** Local offline schema diffing before LLM invocation to cut latency and token usage.

package/bin/cli.js

@@ -24,15 +24,15 @@ program
   .option('-c, --commits <number>', 'Number of recent commits to analyze', '5')
   .option('-y, --yes', 'Automatically apply the patch without asking', false)
   .action(async (errorInput, options) => {
-    console.log(pc.bold(pc.cyan('\n■ AI-Blackbox Triage Engine\n')));
+    console.log(pc.bold(pc.cyan('\n■ Triage-Trip Engine\n')));
 
     const spinner = ora('Reading recent git changes & Cursor prompts...').start();
     let diagnosis = '';
-    
+
     try {
       const commitCount = parseInt(options.commits, 10);
       const [changes, prompts] = await Promise.all([
-        getRecentChanges(commitCount),
+        getRecentChanges(commitCount, errorInput),
         Promise.resolve().then(() => getRecentCursorPrompts(10))
       ]);
 
@@ -60,16 +60,21 @@ program
       }
 
       if (shouldApply) {
-        const patchSpinner = ora('Applying patch via git apply...').start();
+        const patchSpinner = ora('Applying patch to working tree...').start();
         try {
-          await applyDiff(patch);
+          const res = await applyDiff(patch);
           patchSpinner.succeed(pc.green('Patch applied successfully to working tree.'));
+          if (res?.modifiedFiles && res.modifiedFiles.length > 0) {
+            console.log(pc.dim(`Modified: ${res.modifiedFiles.join(', ')}`));
+          }
           console.log(pc.dim('Run `git diff` to review or `git commit` to save the fix.\n'));
         } catch (err) {
-          patchSpinner.fail(pc.red(err.message));
+          patchSpinner.fail(pc.red('Patch application failed: ' + err.message));
         }
       }
+    } else {
+      console.log(pc.dim('ℹ No executable patch block was detected in the diagnostic report.\n'));
     }
   });
 
-program.parse(process.argv);
+program.parse(process.argv);

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "triage-trip",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Autonomous CLI to pinpoint and patch regressions introduced by AI code assistants",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node test/patch.test.js"
   },
   "keywords": [
     "cursor",

package/src/git.js

@@ -1,4 +1,6 @@
 import { simpleGit } from 'simple-git';
+import fs from 'fs';
+import path from 'path';
 
 const git = simpleGit();
 
@@ -13,7 +15,126 @@ function sanitizeDiff(diffStr, maxChars = 4000) {
   return diffStr;
 }
 
-export async function getRecentChanges(maxCommits = 3) {
+const BINARY_EXTENSIONS = new Set([
+  '.gif', '.png', '.jpg', '.jpeg', '.cast', '.ico', '.pdf', '.zip',
+  '.tar', '.gz', '.db', '.sqlite', '.sqlite3', '.bin', '.wasm'
+]);
+
+/**
+ * Collects active working copy text for relevant files with line numbers.
+ * Gives the LLM exact source of truth for current file state, eliminating hallucinated diffs.
+ */
+function collectActiveFiles(status, commitDiffs, errorInput = '', maxFiles = 5) {
+  const candidates = new Set();
+
+  // 1. Extract file paths from error input / stack trace
+  if (errorInput) {
+    const fileMatches = errorInput.match(/(?:[a-zA-Z0-9_\-\.\/]+\/)?([a-zA-Z0-9_\-\.]+\.[a-zA-Z0-9]+)/g) || [];
+    for (const match of fileMatches) {
+      const cleanPath = match.replace(/^(?:file:\/\/\/|\/)/, '');
+      candidates.add(cleanPath);
+      candidates.add(path.basename(cleanPath));
+    }
+  }
+
+  // 2. Working tree files from git status
+  const statusFiles = [
+    ...(status.modified || []),
+    ...(status.staged || []),
+    ...(status.created || []),
+    ...(status.not_added || []),
+  ];
+  for (const f of statusFiles) candidates.add(f);
+
+  // 3. Files from latest commit diff
+  if (commitDiffs.length > 0 && commitDiffs[0].diff) {
+    const diffFiles = commitDiffs[0].diff.match(/(?:---|\+\+\+)\s+[ab]\/([^\s\n]+)/g) || [];
+    for (const df of diffFiles) {
+      const p = df.replace(/^(?:---|\+\+\+)\s+[ab]\//, '');
+      candidates.add(p);
+    }
+  }
+
+  const activeFiles = {};
+  let count = 0;
+
+  for (const candidate of candidates) {
+    if (count >= maxFiles) break;
+
+    // Resolve file
+    let fullPath = path.resolve(process.cwd(), candidate);
+    if (!fs.existsSync(fullPath)) {
+      // Try resolving by basename in workspace
+      const baseName = path.basename(candidate);
+      const found = findCandidateFile(process.cwd(), baseName);
+      if (found) fullPath = found;
+      else continue;
+    }
+
+    const ext = path.extname(fullPath).toLowerCase();
+    if (BINARY_EXTENSIONS.has(ext)) continue;
+    if (fullPath.includes('node_modules') || fullPath.includes('.git')) continue;
+
+    try {
+      const stat = fs.statSync(fullPath);
+      if (!stat.isFile() || stat.size > 50000) continue;
+
+      const content = fs.readFileSync(fullPath, 'utf8');
+      const relPath = path.relative(process.cwd(), fullPath);
+
+      const lines = content.split('\n');
+      const formatted = lines
+        .slice(0, 150)
+        .map((line, idx) => `${idx + 1}| ${line}`)
+        .join('\n');
+
+      activeFiles[relPath] = formatted;
+      count++;
+
+      // Also inspect relative local imports for JS/TS
+      if (['.js', '.ts', '.jsx', '.tsx', '.mjs'].includes(ext)) {
+        const importMatches = content.match(/(?:import|require)\s*\(?['"](\.[^'"]+)['"]/g) || [];
+        for (const imp of importMatches) {
+          const importRel = imp.match(/['"](\.[^'"]+)['"]/)?.[1];
+          if (importRel) {
+            const dir = path.dirname(fullPath);
+            let importedPath = path.resolve(dir, importRel);
+            if (!fs.existsSync(importedPath) && fs.existsSync(importedPath + '.js')) {
+              importedPath = importedPath + '.js';
+            }
+            if (fs.existsSync(importedPath) && !activeFiles[path.relative(process.cwd(), importedPath)]) {
+              candidates.add(path.relative(process.cwd(), importedPath));
+            }
+          }
+        }
+      }
+    } catch {}
+  }
+
+  return activeFiles;
+}
+
+function findCandidateFile(dir, baseName, depth = 0) {
+  if (depth > 4) return null;
+  const ignored = new Set(['node_modules', '.git', 'dist', 'build', '.cache', 'coverage']);
+
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const ent of entries) {
+      if (ent.isDirectory()) {
+        if (!ignored.has(ent.name)) {
+          const found = findCandidateFile(path.join(dir, ent.name), baseName, depth + 1);
+          if (found) return found;
+        }
+      } else if (ent.isFile() && ent.name === baseName) {
+        return path.join(dir, ent.name);
+      }
+    }
+  } catch {}
+  return null;
+}
+
+export async function getRecentChanges(maxCommits = 3, errorInput = '') {
   const isRepo = await git.checkIsRepo();
   if (!isRepo) {
     throw new Error('Not inside a valid Git repository.');
@@ -27,6 +148,9 @@ export async function getRecentChanges(maxCommits = 3) {
     ':!yarn.lock',
     ':!pnpm-lock.yaml',
     ':!bun.lockb',
+    ':!assets/*',
+    ':!*.gif',
+    ':!*.cast',
   ];
 
   const unstagedDiff = await git.diff(['--', '.', ...lockfileIgnores]);
@@ -58,10 +182,13 @@ export async function getRecentChanges(maxCommits = 3) {
     })
   );
 
+  const activeFileContents = collectActiveFiles(status, commitDiffs, errorInput);
+
   return {
     branch: status.current,
-    untrackedFiles: status.not_added, // Tells the LLM if newly created files exist
+    untrackedFiles: status.not_added,
     workingDiff: sanitizeDiff(combinedWorkingDiff) || null,
     recentCommits: commitDiffs,
+    activeFileContents,
   };
-}
+}

package/src/patch.js

@@ -1,65 +1,597 @@
-// src/patch.js
+import { spawn } from 'child_process';
 import fs from 'fs';
 import path from 'path';
-import { spawn } from 'child_process';
+import { parse } from '@babel/parser';
+import traversePkg from '@babel/traverse';
+
+const traverse = traversePkg.default?.default || traversePkg.default || traversePkg;
 
+/**
+ * Extracts unified diff text from LLM response.
+ * Handles markdown fences (```diff, ```patch, generic ```), raw diffs, and cleans common noise.
+ */
 export function extractDiff(llmOutput) {
-  const diffMatch =
-    llmOutput.match(/```diff\s*([\s\S]*?)```/) ||
-    llmOutput.match(/(--- [^\n]+\n\+\+\+ [^\n]+[\s\S]*)/);
+  if (!llmOutput || typeof llmOutput !== 'string') return null;
+
+  // 1. Try markdown code block markers
+  const fenceMatch =
+    llmOutput.match(/```(?:diff|patch)\s*([\s\S]*?)```/i) ||
+    llmOutput.match(/```\s*\n(--- [^\n]+\n\+\+\+ [^\n]+[\s\S]*?)```/) ||
+    llmOutput.match(/```\s*\n(diff --git [^\n]+[\s\S]*?)```/);
+
+  let raw = '';
+  if (fenceMatch) {
+    raw = fenceMatch[1];
+  } else {
+    // 2. Try raw unified diff pattern
+    const rawMatch =
+      llmOutput.match(/(diff --git a\/[^\n]+ b\/[^\n]+[\s\S]*)/) ||
+      llmOutput.match(/(--- [^\n]+\n\+\+\+ [^\n]+[\s\S]*)/);
+    if (rawMatch) {
+      raw = rawMatch[1];
+    } else {
+      return null;
+    }
+  }
+
+  // Clean non-breaking spaces and Windows newlines
+  raw = raw.replace(/\u00A0/g, ' ').replace(/\r\n/g, '\n');
+
+  // Strip git index metadata lines if malformed
+  raw = raw.replace(/^index [0-9a-f]+\.\.[0-9a-f]+.*$\n?/gm, '');
+
+  if (!raw.endsWith('\n')) raw += '\n';
+
+  return raw.trim() + '\n';
+}
 
-  if (!diffMatch) return null;
-  let rawDiff = diffMatch[1] || diffMatch[0];
+/**
+ * Normalizes diff headers and recounts hunk lines (@@ -oldStart,oldCount +newStart,newCount @@).
+ * LLMs frequently miscount lines in the hunk header, which causes git apply to fail.
+ */
+export function normalizeDiff(diffString) {
+  if (!diffString) return '';
+  const cleaned = diffString.replace(/\u00A0/g, ' ').replace(/\r\n/g, '\n');
+  const lines = cleaned.split('\n');
+  const result = [];
 
-  rawDiff = rawDiff.replace(/\u00A0/g, ' ').replace(/\r\n/g, '\n');
-  rawDiff = rawDiff.replace(/^index [0-9a-f]+\.\.[0-9a-f]+.*$\n?/m, '');
+  let currentHunkIdx = -1;
+  let oldCount = 0;
+  let newCount = 0;
+  let inHunk = false;
+  let oldStart = 1;
+  let newStart = 1;
+  let hunkHeaderExtra = '';
 
-  if (!rawDiff.endsWith('\n')) {
-    rawDiff += '\n';
+  function finalizeHunk() {
+    if (currentHunkIdx >= 0) {
+      result[currentHunkIdx] = `@@ -${oldStart},${oldCount} +${newStart},${newCount} @@${hunkHeaderExtra}`;
+    }
   }
 
-  return rawDiff.trim() + '\n';
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Normalize header paths: ensure standard a/ and b/ prefixes
+    if (line.startsWith('--- ') && !line.startsWith('--- a/') && !line.startsWith('--- /dev/null')) {
+      const p = line.slice(4).trim().replace(/^([ab]\/|\.\/)/, '');
+      result.push(`--- a/${p}`);
+      continue;
+    }
+    if (line.startsWith('+++ ') && !line.startsWith('+++ b/') && !line.startsWith('+++ /dev/null')) {
+      const p = line.slice(4).trim().replace(/^([ab]\/|\.\/)/, '');
+      result.push(`+++ b/${p}`);
+      continue;
+    }
+
+    const hunkMatch = line.match(/^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@(.*)$/);
+    if (hunkMatch) {
+      finalizeHunk();
+      oldStart = hunkMatch[1];
+      newStart = hunkMatch[2];
+      hunkHeaderExtra = hunkMatch[3] || '';
+      oldCount = 0;
+      newCount = 0;
+      inHunk = true;
+      currentHunkIdx = result.length;
+      result.push(line);
+      continue;
+    }
+
+    if (inHunk) {
+      if (line.startsWith('--- ') || line.startsWith('diff --git')) {
+        finalizeHunk();
+        inHunk = false;
+        currentHunkIdx = -1;
+        result.push(line);
+      } else if (line.startsWith('-')) {
+        oldCount++;
+        result.push(line);
+      } else if (line.startsWith('+')) {
+        newCount++;
+        result.push(line);
+      } else if (line.startsWith(' ') || line === '') {
+        oldCount++;
+        newCount++;
+        result.push(line === '' ? ' ' : line);
+      } else if (line.startsWith('\\')) {
+        // e.g. 
+        result.push(line);
+      } else {
+        finalizeHunk();
+        inHunk = false;
+        currentHunkIdx = -1;
+        result.push(line);
+      }
+    } else {
+      result.push(line);
+    }
+  }
+
+  finalizeHunk();
+  return result.join('\n').trim() + '\n';
 }
 
-export async function applyDiff(diffString) {
-  const flags = [
-    '--recount',
-    '--ignore-space-change',
-    '--ignore-whitespace',
-    '--whitespace=nowarn',
-    '-C1'
-  ];
+/**
+ * Validates syntax of patched content to prevent breaking the workspace with unparseable code.
+ */
+export function validateSyntax(filePath, content) {
+  const ext = path.extname(filePath).toLowerCase();
+
+  if (['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs'].includes(ext)) {
+    try {
+      parse(content, {
+        sourceType: 'module',
+        plugins: ['jsx', 'typescript'],
+      });
+      return { valid: true };
+    } catch (err) {
+      return { valid: false, error: err.message };
+    }
+  }
+
+  if (ext === '.json') {
+    try {
+      JSON.parse(content);
+      return { valid: true };
+    } catch (err) {
+      return { valid: false, error: err.message };
+    }
+  }
+
+  return { valid: true };
+}
+
+/**
+ * Parses a unified diff string into structured file patches and hunks.
+ */
+export function parseUnifiedDiff(diffString) {
+  const files = [];
+  const lines = diffString.split('\n');
+  let currentFile = null;
+  let currentHunk = null;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    if (line.startsWith('--- ')) {
+      const rawPath = line.slice(4).trim().split('\t')[0];
+      const oldPath = rawPath.replace(/^(?:a\/|\.\/)/, '');
+      currentFile = {
+        oldPath,
+        newPath: '',
+        isNew: rawPath === '/dev/null' || rawPath === 'dev/null',
+        isDeleted: false,
+        hunks: [],
+      };
+      files.push(currentFile);
+      currentHunk = null;
+      continue;
+    }
+
+    if (line.startsWith('+++ ') && currentFile) {
+      const rawPath = line.slice(4).trim().split('\t')[0];
+      currentFile.newPath = rawPath.replace(/^(?:b\/|\.\/)/, '');
+      currentFile.isDeleted = rawPath === '/dev/null' || rawPath === 'dev/null';
+      continue;
+    }
+
+    const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+    if (hunkMatch && currentFile) {
+      currentHunk = {
+        oldStart: parseInt(hunkMatch[1], 10),
+        oldCount: parseInt(hunkMatch[2] || '1', 10),
+        newStart: parseInt(hunkMatch[3], 10),
+        newCount: parseInt(hunkMatch[4] || '1', 10),
+        rawLines: [],
+        oldLines: [],
+        newLines: [],
+        removed: [],
+        added: [],
+      };
+      currentFile.hunks.push(currentHunk);
+      continue;
+    }
+
+    if (currentHunk) {
+      if (line.startsWith('-')) {
+        currentHunk.rawLines.push(line);
+        currentHunk.oldLines.push(line.slice(1));
+        currentHunk.removed.push(line.slice(1));
+      } else if (line.startsWith('+')) {
+        currentHunk.rawLines.push(line);
+        currentHunk.newLines.push(line.slice(1));
+        currentHunk.added.push(line.slice(1));
+      } else if (line.startsWith(' ') || line === '') {
+        const text = line.startsWith(' ') ? line.slice(1) : line;
+        currentHunk.rawLines.push(line);
+        currentHunk.oldLines.push(text);
+        currentHunk.newLines.push(text);
+      }
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Resolves a file path from a diff to an actual file on disk.
+ */
+function resolveFilePath(targetRelPath) {
+  if (!targetRelPath || targetRelPath === '/dev/null') return null;
+
+  // 1. Direct path from cwd
+  const directPath = path.resolve(process.cwd(), targetRelPath);
+  if (fs.existsSync(directPath)) return directPath;
+
+  // 2. Search workspace for matching basename (avoiding noisy directories)
+  const baseName = path.basename(targetRelPath);
+  const found = findFileByBasename(process.cwd(), baseName);
+  if (found) return found;
+
+  return directPath; // return unresolved direct path for creation or not-found handling
+}
+
+function findFileByBasename(dir, targetName, depth = 0) {
+  if (depth > 5) return null;
+  const ignored = new Set(['node_modules', '.git', 'dist', 'build', '.cache', 'coverage']);
+
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const ent of entries) {
+      if (ent.isDirectory()) {
+        if (!ignored.has(ent.name)) {
+          const res = findFileByBasename(path.join(dir, ent.name), targetName, depth + 1);
+          if (res) return res;
+        }
+      } else if (ent.isFile() && ent.name === targetName) {
+        return path.join(dir, ent.name);
+      }
+    }
+  } catch {}
+  return null;
+}
+
+/**
+ * Computes fast token-based similarity between two lines.
+ */
+function lineTokenSimilarity(a, b) {
+  const s1 = a.trim().toLowerCase();
+  const s2 = b.trim().toLowerCase();
+  if (s1 === s2) return 1.0;
+  if (!s1 || !s2) return 0.0;
+
+  const t1 = s1.split(/[^a-z0-9_$]+/i).filter(Boolean);
+  const t2 = s2.split(/[^a-z0-9_$]+/i).filter(Boolean);
+  if (t1.length === 0 || t2.length === 0) return 0.0;
+
+  let matches = 0;
+  const set2 = new Set(t2);
+  for (const t of t1) {
+    if (set2.has(t)) matches++;
+  }
+  return (2 * matches) / (t1.length + t2.length);
+}
+
+/**
+ * Applies a hunk to an array of file lines using progressive matching tiers.
+ * Returns { success: boolean, updatedLines: string[] }.
+ */
+function applyHunkToLines(fileLines, hunk, targetFilePath) {
+  const oldLines = hunk.oldLines;
+  const newLines = hunk.newLines;
+  const removed = hunk.removed;
+  const added = hunk.added;
+
+  // --- Tier 1: Exact oldLines (context + removed) match ---
+  if (oldLines.length > 0) {
+    for (let i = 0; i <= fileLines.length - oldLines.length; i++) {
+      let match = true;
+      for (let j = 0; j < oldLines.length; j++) {
+        if (fileLines[i + j] !== oldLines[j]) {
+          match = false;
+          break;
+        }
+      }
+      if (match) {
+        const updated = [...fileLines.slice(0, i), ...newLines, ...fileLines.slice(i + oldLines.length)];
+        return { success: true, updatedLines: updated };
+      }
+    }
+  }
+
+  // --- Tier 2: Exact removed-only lines match (ignoring context) ---
+  if (removed.length > 0) {
+    for (let i = 0; i <= fileLines.length - removed.length; i++) {
+      let match = true;
+      for (let j = 0; j < removed.length; j++) {
+        if (fileLines[i + j] !== removed[j]) {
+          match = false;
+          break;
+        }
+      }
+      if (match) {
+        const updated = [...fileLines.slice(0, i), ...added, ...fileLines.slice(i + removed.length)];
+        return { success: true, updatedLines: updated };
+      }
+    }
+  }
+
+  // --- Tier 3: Whitespace & indentation normalized match ---
+  if (oldLines.length > 0) {
+    const normOld = oldLines.map((l) => l.trim());
+    for (let i = 0; i <= fileLines.length - normOld.length; i++) {
+      let match = true;
+      for (let j = 0; j < normOld.length; j++) {
+        if (fileLines[i + j].trim() !== normOld[j]) {
+          match = false;
+          break;
+        }
+      }
+      if (match) {
+        // Adapt indentation from original lines
+        const indentMatch = fileLines[i].match(/^\s*/);
+        const baseIndent = indentMatch ? indentMatch[0] : '';
+        const adaptedNew = newLines.map((l) => {
+          if (l.trim().length === 0) return '';
+          const diffIndent = l.match(/^\s*/)?.[0] || '';
+          return diffIndent ? l : baseIndent + l;
+        });
+        const updated = [...fileLines.slice(0, i), ...adaptedNew, ...fileLines.slice(i + normOld.length)];
+        return { success: true, updatedLines: updated };
+      }
+    }
+  }
+
+  // --- Tier 4: Case-insensitive & token similarity match ---
+  // Covers cases like `profile.userID` vs `profile.userid` vs `profile.userId`
+  if (removed.length > 0) {
+    let bestIdx = -1;
+    let bestScore = 0;
+
+    for (let i = 0; i <= fileLines.length - removed.length; i++) {
+      let totalSim = 0;
+      for (let j = 0; j < removed.length; j++) {
+        const sim = lineTokenSimilarity(fileLines[i + j], removed[j]);
+        totalSim += sim;
+      }
+      const avgSim = totalSim / removed.length;
+      if (avgSim > bestScore) {
+        bestScore = avgSim;
+        bestIdx = i;
+      }
+    }
+
+    if (bestScore >= 0.75 && bestIdx >= 0) {
+      const indentMatch = fileLines[bestIdx].match(/^\s*/);
+      const baseIndent = indentMatch ? indentMatch[0] : '';
+
+      const adaptedAdded = added.map((l) => {
+        if (l.trim().length === 0) return '';
+        const curIndent = l.match(/^\s*/)?.[0] || '';
+        return curIndent ? l : baseIndent + l;
+      });
+
+      const updated = [...fileLines.slice(0, bestIdx), ...adaptedAdded, ...fileLines.slice(bestIdx + removed.length)];
+      return { success: true, updatedLines: updated };
+    }
+  }
+
+  // --- Tier 5: AST-guided MemberExpression / Identifier rename for JS/TS ---
+  const ext = path.extname(targetFilePath).toLowerCase();
+  if (['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs'].includes(ext) && removed.length === 1 && added.length === 1) {
+    const astResult = tryAstMemberRename(fileLines.join('\n'), removed[0], added[0]);
+    if (astResult.success) {
+      return { success: true, updatedLines: astResult.code.split('\n') };
+    }
+  }
+
+  return { success: false };
+}
 
-  // 1. Try git apply
-  const attempt = await runGitApply(diffString, flags);
-  if (attempt.success) return true;
+/**
+ * Uses Babel AST traversal to pinpoint and rename member expressions (e.g. profile.userid -> profile.user_id).
+ */
+function tryAstMemberRename(code, removedLine, addedLine) {
+  try {
+    const oldPropMatch = removedLine.match(/([a-zA-Z0-9_$]+)\.([a-zA-Z0-9_$]+)/);
+    const newPropMatch = addedLine.match(/([a-zA-Z0-9_$]+)\.([a-zA-Z0-9_$]+)/);
 
-  // 2. Try git apply with 3way
-  const attempt3Way = await runGitApply(diffString, [...flags, '--3way']);
-  if (attempt3Way.success) return true;
+    if (!oldPropMatch || !newPropMatch) return { success: false };
+    const objName = oldPropMatch[1];
+    const oldProp = oldPropMatch[2];
+    const newProp = newPropMatch[2];
 
-  // 3. Fallback: Direct line search & replace on disk
-  const applied = fallbackManualPatch(diffString);
-  if (applied) return true;
+    const ast = parse(code, { sourceType: 'module', plugins: ['jsx', 'typescript'] });
+    let replaced = false;
+    let newCode = code;
 
-  throw new Error(`Patch cannot apply cleanly:\n${attempt.stderr}`);
+    traverse(ast, {
+      MemberExpression(p) {
+        if (
+          !replaced &&
+          p.node.object?.type === 'Identifier' &&
+          p.node.object.name === objName &&
+          p.node.property?.type === 'Identifier' &&
+          p.node.property.name.toLowerCase() === oldProp.toLowerCase()
+        ) {
+          const start = p.node.property.start;
+          const end = p.node.property.end;
+          newCode = newCode.slice(0, start) + newProp + newCode.slice(end);
+          replaced = true;
+          p.stop();
+        }
+      },
+    });
+
+    return { success: replaced, code: newCode };
+  } catch {
+    return { success: false };
+  }
 }
 
+/**
+ * Semantic Fallback Patcher: Applies parsed diff directly to files on disk with atomic rollback.
+ * Guarantees zero false positives: if no files are changed or any file fails, rolls back completely.
+ */
+export async function applySemanticFallback(diffString) {
+  const filePatches = parseUnifiedDiff(diffString);
+  if (filePatches.length === 0) {
+    throw new Error('No valid file hunks could be parsed from the diff.');
+  }
+
+  const backups = new Map(); // filePath -> originalContent
+  const createdFiles = new Set();
+  const modifiedFiles = [];
+
+  try {
+    for (const patchObj of filePatches) {
+      const targetRelPath = patchObj.newPath || patchObj.oldPath;
+      const targetPath = resolveFilePath(targetRelPath);
+
+      // 1. Handle new file creation
+      if (patchObj.isNew) {
+        const fullNewPath = targetPath || path.resolve(process.cwd(), targetRelPath);
+        const dir = path.dirname(fullNewPath);
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+        const newContent = patchObj.hunks.flatMap((h) => h.added).join('\n') + '\n';
+        const syntaxCheck = validateSyntax(fullNewPath, newContent);
+        if (!syntaxCheck.valid) {
+          throw new Error(`Proposed new file '${targetRelPath}' has a syntax error: ${syntaxCheck.error}`);
+        }
+
+        fs.writeFileSync(fullNewPath, newContent, 'utf8');
+        createdFiles.add(fullNewPath);
+        modifiedFiles.push(targetRelPath);
+        continue;
+      }
+
+      // 2. Handle file deletion
+      if (patchObj.isDeleted) {
+        if (fs.existsSync(targetPath)) {
+          backups.set(targetPath, fs.readFileSync(targetPath, 'utf8'));
+          fs.unlinkSync(targetPath);
+          modifiedFiles.push(targetRelPath);
+        }
+        continue;
+      }
+
+      // 3. Handle file modification
+      if (!targetPath || !fs.existsSync(targetPath)) {
+        throw new Error(`Target file not found in repository: ${targetRelPath}`);
+      }
+
+      const originalContent = fs.readFileSync(targetPath, 'utf8');
+      backups.set(targetPath, originalContent);
+
+      const hasCrlf = originalContent.includes('\r\n');
+      const normalizedOriginal = originalContent.replace(/\r\n/g, '\n');
+      let currentLines = normalizedOriginal.split('\n');
+
+      let anyHunkApplied = false;
+
+      for (const hunk of patchObj.hunks) {
+        const hunkRes = applyHunkToLines(currentLines, hunk, targetPath);
+        if (hunkRes.success) {
+          currentLines = hunkRes.updatedLines;
+          anyHunkApplied = true;
+        } else {
+          // Check if already applied
+          const alreadyContainsAdded = hunk.added.length > 0 && hunk.added.every((l) => normalizedOriginal.includes(l.trim()));
+          if (alreadyContainsAdded) {
+            continue;
+          }
+          throw new Error(
+            `Patch hunk at line ${hunk.oldStart} could not be matched to any code in '${targetRelPath}'.`
+          );
+        }
+      }
+
+      let updatedContent = currentLines.join(hasCrlf ? '\r\n' : '\n');
+
+      // Verify actual content modification
+      if (updatedContent === originalContent) {
+        // If content did not change, check if diff was already applied
+        const alreadyApplied = patchObj.hunks.some((h) =>
+          h.added.length > 0 && h.added.every((l) => originalContent.includes(l.trim()))
+        );
+        if (alreadyApplied) {
+          continue; // File already has the fix
+        }
+        throw new Error(`Patch resulted in no changes to '${targetRelPath}'.`);
+      }
+
+      // Validate syntax before committing to disk
+      const syntaxCheck = validateSyntax(targetPath, updatedContent);
+      if (!syntaxCheck.valid) {
+        throw new Error(`Proposed patch introduces a syntax error in '${targetRelPath}': ${syntaxCheck.error}`);
+      }
+
+      fs.writeFileSync(targetPath, updatedContent, 'utf8');
+      modifiedFiles.push(targetRelPath);
+    }
+
+    if (modifiedFiles.length === 0) {
+      throw new Error('Patch was already applied or resulted in no changes to working tree.');
+    }
+
+    return { success: true, method: 'semantic-fallback', modifiedFiles };
+  } catch (err) {
+    // Atomic Rollback: Restore all modified files from backups
+    for (const [filePath, content] of backups.entries()) {
+      try {
+        fs.writeFileSync(filePath, content, 'utf8');
+      } catch {}
+    }
+    // Remove any created files
+    for (const createdPath of createdFiles) {
+      try {
+        if (fs.existsSync(createdPath)) fs.unlinkSync(createdPath);
+      } catch {}
+    }
+    throw err;
+  }
+}
+
+/**
+ * Spawns git apply with given command-line flags.
+ */
 function runGitApply(diffContent, flags = []) {
   return new Promise((resolve) => {
     const git = spawn('git', ['apply', ...flags, '-'], {
-      stdio: ['pipe', 'pipe', 'pipe']
+      stdio: ['pipe', 'pipe', 'pipe'],
     });
 
     let stderr = '';
-    git.stderr.on('data', (chunk) => {
-      stderr += chunk.toString();
+    git.stderr.on('data', (d) => {
+      stderr += d.toString();
     });
 
     git.on('close', (code) => {
       resolve({
         success: code === 0,
-        stderr: stderr.trim()
+        stderr: stderr.trim(),
       });
     });
 
@@ -68,53 +600,110 @@ function runGitApply(diffContent, flags = []) {
   });
 }
 
-function fallbackManualPatch(diffString) {
-  try {
-    const fileMatch = diffString.match(/\+\+\+ b\/(.+)/);
-    if (!fileMatch) return false;
-
-    const relativePath = fileMatch[1].trim();
-    const filePath = path.resolve(process.cwd(), relativePath);
-    if (!fs.existsSync(filePath)) return false;
+/**
+ * Main patch application entry point.
+ * Tries progressive Git Apply strategies, then falls back to Semantic Fallback Patcher.
+ * Guarantees syntax validation and atomic rollback on errors.
+ */
+export async function applyDiff(diffString) {
+  if (!diffString || typeof diffString !== 'string' || !diffString.trim()) {
+    throw new Error('No valid diff provided to apply.');
+  }
 
-    const fileContent = fs.readFileSync(filePath, 'utf8');
+  const normalized = normalizeDiff(diffString);
 
-    // Extract removed (-) and added (+) lines from the hunk
-    const lines = diffString.split('\n');
-    let oldLine = null;
-    let newLine = null;
+  // Snapshot target file mtimes to verify Git apply actually touched files
+  const filePatches = parseUnifiedDiff(normalized);
+  const targetPaths = filePatches
+    .map((p) => resolveFilePath(p.newPath || p.oldPath))
+    .filter(Boolean);
 
-    for (const line of lines) {
-      if (line.startsWith('-') && !line.startsWith('---')) {
-        oldLine = line.slice(1).trim();
-      } else if (line.startsWith('+') && !line.startsWith('+++')) {
-        newLine = line.slice(1).trim();
-      }
+  const initialContents = new Map();
+  for (const p of targetPaths) {
+    if (fs.existsSync(p)) {
+      initialContents.set(p, fs.readFileSync(p, 'utf8'));
     }
+  }
 
-    if (!oldLine || !newLine) return false;
+  // Strategy 1: Git apply with whitespace and recount adjustments
+  const strat1 = await runGitApply(normalized, ['-p1', '--recount', '--whitespace=fix', '-C1']);
+  if (strat1.success && verifyAndValidateGitApply(targetPaths, initialContents)) {
+    return { success: true, method: 'git-apply-recount' };
+  }
 
-    // Scan file lines and replace the matching content while preserving original indentation
-    const fileLines = fileContent.split('\n');
-    let replaced = false;
+  // Strategy 2: Git apply with relaxed whitespace
+  const strat2 = await runGitApply(normalized, [
+    '-p1',
+    '--ignore-space-change',
+    '--ignore-whitespace',
+    '--recount',
+    '-C1',
+  ]);
+  if (strat2.success && verifyAndValidateGitApply(targetPaths, initialContents)) {
+    return { success: true, method: 'git-apply-ignore-whitespace' };
+  }
 
-    for (let i = 0; i < fileLines.length; i++) {
-      if (fileLines[i].includes(oldLine)) {
-        const indentMatch = fileLines[i].match(/^\s*/);
-        const indent = indentMatch ? indentMatch[0] : '';
-        fileLines[i] = indent + newLine;
-        replaced = true;
-        break;
+  // Strategy 3: Git apply with zero context
+  const strat3 = await runGitApply(normalized, [
+    '-p1',
+    '--unidiff-zero',
+    '-C0',
+    '--ignore-space-change',
+    '--ignore-whitespace',
+  ]);
+  if (strat3.success && verifyAndValidateGitApply(targetPaths, initialContents)) {
+    return { success: true, method: 'git-apply-unidiff-zero' };
+  }
+
+  // Strategy 4: Git apply with -p0
+  const strat4 = await runGitApply(normalized, ['-p0', '--recount', '--whitespace=fix']);
+  if (strat4.success && verifyAndValidateGitApply(targetPaths, initialContents)) {
+    return { success: true, method: 'git-apply-p0' };
+  }
+
+  // Strategy 5: Git 3-way merge
+  const strat5 = await runGitApply(normalized, ['-3', '--recount', '--whitespace=fix']);
+  if (strat5.success && verifyAndValidateGitApply(targetPaths, initialContents)) {
+    return { success: true, method: 'git-apply-3way' };
+  }
+
+  // Rollback any partial/broken git apply attempt before semantic fallback
+  for (const [p, content] of initialContents.entries()) {
+    try {
+      if (fs.existsSync(p)) fs.writeFileSync(p, content, 'utf8');
+    } catch {}
+  }
+
+  // Strategy 6: Intelligent Semantic Fallback Patcher
+  return await applySemanticFallback(normalized);
+}
+
+/**
+ * Verifies that git apply actually modified the target files and did not produce syntax errors.
+ */
+function verifyAndValidateGitApply(targetPaths, initialContents) {
+  let anyModified = false;
+
+  for (const p of targetPaths) {
+    if (!fs.existsSync(p)) continue;
+    let curContent = fs.readFileSync(p, 'utf8');
+    const initContent = initialContents.get(p);
+
+    if (initContent !== undefined && curContent !== initContent) {
+      // If original file had CRLF line endings, ensure CRLF is preserved consistently
+      const origHadCrlf = initContent.includes('\r\n');
+      if (origHadCrlf) {
+        curContent = curContent.replace(/\r?\n/g, '\r\n');
+        fs.writeFileSync(p, curContent, 'utf8');
       }
-    }
 
-    if (replaced) {
-      fs.writeFileSync(filePath, fileLines.join('\n'), 'utf8');
-      return true;
+      anyModified = true;
+      const syntax = validateSyntax(p, curContent);
+      if (!syntax.valid) {
+        return false; // Reject git apply if syntax error introduced
+      }
     }
-
-    return false;
-  } catch {
-    return false;
   }
-}
+
+  return anyModified;
+}

package/src/triage.js

@@ -23,24 +23,52 @@ When generating the "Patch" section:
 - Ensure @@ -line,count +line,count @@ markers accurately match the context.
 - Include 1-2 lines of unchanged surrounding context above and below the change.
 - Only touch lines that actually exist in the file.
-- Do not invent comments in context lines.
+- Match the exact current text and casing from the active working file on disk as the '-' (removed) lines.
 `.trim();
 
+  const activeFilesSection = gitContext.activeFileContents && Object.keys(gitContext.activeFileContents).length > 0
+    ? `Active Working Files on Disk (Current File Contents & Line Numbers):\n${JSON.stringify(gitContext.activeFileContents, null, 2)}`
+    : '';
+
   const userPrompt = `
 User problem / error trace:
 "${errorDescription}"
 
+${activeFilesSection}
+
 Recent Cursor Composer Prompts:
 ${JSON.stringify(cursorPrompts, null, 2)}
 
 Recent Repository Git Stream (Working diff + Commits):
-${JSON.stringify(gitContext, null, 2)}
+${JSON.stringify({
+  branch: gitContext.branch,
+  untrackedFiles: gitContext.untrackedFiles,
+  workingDiff: gitContext.workingDiff,
+  recentCommits: gitContext.recentCommits,
+}, null, 2)}
 
 Provide a strict, concise triage output formatted with terminal-friendly Markdown:
 1. **Root Cause**: Pinpoint the file, line, and commit/working diff where the breaking change occurred.
 2. **Attributed Prompt**: Name the specific Cursor prompt that likely caused this diff (if found in the list; otherwise state none).
 3. **The Shift**: Explain what broke (e.g., schema key rename, dropped parameter, async/await omission).
 4. **Patch**: Provide the exact unified diff adhering strictly to the system diff formatting instructions.
+
+CRITICAL RULES FOR THE PATCH:
+- The '-' (removed) lines MUST match the EXACT text and casing currently in the file shown in "Active Working Files on Disk".
+- Target the file accurately:
+  --- a/<path>
+  +++ b/<path>
+- Never delete the entire file. The patch must FIX the bug in the existing file.
+- Format strictly as a valid unified diff block in \`\`\`diff.
+- Only change the breaking line(s). Keep 1-2 lines of unchanged surrounding context lines above and below without '+' or '-'.
+- Example format:
+\`\`\`diff
+--- a/app.js
++++ b/app.js
+@@ -6,3 +6,3 @@
+-  console.log(\`Loading dashboard for user ID: \${profile.userid.toUpperCase()}\`);
++  console.log(\`Loading dashboard for user ID: \${profile.user_id.toUpperCase()}\`);
+\`\`\`
 `;
 
   // 1. Prefer Anthropic if key exists
@@ -66,4 +94,4 @@ Provide a strict, concise triage output formatted with terminal-friendly Markdow
     ]
   });
   return response.choices[0].message.content;
-}
+}