@juspay/yama 2.4.2 → 2.5.0

package/dist/v2/core/YamaV2Orchestrator.js

@@ -10,6 +10,8 @@ import { SessionManager } from "./SessionManager.js";
 import { MemoryManager } from "../memory/MemoryManager.js";
 import { LocalDiffSource } from "./LocalDiffSource.js";
 import { ContextExplorerService } from "../exploration/ContextExplorerService.js";
+import { ProviderDetector, } from "../utils/ProviderDetector.js";
+import { getProviderToolset } from "../providers/ProviderToolset.js";
 import { buildObservabilityConfigFromEnv, validateObservabilityConfig, } from "../utils/ObservabilityConfig.js";
 export class YamaOrchestrator {
     neurolink;
@@ -23,11 +25,16 @@ export class YamaOrchestrator {
     config;
     initialized = false;
     mcpInitialized = false;
+    // Provider the PR-mode MCP servers were last set up for. Lets one orchestrator
+    // instance switch providers mid-process (Bitbucket PR then GitHub PR) by
+    // re-running setup when the detected provider no longer matches.
+    mcpProvider = null;
     localGitMcpInitialized = false;
     exploreToolRegistered = false;
     currentToolContext = null;
     initOptions;
     bootstrapStandardsCache = new Map();
+    detectedProvider = "bitbucket";
     constructor(options = {}) {
         this.initOptions = options;
         this.configLoader = new ConfigLoader();
@@ -39,7 +46,7 @@ export class YamaOrchestrator {
     /**
      * Initialize Yama with configuration and MCP servers
      */
-    async initialize(configPath, mode = "pr") {
+    async initialize(configPath, mode = "pr", request) {
         try {
             if (!this.initialized) {
                 console.log("🚀 Initializing Yama...\n");
@@ -47,6 +54,22 @@ export class YamaOrchestrator {
                 const resolvedConfigPath = configPath || this.initOptions.configPath;
                 this.config = await this.configLoader.loadConfig(resolvedConfigPath, this.initOptions.configOverrides);
                 this.showBanner();
+                // Step 1.5: Detect provider BEFORE MCP setup so the correct provider's
+                // MCP server is wired up. When the real request is threaded in, detect
+                // from it; otherwise fall back to a preliminary detection (for logging
+                // and env/config-default driven runs).
+                if (request) {
+                    this.detectedProvider = ProviderDetector.detect(request, process.env, this.config.defaultProvider);
+                }
+                else {
+                    const preliminaryRequest = {
+                        mode: "pr",
+                        workspace: "",
+                        repository: "",
+                    };
+                    this.detectedProvider = ProviderDetector.detect(preliminaryRequest, process.env, this.config.defaultProvider);
+                }
+                console.log(`🔌 Provider detected: ${this.detectedProvider}\n`);
                 // Step 2: Initialize
                 if (this.config.memory?.enabled) {
                     this.memoryManager = new MemoryManager(this.config.memory, this.config.ai.provider, this.config.ai.model);
@@ -61,12 +84,26 @@ export class YamaOrchestrator {
                 this.initialized = true;
             }
             // Step 4: Mode-specific setup
-            if (mode === "pr" && !this.mcpInitialized) {
-                await this.mcpManager.setupMCPServers(this.neurolink, this.config.mcpServers);
-                if (this.explorer && this.config.ai.explore.enabled) {
-                    await this.explorer.initialize("pr");
+            if (mode === "pr") {
+                // If MCP was already set up for a DIFFERENT provider (one instance
+                // reviewing a Bitbucket PR then a GitHub PR), tear down the previous
+                // provider's server and re-register for the new one. Single-provider
+                // runs never hit this branch, so their behaviour is unchanged.
+                if (this.mcpInitialized &&
+                    this.mcpProvider !== null &&
+                    this.mcpProvider !== this.detectedProvider) {
+                    console.log(`🔄 Provider changed (${this.mcpProvider} → ${this.detectedProvider}); re-registering MCP servers...`);
+                    await this.mcpManager.resetForProviderSwitch(this.neurolink, this.mcpProvider);
+                    this.mcpInitialized = false;
+                }
+                if (!this.mcpInitialized) {
+                    await this.mcpManager.setupMCPServers(this.neurolink, this.config.mcpServers, this.detectedProvider);
+                    if (this.explorer && this.config.ai.explore.enabled) {
+                        await this.explorer.initialize("pr");
+                    }
+                    this.mcpInitialized = true;
+                    this.mcpProvider = this.detectedProvider;
                 }
-                this.mcpInitialized = true;
             }
             else if (mode === "local" && !this.localGitMcpInitialized) {
                 await this.mcpManager.setupLocalGitMCPServer(this.neurolink);
@@ -75,8 +112,9 @@ export class YamaOrchestrator {
                 }
                 this.localGitMcpInitialized = true;
             }
-            // Step 5: Mode-specific validation
-            await this.configLoader.validate(mode);
+            // Step 5: Mode-specific validation (provider-aware: GitHub runs skip the
+            // Bitbucket env requirement, Bitbucket runs are unchanged)
+            await this.configLoader.validate(mode, this.detectedProvider);
             console.log("✅ Yama initialized successfully\n");
             console.log("═".repeat(60) + "\n");
         }
@@ -89,14 +127,16 @@ export class YamaOrchestrator {
      * Start autonomous AI review
      */
     async startReview(request) {
-        await this.ensureInitialized("pr", request.configPath);
+        await this.ensureInitialized("pr", request.configPath, request);
+        // Detect the provider based on request and environment
+        this.detectedProvider = ProviderDetector.detect(request, process.env, this.config.defaultProvider);
         const startTime = Date.now();
         const sessionId = this.sessionManager.createSession(request);
         this.logReviewStart(request, sessionId);
         try {
             const bootstrapStandards = await this.getBootstrappedStandards(request, sessionId);
             // Build comprehensive AI instructions
-            const instructions = await this.promptBuilder.buildReviewInstructions(request, this.config, bootstrapStandards);
+            const instructions = await this.promptBuilder.buildReviewInstructions(request, this.config, bootstrapStandards, this.detectedProvider);
             if (this.config.display.verboseToolCalls) {
                 console.log("\n📝 AI Instructions built:");
                 console.log(`   Instruction length: ${instructions.length} characters\n`);
@@ -218,12 +258,12 @@ export class YamaOrchestrator {
      * Stream review with real-time updates (for verbose mode)
      */
     async *streamReview(request) {
-        await this.ensureInitialized("pr", request.configPath);
+        await this.ensureInitialized("pr", request.configPath, request);
         const sessionId = this.sessionManager.createSession(request);
         try {
             const bootstrapStandards = await this.getBootstrappedStandards(request, sessionId);
             // Build instructions
-            const instructions = await this.promptBuilder.buildReviewInstructions(request, this.config, bootstrapStandards);
+            const instructions = await this.promptBuilder.buildReviewInstructions(request, this.config, bootstrapStandards, this.detectedProvider);
             // Create tool context
             const toolContext = this.createToolContext(sessionId, request);
             this.setToolContext(toolContext);
@@ -274,7 +314,7 @@ export class YamaOrchestrator {
      * This allows the AI to use knowledge gained during review to write better descriptions
      */
     async startReviewAndEnhance(request) {
-        await this.ensureInitialized("pr", request.configPath);
+        await this.ensureInitialized("pr", request.configPath, request);
         const startTime = Date.now();
         const sessionId = this.sessionManager.createSession(request);
         this.logReviewStart(request, sessionId);
@@ -284,7 +324,7 @@ export class YamaOrchestrator {
             // ========================================================================
             const bootstrapStandards = await this.getBootstrappedStandards(request, sessionId);
             // Build review instructions
-            const reviewInstructions = await this.promptBuilder.buildReviewInstructions(request, this.config, bootstrapStandards);
+            const reviewInstructions = await this.promptBuilder.buildReviewInstructions(request, this.config, bootstrapStandards, this.detectedProvider);
             if (this.config.display.verboseToolCalls) {
                 console.log("\n📝 Review instructions built:");
                 console.log(`   Instruction length: ${reviewInstructions.length} characters\n`);
@@ -331,7 +371,7 @@ export class YamaOrchestrator {
             if (this.config.descriptionEnhancement.enabled) {
                 console.log("📝 Phase 2: Enhancing PR description...");
                 console.log("   AI will use review insights to write description\n");
-                const enhanceInstructions = await this.promptBuilder.buildDescriptionEnhancementInstructions(request, this.config);
+                const enhanceInstructions = await this.promptBuilder.buildDescriptionEnhancementInstructions(request, this.config, this.detectedProvider);
                 // Continue the SAME session - AI remembers everything from review
                 const enhanceResponse = await this.neurolink.generate({
                     input: { text: enhanceInstructions },
@@ -376,11 +416,11 @@ export class YamaOrchestrator {
      * Enhance PR description only (without full review)
      */
     async enhanceDescription(request) {
-        await this.ensureInitialized("pr", request.configPath);
+        await this.ensureInitialized("pr", request.configPath, request);
         const sessionId = this.sessionManager.createSession(request);
         try {
             console.log("\n📝 Enhancing PR description...\n");
-            const instructions = await this.promptBuilder.buildDescriptionEnhancementInstructions(request, this.config);
+            const instructions = await this.promptBuilder.buildDescriptionEnhancementInstructions(request, this.config, this.detectedProvider);
             const toolContext = this.createToolContext(sessionId, request);
             this.setToolContext(toolContext);
             const aiResponse = await this.neurolink.generate({
@@ -429,15 +469,28 @@ export class YamaOrchestrator {
         return this.sessionManager.exportSession(sessionId);
     }
     getUserId(request) {
-        return `${request.workspace}-${request.repository}`.toLowerCase();
+        // Coalesce provider-specific identifiers: Bitbucket uses workspace/repository,
+        // GitHub uses owner/repo. Bitbucket behavior is unchanged when those are set.
+        const workspace = request.workspace || request.owner || "";
+        const repository = request.repository || request.repo || "";
+        return `${workspace}-${repository}`.toLowerCase();
     }
     createToolContext(sessionId, request) {
         return {
             sessionId,
             mode: "pr",
-            workspace: request.workspace,
-            repository: request.repository,
-            pullRequestId: request.pullRequestId,
+            // Carry the detected provider so explore_context / tool runtime context
+            // knows which provider's toolset to use (GitHub reviews otherwise saw
+            // provider=undefined and defaulted to Bitbucket).
+            provider: this.detectedProvider,
+            // Coalesce provider-specific identifiers (GitHub owner/repo, Bitbucket
+            // workspace/repository) into the existing context fields. No-op for
+            // Bitbucket where workspace/repository are already set.
+            workspace: request.workspace || request.owner,
+            repository: request.repository || request.repo,
+            // GitHub passes the PR number via prNumber; coalesce so the runtime
+            // context has a PR number for both providers.
+            pullRequestId: request.pullRequestId ?? request.prNumber,
             branch: request.branch,
             dryRun: request.dryRun || false,
             metadata: {
@@ -450,8 +503,12 @@ export class YamaOrchestrator {
         return {
             sessionId,
             mode: "local",
-            workspace: request.workspace,
-            repository: request.repository,
+            // Carry the detected provider for explore_context toolset selection.
+            provider: this.detectedProvider,
+            // Coalesce provider-specific identifiers (GitHub owner/repo, Bitbucket
+            // workspace/repository). No-op for Bitbucket where they are already set.
+            workspace: request.workspace || request.owner,
+            repository: request.repository || request.repo,
             dryRun: request.dryRun || false,
             metadata: {
                 yamaVersion: "2.2.1",
@@ -479,7 +536,9 @@ export class YamaOrchestrator {
         const statistics = this.calculateStatistics(session);
         return {
             mode: "pr",
-            prId: session.request.pullRequestId || 0,
+            // GitHub passes the PR number via prNumber; coalesce so GitHub reviews
+            // report the real PR number instead of 0.
+            prId: session.request.pullRequestId ?? session.request.prNumber ?? 0,
             decision,
             statistics,
             summary: this.extractSummary(aiResponse),
@@ -756,36 +815,25 @@ export class YamaOrchestrator {
      * Extract decision from AI response
      */
     extractDecision(aiResponse, session) {
-        // Derive final review state from tool calls.
-        // Supports both current Bitbucket MCP tools and legacy names.
+        // Derive final review state from tool calls, delegating provider-specific
+        // signal interpretation to the detected provider's toolset. The Bitbucket
+        // toolset replicates the previous hardcoded logic (set_review_status /
+        // set_pr_approval + legacy names) byte-for-byte.
         const toolCalls = session.toolCalls || [];
+        const ts = getProviderToolset(this.detectedProvider);
         let requestedChanges;
         let approved;
         for (const tc of toolCalls) {
-            const name = tc?.toolName;
-            const args = tc?.args || {};
-            if (name === "set_review_status") {
-                if (typeof args.request_changes === "boolean") {
-                    requestedChanges = args.request_changes;
-                }
-            }
-            else if (name === "request_changes") {
+            const decision = ts.interpretDecision({
+                toolName: tc?.toolName,
+                args: tc?.args || {},
+            });
+            if (decision === "BLOCKED") {
                 requestedChanges = true;
             }
-            else if (name === "remove_requested_changes") {
-                requestedChanges = false;
-            }
-            else if (name === "set_pr_approval") {
-                if (typeof args.approved === "boolean") {
-                    approved = args.approved;
-                }
-            }
-            else if (name === "approve_pull_request") {
+            else if (decision === "APPROVED") {
                 approved = true;
             }
-            else if (name === "unapprove_pull_request") {
-                approved = false;
-            }
         }
         if (requestedChanges === true) {
             return "BLOCKED";
@@ -801,10 +849,12 @@ export class YamaOrchestrator {
      */
     calculateStatistics(session) {
         const toolCalls = session.toolCalls || [];
-        // Count file diffs read
-        const filesReviewed = toolCalls.filter((tc) => tc.toolName === "get_pull_request_diff").length;
-        // Try to extract issue counts from comments
-        const commentCalls = toolCalls.filter((tc) => tc.toolName === "add_comment");
+        const ts = getProviderToolset(this.detectedProvider);
+        // Count the changed files actually reviewed. Provider-specific because the
+        // diff-tool semantics differ.
+        const filesReviewed = this.countFilesReviewed(toolCalls);
+        // Try to extract issue counts from comments (provider-specific comment tools)
+        const commentCalls = toolCalls.filter((tc) => ts.commentToolNames.includes(tc.toolName));
         const issuesFound = this.extractIssueCountsFromComments(commentCalls);
         return {
             filesReviewed,
@@ -816,6 +866,54 @@ export class YamaOrchestrator {
             totalComments: commentCalls.length,
         };
     }
+    /**
+     * Count the changed files actually reviewed, from the session tool calls.
+     *
+     * Bitbucket: get_pull_request_diff is called once per file by design, so the
+     * raw count of diff-tool calls already equals the files reviewed. This path is
+     * byte-for-byte identical to the previous behaviour.
+     *
+     * GitHub: pull_request_read is overloaded — the SAME tool name serves
+     * method="get" (PR shell), "get_files" (changed-file list) and "get_diff"
+     * (unified diff). Counting every pull_request_read call therefore inflates the
+     * number. Instead, count DISTINCT file paths the review actually touched, taken
+     * from the inline pending-review comments (add_comment_to_pending_review →
+     * args.path). Fall back to the number of distinct get_files/get_diff reads when
+     * no inline comments were posted (e.g. a clean approval), so a reviewed-but-
+     * clean PR is not reported as 0 files.
+     */
+    countFilesReviewed(toolCalls) {
+        const ts = getProviderToolset(this.detectedProvider);
+        if (this.detectedProvider !== "github") {
+            // Bitbucket (and any non-GitHub provider): one diff fetch per file.
+            return toolCalls.filter((tc) => ts.diffToolNames.includes(tc.toolName)).length;
+        }
+        // GitHub: prefer distinct paths from inline comments.
+        const commentedPaths = new Set();
+        for (const tc of toolCalls) {
+            if (tc?.toolName !== "add_comment_to_pending_review") {
+                continue;
+            }
+            const path = tc?.args?.path;
+            if (typeof path === "string" && path.length > 0) {
+                commentedPaths.add(path);
+            }
+        }
+        if (commentedPaths.size > 0) {
+            return commentedPaths.size;
+        }
+        // Fallback for clean PRs with no inline comments: count the distinct
+        // changed-file / diff reads (pull_request_read with method get_files/get_diff)
+        // rather than every pull_request_read (which includes the single "get").
+        const diffReads = toolCalls.filter((tc) => {
+            if (!ts.diffToolNames.includes(tc?.toolName)) {
+                return false;
+            }
+            const method = tc?.args?.method;
+            return method === "get_files" || method === "get_diff";
+        }).length;
+        return diffReads;
+    }
     /**
      * Extract issue counts from comment tool calls
      */
@@ -1020,6 +1118,9 @@ export class YamaOrchestrator {
                     mode: runtimeMode,
                     workspace: String(mergedContext.workspace || "local"),
                     repository: String(mergedContext.repository || "repository"),
+                    provider: typeof mergedContext.provider === "string"
+                        ? mergedContext.provider
+                        : undefined,
                     pullRequestId: typeof mergedContext.pullRequestId === "number"
                         ? mergedContext.pullRequestId
                         : undefined,
@@ -1063,20 +1164,29 @@ export class YamaOrchestrator {
         if (!this.config.ai.explore.enabled || !this.explorer) {
             return "";
         }
-        const cacheKey = `${request.workspace}/${request.repository}`.toLowerCase();
+        // Validate required parameters for bootstrap. Coalesce provider-specific
+        // identifiers so GitHub (owner/repo) also gets bootstrap standards; no-op
+        // for Bitbucket where workspace/repository are already set.
+        const workspace = (request.workspace || request.owner || "").trim();
+        const repository = (request.repository || request.repo || "").trim();
+        if (workspace.length === 0 || repository.length === 0) {
+            return "";
+        }
+        const cacheKey = `${workspace}/${repository}`.toLowerCase();
         const cached = this.bootstrapStandardsCache.get(cacheKey);
         if (cached !== undefined) {
             return cached;
         }
-        const task = `Bootstrap repo review standards for ${request.workspace}/${request.repository}. Inspect the last 15 merged pull requests on this repository. For each, collect inline and summary comments left by HUMAN reviewers (ignore bot authors like "Yama", "yama-bot", "yama-review", "euler.bot"). Focus on comments that asked for code changes, flagged bugs, pushed back on an approach, or cited a convention. Distill the recurring patterns and anti-patterns the human reviewers care about — especially things that a static config rule set would miss (naming, error-handling idioms, module boundaries, test expectations, migration rules, review etiquette). Return a concise bullet list of 10-20 patterns. Each bullet: one sentence stating the pattern, optionally one sentence of rationale. Do NOT include PR numbers, author names, or raw quotes — just distilled patterns.`;
+        const task = `Bootstrap repo review standards for ${workspace}/${repository}. Inspect the last 15 merged pull requests on this repository. For each, collect inline and summary comments left by HUMAN reviewers (ignore bot authors like "Yama", "yama-bot", "yama-review", "euler.bot"). Focus on comments that asked for code changes, flagged bugs, pushed back on an approach, or cited a convention. Distill the recurring patterns and anti-patterns the human reviewers care about — especially things that a static config rule set would miss (naming, error-handling idioms, module boundaries, test expectations, migration rules, review etiquette). Return a concise bullet list of 10-20 patterns. Each bullet: one sentence stating the pattern, optionally one sentence of rationale. Do NOT include PR numbers, author names, or raw quotes — just distilled patterns.`;
         try {
             console.log(`   🧭 Bootstrapping repo standards from recent PRs (one-time per process)...`);
-            const { result } = await this.explorer.explore({ task, focus: [request.repository] }, {
+            const { result } = await this.explorer.explore({ task, focus: [repository] }, {
                 sessionId,
                 mode: "pr",
-                workspace: request.workspace,
-                repository: request.repository,
-                pullRequestId: request.pullRequestId,
+                provider: this.detectedProvider,
+                workspace,
+                repository,
+                pullRequestId: request.pullRequestId ?? request.prNumber,
                 branch: request.branch,
                 dryRun: request.dryRun || false,
                 metadata: { bootstrap: true },
@@ -1115,8 +1225,8 @@ export class YamaOrchestrator {
     /**
      * Ensure orchestrator is initialized
      */
-    async ensureInitialized(mode = "pr", configPath) {
-        await this.initialize(configPath, mode);
+    async ensureInitialized(mode = "pr", configPath, request) {
+        await this.initialize(configPath, mode, request);
     }
     /**
      * Show Yama banner

package/dist/v2/exploration/ContextExplorerService.d.ts

@@ -18,7 +18,16 @@ export declare class ContextExplorerService {
     explore(input: ExploreContextInput, runtimeContext: ExploreRuntimeContext): Promise<ExploreExecutionResult>;
     private normalizeInput;
     private buildCacheKey;
+    private getUserId;
     private getToolFilteringOptions;
+    /**
+     * Provider-agnostic mutation block list for the read-only explore subagent.
+     * Derived once from each provider toolset's mutationToolNames (Bitbucket +
+     * GitHub) so the source of truth stays in ProviderToolset, not re-hardcoded
+     * here. Names are lower-cased for case-insensitive matching against the
+     * normalized tool name.
+     */
+    private static readonly MUTATION_TOOL_NAMES;
     private shouldExcludeTool;
     private normalizeToolName;
     private normalizeResult;

package/dist/v2/exploration/ContextExplorerService.js

@@ -5,6 +5,7 @@ import { NeuroLink } from "@juspay/neurolink";
 import { MCPServerManager } from "../core/MCPServerManager.js";
 import { KnowledgeBaseManager } from "../learning/KnowledgeBaseManager.js";
 import { buildObservabilityConfigFromEnv, validateObservabilityConfig, } from "../utils/ObservabilityConfig.js";
+import { getProviderToolset } from "../providers/ProviderToolset.js";
 import { ExplorerPromptBuilder } from "./ExplorerPromptBuilder.js";
 import { RulesContextLoader } from "./RulesContextLoader.js";
 export class ContextExplorerService {
@@ -72,7 +73,7 @@ export class ContextExplorerService {
             ...this.getToolFilteringOptions(runtimeContext.mode),
             context: {
                 sessionId: runtimeContext.sessionId,
-                userId: `${runtimeContext.workspace}-${runtimeContext.repository}`.toLowerCase(),
+                userId: this.getUserId(runtimeContext),
                 operation: "explore-context-research",
                 metadata: runtimeContext.metadata || {},
             },
@@ -91,7 +92,7 @@ export class ContextExplorerService {
             disableTools: true,
             context: {
                 sessionId: runtimeContext.sessionId,
-                userId: `${runtimeContext.workspace}-${runtimeContext.repository}`.toLowerCase(),
+                userId: this.getUserId(runtimeContext),
                 operation: "explore-context-extraction",
                 metadata: runtimeContext.metadata || {},
             },
@@ -122,16 +123,48 @@ export class ContextExplorerService {
         };
     }
     buildCacheKey(input, runtimeContext) {
+        // Validate required string parameters
+        const task = typeof input.task === "string" ? input.task.trim().toLowerCase() : "";
+        const workspace = typeof runtimeContext.workspace === "string"
+            ? runtimeContext.workspace.trim()
+            : "";
+        const repository = typeof runtimeContext.repository === "string"
+            ? runtimeContext.repository.trim()
+            : "";
+        if (!task) {
+            throw new Error("Invalid cache key: task must be a non-empty string");
+        }
+        if (!workspace || !repository) {
+            throw new Error("Invalid cache key: workspace and repository must be non-empty strings");
+        }
         return JSON.stringify({
             mode: runtimeContext.mode,
-            workspace: runtimeContext.workspace,
-            repository: runtimeContext.repository,
+            provider: typeof runtimeContext.provider === "string"
+                ? runtimeContext.provider.trim().toLowerCase()
+                : "bitbucket",
+            workspace,
+            repository,
             pullRequestId: runtimeContext.pullRequestId || null,
-            branch: runtimeContext.branch || null,
-            task: input.task.toLowerCase(),
-            focus: (input.focus || []).map((item) => item.toLowerCase()),
+            branch: typeof runtimeContext.branch === "string"
+                ? runtimeContext.branch.trim()
+                : null,
+            task,
+            focus: Array.isArray(input.focus)
+                ? input.focus
+                    .filter((item) => typeof item === "string")
+                    .map((item) => item.trim().toLowerCase())
+                : [],
         });
     }
+    getUserId(runtimeContext) {
+        const workspace = typeof runtimeContext.workspace === "string"
+            ? runtimeContext.workspace.trim()
+            : "unknown";
+        const repository = typeof runtimeContext.repository === "string"
+            ? runtimeContext.repository.trim()
+            : "unknown";
+        return `${workspace}-${repository}`.toLowerCase();
+    }
     getToolFilteringOptions(mode) {
         try {
             const externalTools = this.neurolink.getExternalMCPTools?.();
@@ -148,9 +181,17 @@ export class ContextExplorerService {
             return {};
         }
     }
+    /**
+     * Provider-agnostic mutation block list for the read-only explore subagent.
+     * Derived once from each provider toolset's mutationToolNames (Bitbucket +
+     * GitHub) so the source of truth stays in ProviderToolset, not re-hardcoded
+     * here. Names are lower-cased for case-insensitive matching against the
+     * normalized tool name.
+     */
+    static MUTATION_TOOL_NAMES = new Set(["bitbucket", "github"].flatMap((provider) => getProviderToolset(provider).mutationToolNames.map((name) => name.toLowerCase())));
     shouldExcludeTool(mode, toolName) {
         const normalized = this.normalizeToolName(toolName);
-        if (/^(add_comment|set_pr_approval|set_review_status|approve_pull_request|unapprove_pull_request|request_changes|remove_requested_changes|update_pull_request|merge_pull_request|delete_branch)$/i.test(normalized)) {
+        if (ContextExplorerService.MUTATION_TOOL_NAMES.has(normalized.toLowerCase())) {
             return true;
         }
         if (mode === "local") {
@@ -430,7 +471,7 @@ Rules:
         if (!this.memoryManager) {
             return null;
         }
-        return this.memoryManager.readRepositoryMemory(runtimeContext.workspace, runtimeContext.repository);
+        return this.memoryManager.readRepositoryMemory(runtimeContext.workspace, runtimeContext.repository, runtimeContext.provider || "bitbucket");
     }
     initializeNeurolink() {
         const observabilityConfig = buildObservabilityConfigFromEnv();

package/dist/v2/exploration/types.d.ts

@@ -8,6 +8,7 @@ export interface ExploreRuntimeContext {
     mode: "pr" | "local";
     workspace: string;
     repository: string;
+    provider?: string;
     pullRequestId?: number;
     branch?: string;
     dryRun?: boolean;

package/dist/v2/learning/types.d.ts

@@ -2,6 +2,7 @@
  * Learning Types
  * Type definitions for the knowledge base and learning extraction system
  */
+import type { VCSProviderName } from "../providers/ProviderToolset.js";
 /**
  * Categories for extracted learnings
  * Maps to sections in the knowledge base file
@@ -69,6 +70,7 @@ export interface LearnRequest {
     workspace: string;
     repository: string;
     pullRequestId: number;
+    provider?: VCSProviderName;
     dryRun?: boolean;
     /** @deprecated Use commitMode instead */
     commit?: boolean;

package/dist/v2/memory/MemoryManager.d.ts

@@ -36,18 +36,34 @@ export declare class MemoryManager {
      */
     buildNeuroLinkMemoryConfig(): Record<string, unknown>;
     /**
-     * Build a deterministic owner ID from workspace and repository.
+     * Build a deterministic owner ID from provider, workspace, and repository.
+     * Isolates memory per platform to prevent collisions between same repo names
+     * on different platforms (e.g., "repo" on GitHub vs Bitbucket).
+     *
+     * Format:
+     *   - GitHub: github-{owner}-{repo}
+     *   - Bitbucket: bitbucket-{workspace}-{repo}
+     *
      * This value is passed as `context.userId` in generate() calls.
      */
-    static buildOwnerId(workspace: string, repository: string): string;
+    static buildOwnerId(workspace: string, repository: string, provider?: string): string;
+    /**
+     * Build the legacy (unprefixed) owner ID used before provider isolation.
+     *
+     * Format: {workspace}-{repository}
+     *
+     * Used as a read-time fallback so memory written before the provider-prefix
+     * upgrade keeps working. New writes always use the provider-prefixed key.
+     */
+    static buildLegacyOwnerId(workspace: string, repository: string): string;
     /**
      * Read persisted condensed memory for a repository owner ID.
      */
     readMemory(ownerId: string): Promise<string | null>;
     /**
-     * Read persisted condensed memory for a workspace/repository pair.
+     * Read persisted condensed memory for a workspace/repository pair on a specific provider.
      */
-    readRepositoryMemory(workspace: string, repository: string): Promise<string | null>;
+    readRepositoryMemory(workspace: string, repository: string, provider?: string): Promise<string | null>;
     /**
      * Commit memory files to the repository if autoCommit is enabled.
      *

package/dist/v2/memory/MemoryManager.js

@@ -123,10 +123,29 @@ export class MemoryManager {
         };
     }
     /**
-     * Build a deterministic owner ID from workspace and repository.
+     * Build a deterministic owner ID from provider, workspace, and repository.
+     * Isolates memory per platform to prevent collisions between same repo names
+     * on different platforms (e.g., "repo" on GitHub vs Bitbucket).
+     *
+     * Format:
+     *   - GitHub: github-{owner}-{repo}
+     *   - Bitbucket: bitbucket-{workspace}-{repo}
+     *
      * This value is passed as `context.userId` in generate() calls.
      */
-    static buildOwnerId(workspace, repository) {
+    static buildOwnerId(workspace, repository, provider = "bitbucket") {
+        const providerPrefix = provider.toLowerCase();
+        return `${providerPrefix}-${workspace}-${repository}`.toLowerCase();
+    }
+    /**
+     * Build the legacy (unprefixed) owner ID used before provider isolation.
+     *
+     * Format: {workspace}-{repository}
+     *
+     * Used as a read-time fallback so memory written before the provider-prefix
+     * upgrade keeps working. New writes always use the provider-prefixed key.
+     */
+    static buildLegacyOwnerId(workspace, repository) {
         return `${workspace}-${repository}`.toLowerCase();
     }
     /**
@@ -146,10 +165,16 @@ export class MemoryManager {
         }
     }
     /**
-     * Read persisted condensed memory for a workspace/repository pair.
+     * Read persisted condensed memory for a workspace/repository pair on a specific provider.
      */
-    async readRepositoryMemory(workspace, repository) {
-        return this.readMemory(MemoryManager.buildOwnerId(workspace, repository));
+    async readRepositoryMemory(workspace, repository, provider = "bitbucket") {
+        const prefixed = await this.readMemory(MemoryManager.buildOwnerId(workspace, repository, provider));
+        if (prefixed !== null) {
+            return prefixed;
+        }
+        // Fall back to the legacy unprefixed key so memory written before the
+        // provider-prefix upgrade is not silently dropped after upgrading.
+        return this.readMemory(MemoryManager.buildLegacyOwnerId(workspace, repository));
     }
     /**
      * Commit memory files to the repository if autoCommit is enabled.