@j0hanz/code-review-analyst-mcp 1.6.4 → 1.7.1

package/README.md

@@ -12,13 +12,13 @@ Gemini-powered MCP server for pull request analysis with structured outputs for
 
 ## Overview
 
-This server accepts unified diffs and returns structured JSON results — findings with severity, impact categories, merge risk, test plans, and verbatim search/replace fixes. It uses Gemini Thinking models (Flash for fast tools, Pro for deep analysis) and runs over **stdio transport**.
+This server accepts unified diffs and returns structured JSON results — findings with severity, impact categories, merge risk, test plans, and verbatim search/replace fixes. It uses Gemini Thinking models (Flash for fast tools, Flash for deep analysis) and runs over **stdio transport**.
 
 ## Key Features
 
 - **Impact Analysis** — Objective severity scoring, breaking change detection, and rollback complexity assessment.
 - **Review Summary** — Concise PR digest with merge recommendation and change statistics.
-- **Deep Code Inspection** — Pro model with high thinking level for context-aware analysis using full file contents.
+- **Deep Code Inspection** — Flash model with high thinking level for context-aware analysis using full file contents.
 - **Search & Replace Fixes** — Verbatim, copy-paste-ready code fixes tied to specific findings.
 - **Test Plan Generation** — Systematic test case generation with priority ranking and pseudocode.
 - **Async Task Support** — All tools support MCP task lifecycle with progress notifications.
@@ -279,13 +279,25 @@ docker build -t code-review-analyst-mcp .
 
 ## Tools
 
+> [!IMPORTANT]
+> Call `generate_diff` first (`mode: "unstaged"` or `"staged"`). All review tools read the cached server-side diff (`diff://current`) and do not accept a direct `diff` parameter.
+
+### `generate_diff`
+
+Generate and cache the current branch diff for downstream review tools.
+
+| Parameter | Type     | Required | Description                                        |
+| --------- | -------- | -------- | -------------------------------------------------- |
+| `mode`    | `string` | Yes      | `unstaged` (working tree) or `staged` (git index). |
+
+**Returns:** `diffRef`, `stats` (files, added, deleted), `generatedAt`, `mode`, `message`.
+
 ### `analyze_pr_impact`
 
-Assess the impact and risk of a pull request diff using the Flash model.
+Assess the impact and risk of cached pull request changes using the Flash model.
 
 | Parameter    | Type     | Required | Description                              |
 | ------------ | -------- | -------- | ---------------------------------------- |
-| `diff`       | `string` | Yes      | Unified diff text.                       |
 | `repository` | `string` | Yes      | Repository identifier (e.g. `org/repo`). |
 | `language`   | `string` | No       | Primary language hint.                   |
 
@@ -297,7 +309,6 @@ Summarize a pull request diff and assess high-level risk using the Flash model.
 
 | Parameter    | Type     | Required | Description                              |
 | ------------ | -------- | -------- | ---------------------------------------- |
-| `diff`       | `string` | Yes      | Unified diff text.                       |
 | `repository` | `string` | Yes      | Repository identifier (e.g. `org/repo`). |
 | `language`   | `string` | No       | Primary language hint.                   |
 
@@ -305,11 +316,10 @@ Summarize a pull request diff and assess high-level risk using the Flash model.
 
 ### `inspect_code_quality`
 
-Deep-dive code review using the Pro model with thinking (16K token budget).
+Deep-dive code review using the Flash model with high thinking (16K token budget).
 
 | Parameter     | Type       | Required | Description                                   |
 | ------------- | ---------- | -------- | --------------------------------------------- |
-| `diff`        | `string`   | Yes      | Unified diff text.                            |
 | `repository`  | `string`   | Yes      | Repository identifier (e.g. `org/repo`).      |
 | `language`    | `string`   | No       | Primary language hint.                        |
 | `focusAreas`  | `string[]` | No       | Areas to inspect: security, correctness, etc. |
@@ -322,11 +332,10 @@ Deep-dive code review using the Pro model with thinking (16K token budget).
 
 ### `suggest_search_replace`
 
-Generate verbatim search-and-replace blocks to fix a specific finding using the Pro model with thinking.
+Generate verbatim search-and-replace blocks to fix a specific finding using the Flash model with high thinking.
 
 | Parameter        | Type     | Required | Description                              |
 | ---------------- | -------- | -------- | ---------------------------------------- |
-| `diff`           | `string` | Yes      | Unified diff that contains the issue.    |
 | `findingTitle`   | `string` | Yes      | Short title of the finding to fix.       |
 | `findingDetails` | `string` | Yes      | Detailed explanation of the bug or risk. |
 
@@ -338,7 +347,6 @@ Create a test plan covering the changes in the diff using the Flash model with t
 
 | Parameter       | Type     | Required | Description                                 |
 | --------------- | -------- | -------- | ------------------------------------------- |
-| `diff`          | `string` | Yes      | Unified diff to generate tests for.         |
 | `repository`    | `string` | Yes      | Repository identifier (e.g. `org/repo`).    |
 | `language`      | `string` | No       | Primary language hint.                      |
 | `testFramework` | `string` | No       | Test framework (e.g. jest, vitest, pytest). |
@@ -391,8 +399,8 @@ Create a test plan covering the changes in the diff using the Flash model with t
 | ------------------------- | ------------------------ | -------------- |
 | `analyze_pr_impact`       | `gemini-3-flash-preview` | `minimal`      |
 | `generate_review_summary` | `gemini-3-flash-preview` | `minimal`      |
-| `inspect_code_quality`    | `gemini-3-pro-preview`   | `high`         |
-| `suggest_search_replace`  | `gemini-3-pro-preview`   | `high`         |
+| `inspect_code_quality`    | `gemini-3-flash-preview` | `high`         |
+| `suggest_search_replace`  | `gemini-3-flash-preview` | `high`         |
 | `generate_test_plan`      | `gemini-3-flash-preview` | `medium`       |
 
 ## Workflows
@@ -456,7 +464,7 @@ The pipeline runs lint, type-check, test, and build, then publishes to three tar
 | ------------------------------------------ | ------------------------------------------------------------------------------------ |
 | `Missing GEMINI_API_KEY or GOOGLE_API_KEY` | Set one of the API key env vars in your MCP client config.                           |
 | `E_INPUT_TOO_LARGE`                        | Diff exceeds budget. Split into smaller diffs.                                       |
-| `Gemini request timed out`                 | Pro model tasks may take 60-120s. Increase your client timeout.                      |
+| `Gemini request timed out`                 | Deep analysis tasks may take 60-120s. Increase your client timeout.                  |
 | `Too many concurrent Gemini calls`         | Reduce parallel tool calls or increase `MAX_CONCURRENT_CALLS`.                       |
 | No tool output visible                     | Ensure your MCP client is not swallowing `stderr` — the server uses stdio transport. |
 

package/dist/lib/diff-store.d.ts

@@ -2,6 +2,7 @@ import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { ParsedFile } from './diff.js';
 import { createErrorToolResponse } from './tool-response.js';
 export declare const DIFF_RESOURCE_URI = "diff://current";
+export declare const diffStaleWarningMs: import("./env-config.js").CachedEnvInt;
 export interface DiffStats {
     files: number;
     added: number;

package/dist/lib/diff-store.js

@@ -3,6 +3,8 @@ import { createErrorToolResponse } from './tool-response.js';
 export const DIFF_RESOURCE_URI = 'diff://current';
 const diffCacheTtlMs = createCachedEnvInt('DIFF_CACHE_TTL_MS', 60 * 60 * 1_000 // 1 hour default
 );
+export const diffStaleWarningMs = createCachedEnvInt('DIFF_STALE_WARNING_MS', 5 * 60 * 1_000 // 5 minutes default
+);
 const diffSlots = new Map();
 let sendResourceUpdated;
 function setDiffSlot(key, data) {

package/dist/lib/gemini.js

@@ -38,6 +38,8 @@ const DIGITS_ONLY_PATTERN = /^\d+$/;
 const TRUE_ENV_VALUES = new Set(['1', 'true', 'yes', 'on']);
 const FALSE_ENV_VALUES = new Set(['0', 'false', 'no', 'off']);
 const SLEEP_UNREF_OPTIONS = { ref: false };
+const JSON_CODE_BLOCK_PATTERN = /```(?:json)?\n?([\s\S]*?)(?=\n?```)/u;
+const NEVER_ABORT_SIGNAL = new AbortController().signal;
 const maxConcurrentCallsConfig = createCachedEnvInt('MAX_CONCURRENT_CALLS', 10);
 const maxConcurrentBatchCallsConfig = createCachedEnvInt('MAX_CONCURRENT_BATCH_CALLS', 2);
 const concurrencyWaitMsConfig = createCachedEnvInt('MAX_CONCURRENT_CALLS_WAIT_MS', 2_000);
@@ -45,8 +47,8 @@ const batchPollIntervalMsConfig = createCachedEnvInt('GEMINI_BATCH_POLL_INTERVAL
 const batchTimeoutMsConfig = createCachedEnvInt('GEMINI_BATCH_TIMEOUT_MS', 120_000);
 let activeCalls = 0;
 let activeBatchCalls = 0;
-const slotWaiters = [];
-const batchSlotWaiters = [];
+const slotWaiters = new Set();
+const batchSlotWaiters = new Set();
 const RETRYABLE_TRANSIENT_CODES = new Set([
     'RESOURCE_EXHAUSTED',
     'UNAVAILABLE',
@@ -54,6 +56,36 @@ const RETRYABLE_TRANSIENT_CODES = new Set([
     'INTERNAL',
     'ABORTED',
 ]);
+function getWaiterCount(waiters) {
+    return waiters instanceof Set ? waiters.size : waiters.length;
+}
+function addWaiter(waiters, waiter) {
+    if (waiters instanceof Set) {
+        waiters.add(waiter);
+        return;
+    }
+    waiters.push(waiter);
+}
+function removeWaiter(waiters, waiter) {
+    if (waiters instanceof Set) {
+        waiters.delete(waiter);
+        return;
+    }
+    const index = waiters.indexOf(waiter);
+    if (index !== -1) {
+        waiters.splice(index, 1);
+    }
+}
+function popNextWaiter(waiters) {
+    if (waiters instanceof Set) {
+        const next = waiters.values().next().value;
+        if (next !== undefined) {
+            waiters.delete(next);
+        }
+        return next;
+    }
+    return waiters.shift();
+}
 const SAFETY_CATEGORIES = [
     HarmCategory.HARM_CATEGORY_HATE_SPEECH,
     HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
@@ -371,7 +403,7 @@ function parseStructuredResponse(responseText) {
     catch {
         // fast-path failed; try extracting from markdown block
     }
-    const jsonMatch = /```(?:json)?\n?([\s\S]*?)(?=\n?```)/u.exec(responseText);
+    const jsonMatch = JSON_CODE_BLOCK_PATTERN.exec(responseText);
     const jsonText = jsonMatch?.[1] ?? responseText;
     try {
         return JSON.parse(jsonText);
@@ -501,13 +533,13 @@ function canRetryAttempt(attempt, maxRetries, error) {
     return attempt < maxRetries && shouldRetry(error);
 }
 function tryWakeNextWaiter() {
-    const next = slotWaiters.shift();
+    const next = popNextWaiter(slotWaiters);
     if (next !== undefined) {
         next();
     }
 }
 async function waitForSlot(limit, getActiveCount, acquireSlot, waiters, requestSignal) {
-    if (waiters.length === 0 && getActiveCount() < limit) {
+    if (getWaiterCount(waiters) === 0 && getActiveCount() < limit) {
         acquireSlot();
         return;
     }
@@ -526,12 +558,9 @@ async function waitForSlot(limit, getActiveCount, acquireSlot, waiters, requestS
             acquireSlot();
             resolve();
         };
-        waiters.push(waiter);
-        const removeWaiter = () => {
-            const idx = waiters.indexOf(waiter);
-            if (idx !== -1) {
-                waiters.splice(idx, 1);
-            }
+        addWaiter(waiters, waiter);
+        const removeCurrentWaiter = () => {
+            removeWaiter(waiters, waiter);
         };
         const detachAbortListener = () => {
             if (requestSignal) {
@@ -542,7 +571,7 @@ async function waitForSlot(limit, getActiveCount, acquireSlot, waiters, requestS
             if (settled)
                 return;
             settled = true;
-            removeWaiter();
+            removeCurrentWaiter();
             detachAbortListener();
             reject(new Error(formatConcurrencyLimitErrorMessage(limit, waitLimitMs)));
         }, waitLimitMs);
@@ -551,7 +580,7 @@ async function waitForSlot(limit, getActiveCount, acquireSlot, waiters, requestS
             if (settled)
                 return;
             settled = true;
-            removeWaiter();
+            removeCurrentWaiter();
             clearTimeout(deadlineTimer);
             reject(new Error('Gemini request was cancelled.'));
         };
@@ -566,7 +595,7 @@ async function waitForConcurrencySlot(limit, requestSignal) {
     }, slotWaiters, requestSignal);
 }
 function tryWakeNextBatchWaiter() {
-    const next = batchSlotWaiters.shift();
+    const next = popNextWaiter(batchSlotWaiters);
     if (next !== undefined) {
         next();
     }
@@ -718,12 +747,13 @@ async function runInlineBatchWithPolling(request, model, onLog) {
     let completed = false;
     let timedOut = false;
     try {
+        const createSignal = request.signal ?? NEVER_ABORT_SIGNAL;
         const createPayload = {
             model,
             src: [
                 {
                     contents: [{ role: 'user', parts: [{ text: request.prompt }] }],
-                    config: buildGenerationConfig(request, new AbortController().signal),
+                    config: buildGenerationConfig(request, createSignal),
                 },
             ],
         };
@@ -770,7 +800,7 @@ async function runInlineBatchWithPolling(request, model, onLog) {
 export function getGeminiQueueSnapshot() {
     return {
         activeCalls,
-        waitingCalls: slotWaiters.length,
+        waitingCalls: slotWaiters.size,
     };
 }
 export async function generateStructuredJson(request) {
@@ -793,7 +823,7 @@ export async function generateStructuredJson(request) {
     await safeCallOnLog(onLog, 'info', {
         event: 'gemini_queue_acquired',
         queueWaitMs,
-        waitingCalls: batchMode === 'inline' ? batchSlotWaiters.length : slotWaiters.length,
+        waitingCalls: batchMode === 'inline' ? batchSlotWaiters.size : slotWaiters.size,
         activeCalls,
         activeBatchCalls,
         mode: batchMode,

package/dist/lib/model-config.d.ts

@@ -1,34 +1,32 @@
 /** Fast, cost-effective model for summarization and light analysis. */
 export declare const FLASH_MODEL = "gemini-3-flash-preview";
-/** High-capability model for deep reasoning, quality inspection, and reliable code generation. */
-export declare const PRO_MODEL = "gemini-3-pro-preview";
 /** Default language hint. */
 export declare const DEFAULT_LANGUAGE = "detect";
 /** Default test-framework hint. */
 export declare const DEFAULT_FRAMEWORK = "detect";
-/** Extended timeout for Pro model calls (ms). */
-export declare const DEFAULT_TIMEOUT_PRO_MS = 120000;
+/** Extended timeout for deep analysis calls (ms). */
+export declare const DEFAULT_TIMEOUT_EXTENDED_MS = 120000;
 export declare const MODEL_TIMEOUT_MS: {
-    readonly defaultPro: 120000;
+    readonly extended: 120000;
 };
 /** Thinking level for Flash triage. */
 export declare const FLASH_TRIAGE_THINKING_LEVEL: "minimal";
 /** Thinking level for Flash analysis. */
 export declare const FLASH_THINKING_LEVEL: "medium";
-/** Thinking level for Pro deep analysis. */
-export declare const PRO_THINKING_LEVEL: "high";
+/** Thinking level for Flash deep analysis. */
+export declare const FLASH_HIGH_THINKING_LEVEL: "high";
 /** Output cap for Flash API breaking-change detection. */
-export declare const FLASH_API_BREAKING_MAX_OUTPUT_TOKENS: 4096;
+export declare const FLASH_API_BREAKING_MAX_OUTPUT_TOKENS = 65536;
 /** Output cap for Flash complexity analysis. */
-export declare const FLASH_COMPLEXITY_MAX_OUTPUT_TOKENS: 4096;
+export declare const FLASH_COMPLEXITY_MAX_OUTPUT_TOKENS = 65536;
 /** Output cap for Flash test-plan generation. */
-export declare const FLASH_TEST_PLAN_MAX_OUTPUT_TOKENS: 8192;
+export declare const FLASH_TEST_PLAN_MAX_OUTPUT_TOKENS = 65536;
 /** Output cap for Flash triage tools. */
-export declare const FLASH_TRIAGE_MAX_OUTPUT_TOKENS: 4096;
-/** Output cap for Pro patch generation. */
-export declare const PRO_PATCH_MAX_OUTPUT_TOKENS: 8192;
-/** Output cap for Pro deep review findings. */
-export declare const PRO_REVIEW_MAX_OUTPUT_TOKENS: 12288;
+export declare const FLASH_TRIAGE_MAX_OUTPUT_TOKENS = 65536;
+/** Output cap for Flash patch generation. */
+export declare const FLASH_PATCH_MAX_OUTPUT_TOKENS = 65536;
+/** Output cap for Flash deep review findings. */
+export declare const FLASH_REVIEW_MAX_OUTPUT_TOKENS = 65536;
 /** Temperature for analytical tools. */
 export declare const ANALYSIS_TEMPERATURE: 1;
 /** Temperature for creative synthesis (test plans). */

package/dist/lib/model-config.js

@@ -1,15 +1,13 @@
 /** Fast, cost-effective model for summarization and light analysis. */
 export const FLASH_MODEL = 'gemini-3-flash-preview';
-/** High-capability model for deep reasoning, quality inspection, and reliable code generation. */
-export const PRO_MODEL = 'gemini-3-pro-preview';
 /** Default language hint. */
 export const DEFAULT_LANGUAGE = 'detect';
 /** Default test-framework hint. */
 export const DEFAULT_FRAMEWORK = 'detect';
-/** Extended timeout for Pro model calls (ms). */
-export const DEFAULT_TIMEOUT_PRO_MS = 120_000;
+/** Extended timeout for deep analysis calls (ms). */
+export const DEFAULT_TIMEOUT_EXTENDED_MS = 120_000;
 export const MODEL_TIMEOUT_MS = {
-    defaultPro: DEFAULT_TIMEOUT_PRO_MS,
+    extended: DEFAULT_TIMEOUT_EXTENDED_MS,
 };
 Object.freeze(MODEL_TIMEOUT_MS);
 // ---------------------------------------------------------------------------
@@ -21,35 +19,28 @@ const THINKING_LEVELS = {
     /** Medium thinking for analysis tasks. */
     flash: 'medium',
     /** High thinking for deep review and patches. */
-    pro: 'high',
-};
-// Thinking budget in tokens for Flash and Pro tools. Note that these are not hard limits, but rather guidelines to encourage concise responses and manage latency/cost.
-const OUTPUT_TOKEN_BUDGET = {
-    flashApiBreaking: 4_096,
-    flashComplexity: 4_096,
-    flashTestPlan: 8_192,
-    flashTriage: 4_096,
-    proPatch: 8_192,
-    proReview: 12_288,
+    flashHigh: 'high',
 };
 /** Thinking level for Flash triage. */
 export const FLASH_TRIAGE_THINKING_LEVEL = THINKING_LEVELS.flashTriage;
 /** Thinking level for Flash analysis. */
 export const FLASH_THINKING_LEVEL = THINKING_LEVELS.flash;
-/** Thinking level for Pro deep analysis. */
-export const PRO_THINKING_LEVEL = THINKING_LEVELS.pro;
+/** Thinking level for Flash deep analysis. */
+export const FLASH_HIGH_THINKING_LEVEL = THINKING_LEVELS.flashHigh;
+// Output token caps for various tools. Set to a high default to avoid cutting off important information, but can be adjusted as needed.
+const DEFAULT_OUTPUT_CAP = 65_536;
 /** Output cap for Flash API breaking-change detection. */
-export const FLASH_API_BREAKING_MAX_OUTPUT_TOKENS = OUTPUT_TOKEN_BUDGET.flashApiBreaking;
+export const FLASH_API_BREAKING_MAX_OUTPUT_TOKENS = DEFAULT_OUTPUT_CAP;
 /** Output cap for Flash complexity analysis. */
-export const FLASH_COMPLEXITY_MAX_OUTPUT_TOKENS = OUTPUT_TOKEN_BUDGET.flashComplexity;
+export const FLASH_COMPLEXITY_MAX_OUTPUT_TOKENS = DEFAULT_OUTPUT_CAP;
 /** Output cap for Flash test-plan generation. */
-export const FLASH_TEST_PLAN_MAX_OUTPUT_TOKENS = OUTPUT_TOKEN_BUDGET.flashTestPlan;
+export const FLASH_TEST_PLAN_MAX_OUTPUT_TOKENS = DEFAULT_OUTPUT_CAP;
 /** Output cap for Flash triage tools. */
-export const FLASH_TRIAGE_MAX_OUTPUT_TOKENS = OUTPUT_TOKEN_BUDGET.flashTriage;
-/** Output cap for Pro patch generation. */
-export const PRO_PATCH_MAX_OUTPUT_TOKENS = OUTPUT_TOKEN_BUDGET.proPatch;
-/** Output cap for Pro deep review findings. */
-export const PRO_REVIEW_MAX_OUTPUT_TOKENS = OUTPUT_TOKEN_BUDGET.proReview;
+export const FLASH_TRIAGE_MAX_OUTPUT_TOKENS = DEFAULT_OUTPUT_CAP;
+/** Output cap for Flash patch generation. */
+export const FLASH_PATCH_MAX_OUTPUT_TOKENS = DEFAULT_OUTPUT_CAP;
+/** Output cap for Flash deep review findings. */
+export const FLASH_REVIEW_MAX_OUTPUT_TOKENS = DEFAULT_OUTPUT_CAP;
 // ---------------------------------------------------------------------------
 // Temperatures
 // ---------------------------------------------------------------------------

package/dist/lib/tool-contracts.d.ts

@@ -57,7 +57,7 @@ export declare const TOOL_CONTRACTS: readonly [{
     readonly model: "gemini-3-flash-preview";
     readonly timeoutMs: 90000;
     readonly thinkingLevel: "minimal";
-    readonly maxOutputTokens: 4096;
+    readonly maxOutputTokens: 65536;
     readonly temperature: 1;
     readonly deterministicJson: true;
     readonly params: readonly [{
@@ -82,7 +82,7 @@ export declare const TOOL_CONTRACTS: readonly [{
     readonly model: "gemini-3-flash-preview";
     readonly timeoutMs: 90000;
     readonly thinkingLevel: "minimal";
-    readonly maxOutputTokens: 4096;
+    readonly maxOutputTokens: 65536;
     readonly temperature: 1;
     readonly deterministicJson: true;
     readonly params: readonly [{
@@ -104,10 +104,10 @@ export declare const TOOL_CONTRACTS: readonly [{
 }, {
     readonly name: "inspect_code_quality";
     readonly purpose: "Deep code review over the cached diff.";
-    readonly model: "gemini-3-pro-preview";
+    readonly model: "gemini-3-flash-preview";
     readonly timeoutMs: 120000;
     readonly thinkingLevel: "high";
-    readonly maxOutputTokens: 12288;
+    readonly maxOutputTokens: 65536;
     readonly temperature: 1;
     readonly deterministicJson: true;
     readonly params: readonly [{
@@ -142,10 +142,10 @@ export declare const TOOL_CONTRACTS: readonly [{
 }, {
     readonly name: "suggest_search_replace";
     readonly purpose: "Generate verbatim search/replace fix blocks for one finding.";
-    readonly model: "gemini-3-pro-preview";
+    readonly model: "gemini-3-flash-preview";
     readonly timeoutMs: 120000;
     readonly thinkingLevel: "high";
-    readonly maxOutputTokens: 8192;
+    readonly maxOutputTokens: 65536;
     readonly temperature: 1;
     readonly deterministicJson: true;
     readonly params: readonly [{
@@ -171,7 +171,7 @@ export declare const TOOL_CONTRACTS: readonly [{
     readonly model: "gemini-3-flash-preview";
     readonly timeoutMs: 90000;
     readonly thinkingLevel: "medium";
-    readonly maxOutputTokens: 8192;
+    readonly maxOutputTokens: 65536;
     readonly temperature: 1;
     readonly deterministicJson: true;
     readonly params: readonly [{
@@ -208,7 +208,7 @@ export declare const TOOL_CONTRACTS: readonly [{
     readonly model: "gemini-3-flash-preview";
     readonly timeoutMs: 90000;
     readonly thinkingLevel: "medium";
-    readonly maxOutputTokens: 4096;
+    readonly maxOutputTokens: 65536;
     readonly temperature: 1;
     readonly deterministicJson: true;
     readonly params: readonly [{
@@ -227,7 +227,7 @@ export declare const TOOL_CONTRACTS: readonly [{
     readonly model: "gemini-3-flash-preview";
     readonly timeoutMs: 90000;
     readonly thinkingLevel: "minimal";
-    readonly maxOutputTokens: 4096;
+    readonly maxOutputTokens: 65536;
     readonly temperature: 1;
     readonly deterministicJson: true;
     readonly params: readonly [{

package/dist/lib/tool-contracts.js

@@ -1,4 +1,4 @@
-import { ANALYSIS_TEMPERATURE, CREATIVE_TEMPERATURE, DEFAULT_TIMEOUT_PRO_MS, FLASH_API_BREAKING_MAX_OUTPUT_TOKENS, FLASH_COMPLEXITY_MAX_OUTPUT_TOKENS, FLASH_MODEL, FLASH_TEST_PLAN_MAX_OUTPUT_TOKENS, FLASH_THINKING_LEVEL, FLASH_TRIAGE_MAX_OUTPUT_TOKENS, FLASH_TRIAGE_THINKING_LEVEL, PATCH_TEMPERATURE, PRO_MODEL, PRO_PATCH_MAX_OUTPUT_TOKENS, PRO_REVIEW_MAX_OUTPUT_TOKENS, PRO_THINKING_LEVEL, TRIAGE_TEMPERATURE, } from './model-config.js';
+import { ANALYSIS_TEMPERATURE, CREATIVE_TEMPERATURE, DEFAULT_TIMEOUT_EXTENDED_MS, FLASH_API_BREAKING_MAX_OUTPUT_TOKENS, FLASH_COMPLEXITY_MAX_OUTPUT_TOKENS, FLASH_HIGH_THINKING_LEVEL, FLASH_MODEL, FLASH_PATCH_MAX_OUTPUT_TOKENS, FLASH_REVIEW_MAX_OUTPUT_TOKENS, FLASH_TEST_PLAN_MAX_OUTPUT_TOKENS, FLASH_THINKING_LEVEL, FLASH_TRIAGE_MAX_OUTPUT_TOKENS, FLASH_TRIAGE_THINKING_LEVEL, PATCH_TEMPERATURE, TRIAGE_TEMPERATURE, } from './model-config.js';
 const DEFAULT_TIMEOUT_FLASH_MS = 90_000;
 export const INSPECTION_FOCUS_AREAS = [
     'security',
@@ -119,10 +119,10 @@ export const TOOL_CONTRACTS = [
     {
         name: 'inspect_code_quality',
         purpose: 'Deep code review over the cached diff.',
-        model: PRO_MODEL,
-        timeoutMs: DEFAULT_TIMEOUT_PRO_MS,
-        thinkingLevel: PRO_THINKING_LEVEL,
-        maxOutputTokens: PRO_REVIEW_MAX_OUTPUT_TOKENS,
+        model: FLASH_MODEL,
+        timeoutMs: DEFAULT_TIMEOUT_EXTENDED_MS,
+        thinkingLevel: FLASH_HIGH_THINKING_LEVEL,
+        maxOutputTokens: FLASH_REVIEW_MAX_OUTPUT_TOKENS,
         temperature: ANALYSIS_TEMPERATURE,
         deterministicJson: true,
         params: [
@@ -169,10 +169,10 @@ export const TOOL_CONTRACTS = [
     {
         name: 'suggest_search_replace',
         purpose: 'Generate verbatim search/replace fix blocks for one finding.',
-        model: PRO_MODEL,
-        timeoutMs: DEFAULT_TIMEOUT_PRO_MS,
-        thinkingLevel: PRO_THINKING_LEVEL,
-        maxOutputTokens: PRO_PATCH_MAX_OUTPUT_TOKENS,
+        model: FLASH_MODEL,
+        timeoutMs: DEFAULT_TIMEOUT_EXTENDED_MS,
+        thinkingLevel: FLASH_HIGH_THINKING_LEVEL,
+        maxOutputTokens: FLASH_PATCH_MAX_OUTPUT_TOKENS,
         temperature: PATCH_TEMPERATURE,
         deterministicJson: true,
         params: [

package/dist/lib/tool-factory.d.ts

@@ -1,4 +1,3 @@
-import type { CreateTaskRequestHandlerExtra } from '@modelcontextprotocol/sdk/experimental/tasks/interfaces.js';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { ZodRawShapeCompat } from '@modelcontextprotocol/sdk/server/zod-compat.js';
 import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
@@ -26,6 +25,11 @@ interface ProgressNotificationParams {
     total?: number;
     message?: string;
 }
+interface ProgressPayload {
+    current: number;
+    total?: number;
+    message?: string;
+}
 interface ProgressExtra {
     _meta?: {
         progressToken?: unknown;
@@ -66,8 +70,6 @@ export interface StructuredToolTaskConfig<TInput extends object = Record<string,
     requiresDiff?: boolean;
     /** Optional override for schema validation retries. Defaults to GEMINI_SCHEMA_RETRIES env var. */
     schemaRetries?: number;
-    /** Optional Gemini model to use (e.g. 'gemini-3-pro-preview'). */
-    model?: string;
     /** Optional thinking level. */
     thinkingLevel?: 'minimal' | 'low' | 'medium' | 'high';
     /** Optional timeout in ms for the Gemini call. Defaults to 90,000 ms. Use DEFAULT_TIMEOUT_PRO_MS for Pro model calls. */
@@ -101,27 +103,33 @@ export declare function wrapToolHandler<TInput, TResult extends CallToolResult>(
     toolName: string;
     progressContext?: (input: TInput) => string;
 }, handler: (input: TInput, extra: ProgressExtra) => Promise<TResult> | TResult): (input: TInput, extra: ProgressExtra) => Promise<TResult>;
-interface TaskLike {
-    taskId: string;
+interface TaskStatusReporter {
+    updateStatus: (message: string) => Promise<void>;
+    storeResult?: (status: 'completed' | 'failed', result: CallToolResult) => Promise<void>;
 }
-export declare class ToolTaskRunner<TInput extends object, TResult extends object, TFinal extends TResult> {
-    private readonly server;
+export declare class ToolExecutionRunner<TInput extends object, TResult extends object, TFinal extends TResult> {
     private readonly config;
-    private readonly extra;
-    private readonly task;
+    private readonly signal?;
     private diffSlotSnapshot;
     private hasSnapshot;
-    private readonly responseSchema;
+    private responseSchema;
     private readonly onLog;
     private readonly reportProgress;
+    private readonly statusReporter;
     private progressContext;
-    constructor(server: McpServer, config: StructuredToolTaskConfig<TInput, TResult, TFinal>, extra: CreateTaskRequestHandlerExtra, task: TaskLike);
+    private lastStatusMessage;
+    constructor(config: StructuredToolTaskConfig<TInput, TResult, TFinal>, dependencies: {
+        onLog: (level: string, data: unknown) => Promise<void>;
+        reportProgress: (payload: ProgressPayload) => Promise<void>;
+        statusReporter: TaskStatusReporter;
+    }, signal?: AbortSignal | undefined);
+    setResponseSchemaOverride(responseSchema: Record<string, unknown>): void;
     setDiffSlotSnapshot(diffSlotSnapshot: DiffSlot | undefined): void;
     private updateStatusMessage;
     private storeResultSafely;
     private executeValidation;
     private executeModelCall;
-    run(input: unknown): Promise<void>;
+    run(input: unknown): Promise<CallToolResult>;
 }
 export declare function registerStructuredToolTask<TInput extends object, TResult extends object = Record<string, unknown>, TFinal extends TResult = TResult>(server: McpServer, config: StructuredToolTaskConfig<TInput, TResult, TFinal>): void;
 export {};

package/dist/lib/tool-factory.js

@@ -1,13 +1,12 @@
 import { z } from 'zod';
 import { DefaultOutputSchema } from '../schemas/outputs.js';
-import { createNoDiffError, getDiff } from './diff-store.js';
+import { createNoDiffError, diffStaleWarningMs, getDiff, } from './diff-store.js';
 import { validateDiffBudget } from './diff.js';
 import { createCachedEnvInt } from './env-config.js';
 import { getErrorMessage, RETRYABLE_UPSTREAM_ERROR_PATTERN } from './errors.js';
 import { stripJsonSchemaConstraints } from './gemini-schema.js';
-import { generateStructuredJson, getCurrentRequestId } from './gemini.js';
+import { generateStructuredJson } from './gemini.js';
 import { createErrorToolResponse, createToolResponse, } from './tool-response.js';
-const DEFAULT_TASK_TTL_MS = 30 * 60 * 1_000;
 // Named progress step indices for 7-step progress (0–6).
 const STEP_STARTING = 0;
 const STEP_VALIDATING = 1;
@@ -28,6 +27,8 @@ const DEFAULT_SCHEMA_RETRY_ERROR_CHARS = 1_500;
 const schemaRetryErrorCharsConfig = createCachedEnvInt('MAX_SCHEMA_RETRY_ERROR_CHARS', DEFAULT_SCHEMA_RETRY_ERROR_CHARS);
 const DETERMINISTIC_JSON_RETRY_NOTE = 'Deterministic JSON mode: keep key names exactly as schema-defined and preserve stable field ordering.';
 const JSON_PARSE_ERROR_PATTERN = /model produced invalid json/i;
+const responseSchemaCache = new WeakMap();
+const progressReporterCache = new WeakMap();
 function buildToolAnnotations(annotations) {
     if (!annotations) {
         return {
@@ -49,6 +50,18 @@ function createGeminiResponseSchema(config) {
     const sourceSchema = config.geminiSchema ?? config.resultSchema;
     return stripJsonSchemaConstraints(z.toJSONSchema(sourceSchema));
 }
+function getCachedGeminiResponseSchema(config) {
+    const cached = responseSchemaCache.get(config);
+    if (cached) {
+        return cached;
+    }
+    const responseSchema = createGeminiResponseSchema({
+        geminiSchema: config.geminiSchema,
+        resultSchema: config.resultSchema,
+    });
+    responseSchemaCache.set(config, responseSchema);
+    return responseSchema;
+}
 function parseToolInput(input, fullInputSchema) {
     return fullInputSchema.parse(input);
 }
@@ -92,9 +105,6 @@ function createGenerationRequest(config, promptParts, responseSchema, onLog, sig
         responseSchema,
         onLog,
     };
-    if (config.model !== undefined) {
-        request.model = config.model;
-    }
     if (config.thinkingLevel !== undefined) {
         request.thinkingLevel = config.thinkingLevel;
     }
@@ -165,24 +175,14 @@ function isRetryableUpstreamMessage(message) {
     return (RETRYABLE_UPSTREAM_ERROR_PATTERN.test(message) ||
         BUSY_ERROR_PATTERN.test(message));
 }
-function sendTaskProgress(extra, payload) {
+function createProgressReporter(extra) {
     const rawToken = extra._meta?.progressToken;
     if (typeof rawToken !== 'string' && typeof rawToken !== 'number') {
-        return Promise.resolve();
+        return async () => {
+            // Request did not provide a progress token.
+        };
     }
-    const params = {
-        progressToken: rawToken,
-        progress: payload.current,
-        ...(payload.total !== undefined ? { total: payload.total } : {}),
-        ...(payload.message !== undefined ? { message: payload.message } : {}),
-    };
-    return extra
-        .sendNotification({ method: 'notifications/progress', params })
-        .catch(() => {
-        // Progress notifications are best-effort; never fail tool execution.
-    });
-}
-function createProgressReporter(extra) {
+    const progressToken = rawToken;
     let lastCurrent = 0;
     let didSendTerminal = false;
     return async (payload) => {
@@ -200,13 +200,36 @@ function createProgressReporter(extra) {
         if (payload.message !== undefined) {
             progressPayload.message = payload.message;
         }
-        await sendTaskProgress(extra, progressPayload);
+        const params = {
+            progressToken,
+            progress: progressPayload.current,
+            ...(progressPayload.total !== undefined
+                ? { total: progressPayload.total }
+                : {}),
+            ...(progressPayload.message !== undefined
+                ? { message: progressPayload.message }
+                : {}),
+        };
+        await extra
+            .sendNotification({ method: 'notifications/progress', params })
+            .catch(() => {
+            // Progress notifications are best-effort; never fail tool execution.
+        });
         lastCurrent = current;
         if (total !== undefined && total === current) {
             didSendTerminal = true;
         }
     };
 }
+function getOrCreateProgressReporter(extra) {
+    const cached = progressReporterCache.get(extra);
+    if (cached) {
+        return cached;
+    }
+    const created = createProgressReporter(extra);
+    progressReporterCache.set(extra, created);
+    return created;
+}
 function normalizeProgressContext(context) {
     const compact = context?.replace(/\s+/g, ' ').trim();
     if (!compact) {
@@ -220,16 +243,6 @@ function normalizeProgressContext(context) {
 function formatProgressStep(toolName, context, metadata) {
     return `${toolName}: ${context} [${metadata}]`;
 }
-function friendlyModelName(model) {
-    if (!model)
-        return 'calling model';
-    const normalized = model.toLowerCase();
-    if (normalized.includes('pro'))
-        return 'calling Pro';
-    if (normalized.includes('flash'))
-        return 'calling Flash';
-    return 'calling model';
-}
 function formatProgressCompletion(toolName, context, outcome) {
     return `🗒 ${toolName}: ${context} • ${outcome}`;
 }
@@ -240,8 +253,10 @@ function createFailureStatusMessage(outcome, errorMessage) {
     return errorMessage;
 }
 async function sendSingleStepProgress(extra, toolName, context, current, state) {
-    await sendTaskProgress(extra, {
+    const reporter = getOrCreateProgressReporter(extra);
+    await reporter({
         current,
+        total: 1,
         message: current === 0
             ? formatProgressStep(toolName, context, state)
             : formatProgressCompletion(toolName, context, state),
@@ -288,32 +303,6 @@ function asObjectRecord(value) {
     }
     return { payload: value };
 }
-function createGeminiLogger(server, taskId) {
-    return async (level, data) => {
-        try {
-            await server.sendLoggingMessage({
-                level: toLoggingLevel(level),
-                logger: 'gemini',
-                data: {
-                    requestId: getCurrentRequestId(),
-                    taskId,
-                    ...asObjectRecord(data),
-                },
-            });
-        }
-        catch {
-            try {
-                const timestamp = new Date().toISOString();
-                const payload = JSON.stringify(asObjectRecord(data));
-                console.error(`[${timestamp}] [gemini:${level}] ${taskId} - ${payload}`);
-            }
-            catch {
-                // Safe fallback if JSON stringify fails
-                console.error(`[gemini:${level}] ${taskId} - (logging failed)`);
-            }
-        }
-    };
-}
 export function wrapToolHandler(options, handler) {
     return async (input, extra) => {
         const context = normalizeProgressContext(options.progressContext?.(input));
@@ -366,45 +355,52 @@ async function validateRequest(config, inputRecord, ctx) {
     }
     return undefined;
 }
-export class ToolTaskRunner {
-    server;
+export class ToolExecutionRunner {
     config;
-    extra;
-    task;
+    signal;
     diffSlotSnapshot;
     hasSnapshot = false;
     responseSchema;
     onLog;
     reportProgress;
+    statusReporter;
     progressContext;
-    constructor(server, config, extra, task) {
-        this.server = server;
+    lastStatusMessage;
+    constructor(config, dependencies, signal) {
         this.config = config;
-        this.extra = extra;
-        this.task = task;
-        this.responseSchema = createGeminiResponseSchema({
-            geminiSchema: config.geminiSchema,
-            resultSchema: config.resultSchema,
-        });
-        this.onLog = createGeminiLogger(server, task.taskId);
-        this.reportProgress = createProgressReporter(extra);
+        this.signal = signal;
+        this.responseSchema = getCachedGeminiResponseSchema(config);
+        this.onLog = dependencies.onLog;
+        this.reportProgress = dependencies.reportProgress;
+        this.statusReporter = dependencies.statusReporter;
         this.progressContext = DEFAULT_PROGRESS_CONTEXT;
     }
+    setResponseSchemaOverride(responseSchema) {
+        this.responseSchema = responseSchema;
+        responseSchemaCache.set(this.config, responseSchema);
+    }
     setDiffSlotSnapshot(diffSlotSnapshot) {
         this.diffSlotSnapshot = diffSlotSnapshot;
         this.hasSnapshot = true;
     }
     async updateStatusMessage(message) {
+        if (this.lastStatusMessage === message) {
+            return;
+        }
         try {
-            await this.extra.taskStore.updateTaskStatus(this.task.taskId, 'working', message);
+            await this.statusReporter.updateStatus(message);
+            this.lastStatusMessage = message;
         }
         catch {
             // Best-effort
         }
     }
     async storeResultSafely(status, result) {
+        if (!this.statusReporter.storeResult) {
+            return;
+        }
         try {
-            await this.extra.taskStore.storeTaskResult(this.task.taskId, status, result);
+            await this.statusReporter.storeResult(status, result);
         }
         catch (storeErr) {
             await this.onLog('error', {
@@ -432,9 +428,9 @@ export class ToolTaskRunner {
             await this.updateStatusMessage(validationMessage);
             await reportProgressCompletionUpdate(this.reportProgress, this.config.name, this.progressContext, 'rejected');
             await this.storeResultSafely('completed', validationError);
-            return false;
+            return validationError;
         }
-        return true;
+        return undefined;
     }
     async executeModelCall(systemInstruction, prompt) {
         let parsed;
@@ -442,7 +438,7 @@ export class ToolTaskRunner {
         const maxRetries = this.config.schemaRetries ?? geminiSchemaRetriesConfig.get();
         for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
             try {
-                const raw = await generateStructuredJson(createGenerationRequest(this.config, { systemInstruction, prompt: retryPrompt }, this.responseSchema, this.onLog, this.extra.signal));
+                const raw = await generateStructuredJson(createGenerationRequest(this.config, { systemInstruction, prompt: retryPrompt }, this.responseSchema, this.onLog, this.signal));
                 if (attempt === 0) {
                     await this.updateStatusMessage('validating response');
                     await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_VALIDATING_RESPONSE, 'validating response');
@@ -477,8 +473,6 @@ export class ToolTaskRunner {
         try {
             const inputRecord = parseToolInput(input, this.config.fullInputSchema);
             this.progressContext = normalizeProgressContext(this.config.progressContext?.(inputRecord));
-            // Prefer createTask snapshot; fallback preserves backward compatibility
-            // for any direct constructor callers.
             const ctx = {
                 diffSlot: this.hasSnapshot ? this.diffSlotSnapshot : getDiff(),
             };
@@ -486,82 +480,89 @@ export class ToolTaskRunner {
             await this.updateStatusMessage('starting');
             await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_VALIDATING, 'validating input');
             await this.updateStatusMessage('validating input');
-            if (!(await this.executeValidation(inputRecord, ctx))) {
-                return;
+            const validationError = await this.executeValidation(inputRecord, ctx);
+            if (validationError) {
+                return validationError;
             }
             await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_BUILDING_PROMPT, 'building prompt');
             await this.updateStatusMessage('building prompt');
             const promptParts = this.config.buildPrompt(inputRecord, ctx);
             const { prompt, systemInstruction } = promptParts;
-            const modelLabel = friendlyModelName(this.config.model);
-            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_CALLING_MODEL, modelLabel);
-            await this.updateStatusMessage(modelLabel);
+            await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_CALLING_MODEL, 'calling model');
+            await this.updateStatusMessage('calling model');
             const parsed = await this.executeModelCall(systemInstruction, prompt);
             await reportProgressStepUpdate(this.reportProgress, this.config.name, this.progressContext, STEP_FINALIZING, 'finalizing');
             await this.updateStatusMessage('finalizing');
             const finalResult = (this.config.transformResult
                 ? this.config.transformResult(inputRecord, parsed, ctx)
                 : parsed);
-            const textContent = this.config.formatOutput
+            let textContent = this.config.formatOutput
                 ? this.config.formatOutput(finalResult)
                 : undefined;
+            if (ctx.diffSlot) {
+                const ageMs = Date.now() - new Date(ctx.diffSlot.generatedAt).getTime();
+                if (ageMs > diffStaleWarningMs.get()) {
+                    const ageMinutes = Math.round(ageMs / 60_000);
+                    const warning = `\n\n⚠️ Warning: The analyzed diff is over ${ageMinutes} minutes old. If you have made recent changes, please run generate_diff again.`;
+                    textContent = textContent ? textContent + warning : warning;
+                }
+            }
             const outcome = this.config.formatOutcome?.(finalResult) ?? 'completed';
             await reportProgressCompletionUpdate(this.reportProgress, this.config.name, this.progressContext, outcome);
             await this.updateStatusMessage(`completed: ${outcome}`);
-            await this.storeResultSafely('completed', createToolResponse({
+            const successResponse = createToolResponse({
                 ok: true,
                 result: finalResult,
-            }, textContent));
+            }, textContent);
+            await this.storeResultSafely('completed', successResponse);
+            return successResponse;
         }
         catch (error) {
             const errorMessage = getErrorMessage(error);
             const errorMeta = classifyErrorMeta(error, errorMessage);
             const outcome = errorMeta.kind === 'cancelled' ? 'cancelled' : 'failed';
             await this.updateStatusMessage(createFailureStatusMessage(outcome, errorMessage));
-            await this.storeResultSafely('failed', createErrorToolResponse(this.config.errorCode, errorMessage, undefined, errorMeta));
+            const errorResponse = createErrorToolResponse(this.config.errorCode, errorMessage, undefined, errorMeta);
+            await this.storeResultSafely('failed', errorResponse);
             await reportProgressCompletionUpdate(this.reportProgress, this.config.name, this.progressContext, outcome);
+            return errorResponse; // Return safe error response
         }
     }
 }
 export function registerStructuredToolTask(server, config) {
-    server.experimental.tasks.registerToolTask(config.name, {
+    const responseSchema = createGeminiResponseSchema({
+        geminiSchema: config.geminiSchema,
+        resultSchema: config.resultSchema,
+    });
+    server.registerTool(config.name, {
         title: config.title,
         description: config.description,
         inputSchema: config.inputSchema,
         outputSchema: DefaultOutputSchema,
         annotations: buildToolAnnotations(config.annotations),
-    }, {
-        createTask: async (input, extra) => {
-            const task = await extra.taskStore.createTask({
-                ttl: extra.taskRequestedTtl ?? DEFAULT_TASK_TTL_MS,
-            });
-            const currentDiff = getDiff();
-            // Snapshot by reference: diff-store replaces slots on update, so this
-            // preserves task-level TOCTOU safety without deep-clone overhead.
-            const diffSlotSnapshot = currentDiff;
-            const runner = new ToolTaskRunner(server, config, extra, task);
-            runner.setDiffSlotSnapshot(diffSlotSnapshot);
-            setImmediate(() => {
-                void runner.run(input).catch(async (error) => {
-                    try {
-                        await server.sendLoggingMessage({
-                            level: 'error',
-                            logger: 'task-runner',
-                            data: { task: config.name, error: getErrorMessage(error) },
-                        });
-                    }
-                    catch {
-                        console.error(`[task-runner:${config.name}] ${getErrorMessage(error)}`);
-                    }
-                });
-            });
-            return { task };
-        },
-        getTask: async (_input, extra) => {
-            return await extra.taskStore.getTask(extra.taskId);
-        },
-        getTaskResult: async (_input, extra) => {
-            return (await extra.taskStore.getTaskResult(extra.taskId));
-        },
+    }, async (input, extra) => {
+        const runner = new ToolExecutionRunner(config, {
+            onLog: async (level, data) => {
+                // Standard logging for tool calls
+                try {
+                    await server.sendLoggingMessage({
+                        level: toLoggingLevel(level),
+                        logger: 'gemini',
+                        data: asObjectRecord(data),
+                    });
+                }
+                catch {
+                    // Fallback if logging fails
+                }
+            },
+            reportProgress: createProgressReporter(extra),
+            statusReporter: {
+                updateStatus: async () => {
+                    // No-op for standard tool calls as they don't have a persistent task status
+                },
+            },
+        });
+        runner.setResponseSchemaOverride(responseSchema);
+        return await runner.run(input);
     });
 }

package/dist/resources/index.js

@@ -83,7 +83,7 @@ function registerToolInfoResources(server) {
 }
 export const DIFF_RESOURCE_DESCRIPTION = 'The most recently generated diff, cached by generate_diff. Read by all review tools automatically.';
 function registerDiffResource(server) {
-    server.registerResource('diff-current', new ResourceTemplate(DIFF_RESOURCE_URI, { list: undefined }), {
+    server.registerResource('diff-current', DIFF_RESOURCE_URI, {
         title: 'Current Diff',
         description: DIFF_RESOURCE_DESCRIPTION,
         mimeType: PATCH_MIME_TYPE,

package/dist/resources/instructions.js

@@ -22,7 +22,7 @@ ${parameterLines.join('\n')}
 - **Output**: \`${contract.outputShape}\``;
     }
     const modelInfo = [
-        contract.model.includes('flash') ? 'Flash' : 'Pro',
+        'Flash',
         contract.thinkingLevel ? `Thinking:${contract.thinkingLevel}` : '',
         `${Math.round(contract.timeoutMs / 1_000)}s`,
         `MaxTokens:${contract.maxOutputTokens}`,

package/dist/resources/tool-catalog.js

@@ -26,8 +26,8 @@ generate_review_summary ──→ overallRisk ──────┤
 
 ## When to Use Each Tool
 
-- **Triage**: \`analyze_pr_impact\`, \`generate_review_summary\` (Flash).
-- **Inspection**: \`inspect_code_quality\` (Pro).
+- **Triage**: \`analyze_pr_impact\`, \`generate_review_summary\`.
+- **Inspection**: \`inspect_code_quality\`.
 - **Fixes**: \`suggest_search_replace\` (one finding/call).
 - **Tests**: \`generate_test_plan\`.
 - **Complexity**: \`analyze_time_space_complexity\`.

package/dist/tools/analyze-complexity.js

@@ -19,7 +19,6 @@ export function registerAnalyzeComplexityTool(server) {
         fullInputSchema: AnalyzeComplexityInputSchema,
         resultSchema: AnalyzeComplexityResultSchema,
         errorCode: 'E_ANALYZE_COMPLEXITY',
-        model: TOOL_CONTRACT.model,
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
         ...buildStructuredToolRuntimeOptions(TOOL_CONTRACT),

package/dist/tools/analyze-pr-impact.js

@@ -22,7 +22,6 @@ export function registerAnalyzePrImpactTool(server) {
         fullInputSchema: AnalyzePrImpactInputSchema,
         resultSchema: PrImpactResultSchema,
         errorCode: 'E_ANALYZE_IMPACT',
-        model: TOOL_CONTRACT.model,
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
         ...buildStructuredToolRuntimeOptions(TOOL_CONTRACT),

package/dist/tools/detect-api-breaking.js

@@ -19,7 +19,6 @@ export function registerDetectApiBreakingTool(server) {
         fullInputSchema: DetectApiBreakingInputSchema,
         resultSchema: DetectApiBreakingResultSchema,
         errorCode: 'E_DETECT_API_BREAKING',
-        model: TOOL_CONTRACT.model,
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
         ...buildStructuredToolRuntimeOptions(TOOL_CONTRACT),

package/dist/tools/generate-diff.js

@@ -9,12 +9,19 @@ import { DefaultOutputSchema } from '../schemas/outputs.js';
 const GIT_TIMEOUT_MS = 30_000;
 const GIT_MAX_BUFFER = 10 * 1024 * 1024; // 10 MB
 const execFileAsync = promisify(execFile);
-async function findGitRoot() {
+const gitRootByCwd = new Map();
+async function findGitRoot(cwd = process.cwd()) {
+    const cached = gitRootByCwd.get(cwd);
+    if (cached) {
+        return cached;
+    }
     const { stdout } = await execFileAsync('git', ['rev-parse', '--show-toplevel'], {
-        cwd: process.cwd(),
+        cwd,
         encoding: 'utf8',
     });
-    return stdout.trim();
+    const gitRoot = stdout.trim();
+    gitRootByCwd.set(cwd, gitRoot);
+    return gitRoot;
 }
 function buildGitArgs(mode) {
     const args = ['diff', '--no-color', '--no-ext-diff'];

package/dist/tools/generate-review-summary.js

@@ -36,7 +36,6 @@ export function registerGenerateReviewSummaryTool(server) {
         fullInputSchema: GenerateReviewSummaryInputSchema,
         resultSchema: ReviewSummaryModelSchema,
         errorCode: 'E_REVIEW_SUMMARY',
-        model: TOOL_CONTRACT.model,
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
         ...buildStructuredToolRuntimeOptions(TOOL_CONTRACT),

package/dist/tools/generate-test-plan.js

@@ -23,7 +23,6 @@ export function registerGenerateTestPlanTool(server) {
         fullInputSchema: GenerateTestPlanInputSchema,
         resultSchema: TestPlanResultSchema,
         errorCode: 'E_GENERATE_TEST_PLAN',
-        model: TOOL_CONTRACT.model,
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
         ...buildStructuredToolRuntimeOptions(TOOL_CONTRACT),

package/dist/tools/inspect-code-quality.js

@@ -28,7 +28,6 @@ export function registerInspectCodeQualityTool(server) {
         resultSchema: CodeQualityOutputSchema,
         geminiSchema: CodeQualityResultSchema,
         errorCode: 'E_INSPECT_QUALITY',
-        model: TOOL_CONTRACT.model,
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
         ...buildStructuredToolRuntimeOptions(TOOL_CONTRACT),

package/dist/tools/suggest-search-replace.js

@@ -23,7 +23,6 @@ export function registerSuggestSearchReplaceTool(server) {
         fullInputSchema: SuggestSearchReplaceInputSchema,
         resultSchema: SearchReplaceResultSchema,
         errorCode: 'E_SUGGEST_SEARCH_REPLACE',
-        model: TOOL_CONTRACT.model,
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
         ...buildStructuredToolRuntimeOptions(TOOL_CONTRACT),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/code-review-analyst-mcp",
-  "version": "1.6.4",
+  "version": "1.7.1",
   "mcpName": "io.github.j0hanz/code-review-analyst",
   "description": "Gemini-powered MCP server for code review analysis.",
   "type": "module",