0xray 3.0.11 → 3.0.14

package/dist/core/orchestrator.js

@@ -1,15 +1,9 @@
 /**
- * 0xRay Framework - Core Orchestrator (deprecated)
- *
- * Use thin-dispatch (src/nucleus/thin-dispatch.ts) for runtime agent routing
- * and src/utils/task-graph.ts for task graph utilities.
- * KernelOrchestrator is kept for backward compat with boot sequence integration.
- *
- * @deprecated since v3.0.0 — use thin-dispatch for routing, task-graph for utilities
+ * 0xRay Framework - Core Orchestrator
+ * Main orchestration engine for multi-agent task coordination
  */
 import { frameworkLogger } from "../core/framework-logger.js";
 import { getKernel } from "./kernel-patterns.js";
-import { topologicalSort, validateTaskDependencies, resolveConflicts } from "../utils/task-graph.js";
 export class KernelOrchestrator {
     taskQueue = new Map();
     activeTasks = new Set();
@@ -21,10 +15,6 @@ export class KernelOrchestrator {
         this.kernel = getKernel();
         frameworkLogger.log("orchestrator", "initialized", "info", { config: this.config });
     }
-    /**
-     * @deprecated since v3.0.0 — use thin-dispatch routing (scoreComplexity → routeToAgent)
-     *             and agent-delegator for actual execution.
-     */
     async executeTask(task) {
         const taskId = this.generateTaskId();
         this.taskQueue.set(taskId, task);
@@ -150,9 +140,23 @@ export class KernelOrchestrator {
             };
         }
     }
+    async dispatchToAgent(task) {
+        // Agent selection and dispatch logic
+        const startTime = Date.now();
+        // Simulate task execution with minimal delay to avoid hanging in test environment
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        const duration = Date.now() - startTime;
+        return {
+            success: true,
+            taskId: task.id,
+            agentUsed: task.subagentType || "default-agent",
+            duration,
+            result: { id: task.id, type: task.type, simulated: true },
+        };
+    }
     async executeComplexTask(description, tasks, sessionId) {
         // Validate that all task dependencies are within this orchestrator's batch
-        validateTaskDependencies(tasks);
+        this.validateTaskDependencies(tasks);
         frameworkLogger.log("orchestrator", "complex-task-started", "info", {
             description,
             taskCount: tasks.length,
@@ -160,7 +164,7 @@ export class KernelOrchestrator {
         const results = [];
         const completedTaskIds = new Set();
         // Sort tasks by dependencies (simple topological sort)
-        const sortedTasks = topologicalSort(tasks);
+        const sortedTasks = this.topologicalSort(tasks);
         for (const task of sortedTasks) {
             // Check dependencies
             if (task.dependencies && task.dependencies.length > 0) {
@@ -204,8 +208,156 @@ export class KernelOrchestrator {
         });
         return results;
     }
+    topologicalSort(tasks) {
+        const visited = new Set();
+        const visiting = new Set();
+        const result = [];
+        const visit = (taskId) => {
+            if (visiting.has(taskId)) {
+                throw new Error(`Circular dependency detected: ${taskId}`);
+            }
+            if (visited.has(taskId)) {
+                return;
+            }
+            visiting.add(taskId);
+            const task = tasks.find((t) => t.id === taskId);
+            if (task && task.dependencies) {
+                for (const dep of task.dependencies) {
+                    visit(dep);
+                }
+            }
+            visiting.delete(taskId);
+            visited.add(taskId);
+            if (task) {
+                result.push(task);
+            }
+        };
+        for (const task of tasks) {
+            if (!visited.has(task.id)) {
+                visit(task.id);
+            }
+        }
+        return result;
+    }
+    /**
+     * Validates that all task dependencies are within the current task batch.
+     * Prevents cross-orchestrator dependency errors by failing fast with a clear message.
+     */
+    validateTaskDependencies(tasks) {
+        const taskIds = new Set(tasks.map((t) => t.id));
+        const errors = [];
+        for (const task of tasks) {
+            if (task.dependencies && task.dependencies.length > 0) {
+                for (const dep of task.dependencies) {
+                    if (!taskIds.has(dep)) {
+                        errors.push(`Task "${task.id}" depends on "${dep}" which is NOT in this orchestrator's task batch.\n` +
+                            `Available tasks in this batch: ${Array.from(taskIds).join(", ")}`);
+                    }
+                }
+            }
+        }
+        if (errors.length > 0) {
+            const errorMessage = `[TEST ARCHITECTURE ERROR] Cross-orchestrator dependencies detected.\n\n` +
+                `${errors.join("\n\n")}\n\n` +
+                `This usually means:\n` +
+                `1. You're creating multiple orchestrator instances in one test\n` +
+                `2. Task dependencies are crossing orchestrator boundaries\n\n` +
+                `FIX: Either:\n` +
+                `A) Include the missing dependency task in this executeComplexTask() call\n` +
+                `B) Use a single orchestrator for all dependent tasks\n` +
+                `C) Remove the dependency if it's not needed\n\n` +
+                `Example of correct usage:\n` +
+                `  const orch = new StringRayOrchestrator();\n` +
+                `  await orch.executeComplexTask("test", [\n` +
+                `    { id: "task-1" },\n` +
+                `    { id: "task-2", dependencies: ["task-1"] }  // ✅ Same orchestrator\n` +
+                `  ]);`;
+            throw new Error(errorMessage);
+        }
+    }
+    async executeComplexTaskSingle(task) {
+        const taskId = this.generateTaskId();
+        this.taskQueue.set(taskId, task);
+        this.activeTasks.add(taskId);
+        frameworkLogger.log("orchestrator", "complex-task-started", "info", {
+            taskId,
+            taskType: task.type,
+            complexity: task.complexity,
+            dependencies: task.dependencies,
+        });
+        try {
+            const startTime = Date.now();
+            if (task.dependencies && task.dependencies.length > 0) {
+                frameworkLogger.log("orchestrator", "processing-dependencies", "info", {
+                    taskId,
+                    dependencies: task.dependencies,
+                });
+                await new Promise((resolve) => setTimeout(resolve, 200));
+            }
+            await new Promise((resolve) => setTimeout(resolve, 300));
+            const duration = Date.now() - startTime;
+            frameworkLogger.log("orchestrator", "complex-task-completed", "success", {
+                taskId,
+                duration,
+                dependenciesResolved: task.dependencies?.length || 0,
+            });
+            return {
+                success: true,
+                taskId,
+                agentUsed: task.subagentType || "default-agent",
+                duration,
+                result: {
+                    complexTask: true,
+                    taskType: task.type,
+                    dependenciesProcessed: task.dependencies?.length || 0,
+                },
+            };
+        }
+        catch (error) {
+            frameworkLogger.log("orchestrator", "complex-task-failed", "error", {
+                taskId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return {
+                success: false,
+                taskId,
+                agentUsed: task.subagentType || "default-agent",
+                duration: 0,
+                result: null,
+                errors: [error instanceof Error ? error.message : String(error)],
+            };
+        }
+        finally {
+            this.activeTasks.delete(taskId);
+            this.taskQueue.delete(taskId);
+        }
+    }
     resolveConflicts(conflicts) {
-        return resolveConflicts(conflicts, this.config.conflictResolutionStrategy);
+        if (conflicts.length === 0) {
+            return { response: "", expertiseScore: 0 };
+        }
+        if (this.config.conflictResolutionStrategy === "majority_vote") {
+            const votes = {};
+            conflicts.forEach((conflict) => {
+                const response = String(conflict.response ?? conflict.proposed ?? '');
+                votes[response] = (votes[response] || 0) + 1;
+            });
+            const maxVotes = Math.max(...Object.values(votes));
+            const winner = Object.entries(votes).find(([_, voteCount]) => voteCount === maxVotes);
+            if (winner) {
+                const winningConflicts = conflicts.filter((c) => String(c.response ?? c.proposed ?? '') === winner[0]);
+                const avgExpertise = winningConflicts.reduce((sum, c) => sum + (c.expertiseScore || 0), 0) / winningConflicts.length;
+                return { response: winner[0], expertiseScore: avgExpertise };
+            }
+        }
+        // Fallback to highest expertise score
+        const bestConflict = conflicts.reduce((best, current) => (current.expertiseScore || 0) > (best.expertiseScore || 0)
+            ? current
+            : best);
+        return {
+            response: String(bestConflict.response ?? bestConflict.proposed ?? ''),
+            expertiseScore: bestConflict.expertiseScore || 0,
+        };
     }
     generateTaskId() {
         return `task-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
@@ -236,19 +388,12 @@ export class KernelOrchestrator {
         }
     }
     async performDelegation(agentName, task) {
-        const { scoreAndRoute } = await import("../nucleus/thin-dispatch.js");
-        const routing = scoreAndRoute(task.description, { taskType: task.type, agentName });
-        frameworkLogger.log("orchestrator", "thin-dispatch-routing", "info", {
-            requestedAgent: agentName,
-            routedAgent: routing.agent,
-            score: routing.score.score,
-            level: routing.score.level,
-        });
+        await new Promise((resolve) => setTimeout(resolve, 50));
         return {
             success: true,
-            result: `Task routed to ${routing.agent} via thin-dispatch`,
-            agentName: routing.agent,
-            executionTime: 0,
+            result: `Task completed successfully by ${agentName}`,
+            agentName,
+            executionTime: 50,
         };
     }
     getStatus() {
@@ -260,6 +405,4 @@ export class KernelOrchestrator {
         };
     }
 }
-export const xrayOrchestrator = new KernelOrchestrator();
-export const strRayOrchestrator = xrayOrchestrator; // backward compat
-//# sourceMappingURL=orchestrator.js.map
+export const strRayOrchestrator = new KernelOrchestrator();

package/dist/core/system-prompt-generator.js

@@ -7,7 +7,7 @@
  * @version 1.0.0
  * @since 2026-03-03
  */
-import { XrayContextLoader } from "./context-loader.js";
+import { StringRayContextLoader } from "./context-loader.js";
 import { validateContext, preventSystemPromptBloat } from "./context-validator.js";
 import fs from "fs";
 import path from "path";
@@ -140,7 +140,7 @@ export async function generateLeanSystemPrompt(config = {}) {
     let finalPrompt = systemPrompt;
     if (showCodexContext && enableTokenOptimization) {
         try {
-            const contextLoader = XrayContextLoader.getInstance();
+            const contextLoader = StringRayContextLoader.getInstance();
             const loadResult = await contextLoader.loadCodexContext(process.cwd());
             if (loadResult.success && loadResult.context) {
                 const codexSummary = generateCodexSummary(loadResult.context, maxTokenBudget);
@@ -263,4 +263,3 @@ export function validateSystemPrompt(prompt) {
         warnings
     };
 }
-//# sourceMappingURL=system-prompt-generator.js.map

package/dist/core/trace-context.js

@@ -0,0 +1,33 @@
+// src/core/trace-context.ts
+// Centralized trace propagation
+let currentTrace = null;
+function generateId() {
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    return Date.now().toString(36) + Math.random().toString(36).substring(2);
+}
+export function startTrace(operation, metadata) {
+    const trace = {
+        traceId: generateId(),
+        operation,
+        governanceApproved: false,
+        startTime: Date.now(),
+        metadata: metadata || {}
+    };
+    currentTrace = trace;
+    return trace;
+}
+export function getCurrentTrace() {
+    return currentTrace;
+}
+export function endTrace(approved = true) {
+    if (currentTrace)
+        currentTrace.governanceApproved = approved;
+    currentTrace = null;
+}
+export function propagateTrace(childOperation) {
+    if (!currentTrace)
+        return null;
+    return { ...currentTrace, parentId: currentTrace.traceId, operation: childOperation, startTime: Date.now() };
+}

package/dist/core/xray-activation.js

@@ -1,21 +1,21 @@
 /**
- * 0xRay activation — reads config from .xray/ runtime state directory.
+ * Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .strray fallbacks).
  */
 import { frameworkLogger } from "../core/framework-logger.js";
 import { ensureCriticalComponents } from "../architect/architectural-integrity.js";
 import { validateRegistryConsistency } from "../agents/registry.js";
-export const defaultXrayConfig = {
+export const defaultStringRayConfig = {
     enableOrchestrator: true,
     enableBootOrchestrator: true,
     enableStateManagement: true,
     enableHooks: true,
     enableCodexInjection: true,
     enableProcessors: true,
-    enablePostProcessor: false,
+    enablePostProcessor: true,
 };
-export async function activateXrayFramework(config = {}) {
+export async function activateStringRayFramework(config = {}) {
     const jobId = `activation-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-    const activationConfig = { ...defaultXrayConfig, ...config };
+    const activationConfig = { ...defaultStringRayConfig, ...config };
     // Banner display moved to init.sh execution in plugin
     // Framework activation proceeds quietly
     frameworkLogger.log("stringray-activation", "beginning xray framework activation", "info", { jobId, ...activationConfig });
@@ -59,8 +59,8 @@ async function activateCodexInjection(jobId) {
     frameworkLogger.log("stringray-activation", "activating codex injection", "info", { jobId });
     const { createXrayCodexInjectorHook } = await import("./codex-injector.js");
     const hook = createXrayCodexInjectorHook();
-    globalThis.xrayHooks = globalThis.xrayHooks || [];
-    globalThis.xrayHooks.push(hook);
+    globalThis.strRayHooks = globalThis.strRayHooks || [];
+    globalThis.strRayHooks.push(hook);
     frameworkLogger.log("stringray-activation", "codex injection activated", "success", { jobId, hookName: hook.name });
 }
 async function activateHooks(jobId) {
@@ -70,12 +70,12 @@ async function activateHooks(jobId) {
         const { createXrayCodexInjectorHook } = await import("./codex-injector");
         const hook = createXrayCodexInjectorHook();
         // Store hook globally for OpenCode to pick up
-        globalThis.xrayHooks = globalThis.xrayHooks || [];
-        globalThis.xrayHooks.push(hook);
+        globalThis.strRayHooks = globalThis.strRayHooks || [];
+        globalThis.strRayHooks.push(hook);
         frameworkLogger.log("stringray-activation", "xray hooks activated", "success", {
             jobId,
             hookName: hook.name,
-            hooksRegistered: globalThis.xrayHooks.length
+            hooksRegistered: globalThis.strRayHooks.length
         });
     }
     catch (error) {
@@ -90,16 +90,15 @@ async function activateBootOrchestrator(jobId) {
 }
 async function activateStateManagement(jobId) {
     frameworkLogger.log("stringray-activation", "activating state management", "info", { jobId });
-    const { XrayStateManager } = await import("../state/state-manager");
-    const stateManager = new XrayStateManager();
+    const { StringRayStateManager } = await import("../state/state-manager");
+    const stateManager = new StringRayStateManager();
     // Store the state manager instance globally for framework use
-    globalThis.xrayStateManager = stateManager;
-    globalThis.strRayStateManager = stateManager; // backward compat
+    globalThis.strRayStateManager = stateManager;
     frameworkLogger.log("stringray-activation", "state management activated", "success", { jobId });
 }
 async function activateOrchestrator(jobId) {
     frameworkLogger.log("stringray-activation", "activating xray orchestrator", "info", { jobId });
-    const { xrayOrchestrator } = await import("./orchestrator");
+    const { strRayOrchestrator } = await import("./orchestrator");
     // Also activate the multi-agent orchestration coordinator
     const { multiAgentOrchestrationCoordinator } = await import("../orchestrator/multi-agent-orchestration-coordinator");
     frameworkLogger.log("stringray-activation", "xray orchestrator and multi-agent coordination activated", "success", { jobId });
@@ -107,34 +106,29 @@ async function activateOrchestrator(jobId) {
 async function activateProcessors(jobId) {
     frameworkLogger.log("stringray-activation", "activating processor pipeline", "info", { jobId });
     const { ProcessorManager } = await import("../processors/processor-manager");
-    const { XrayStateManager } = await import("../state/state-manager");
-    const stateManager = new XrayStateManager();
+    const { StringRayStateManager } = await import("../state/state-manager");
+    const stateManager = new StringRayStateManager();
     const processorManager = new ProcessorManager(stateManager);
     // Store the processor manager instance globally for framework use
-    globalThis.xrayProcessorManager = processorManager;
-    globalThis.strRayProcessorManager = processorManager; // backward compat
+    globalThis.strRayProcessorManager = processorManager;
     frameworkLogger.log("stringray-activation", "processor pipeline activated", "success", { jobId });
 }
 async function activatePostProcessor(jobId) {
     frameworkLogger.log("stringray-activation", "activating post-processor system", "info", { jobId });
     const { PostProcessor } = await import("../postprocessor/PostProcessor");
     // Get existing state manager (should be initialized by boot orchestrator)
-    const stateManager = globalThis.xrayStateManager;
+    const stateManager = globalThis.strRayStateManager;
     if (!stateManager) {
         throw new Error("State manager not initialized - boot orchestrator must run first");
     }
     const postProcessor = new PostProcessor(stateManager, null, {});
-    globalThis.xrayPostProcessor = postProcessor;
-    globalThis.strRayPostProcessor = postProcessor; // backward compat
+    globalThis.strRayPostProcessor = postProcessor;
     frameworkLogger.log("stringray-activation", "post-processor system activated", "success", { jobId });
     const { pathResolver } = await import("../utils/path-resolver.js");
-    globalThis.xrayPathResolver = pathResolver;
-    globalThis.strRayPathResolver = pathResolver; // backward compat
+    globalThis.strRayPathResolver = pathResolver;
     frameworkLogger.log("stringray-activation", "path resolver activated", "success", { jobId });
     const { CodexInjector } = await import("./codex-injector.js");
     const codexInjector = new CodexInjector();
-    globalThis.xrayCodexInjector = codexInjector;
-    globalThis.strRayCodexInjector = codexInjector; // backward compat
+    globalThis.strRayCodexInjector = codexInjector;
     frameworkLogger.log("stringray-activation", "codex injector activated", "success", { jobId });
 }
-//# sourceMappingURL=xray-activation.js.map

package/dist/delegation/agent-delegator.js

@@ -45,9 +45,9 @@ export class AgentDelegator {
      */
     loadRoutingMappings() {
         const candidates = [
-            path.resolve(process.cwd(), ".xray/routing-mappings.json"),
+            path.resolve(process.cwd(), ".strray/routing-mappings.json"),
             path.resolve(process.cwd(), "xray/routing-mappings.json"),
-            path.resolve(process.cwd(), ".opencode/xray/routing-mappings.json"),
+            path.resolve(process.cwd(), ".opencode/strray/routing-mappings.json"),
             path.resolve(process.cwd(), "routing-mappings.json"),
         ];
         for (const p of candidates) {
@@ -451,7 +451,7 @@ export class AgentDelegator {
    */
     resolveProjectDirectory() {
         const root = process.cwd();
-        if (fs.existsSync(`${root}/package.json`) || fs.existsSync(`${root}/xray.config.json`)) {
+        if (fs.existsSync(`${root}/package.json`) || fs.existsSync(`${root}/strray.config.json`)) {
             return root;
         }
         let current = root;
@@ -767,4 +767,3 @@ export class AgentDelegator {
 export function createAgentDelegator(stateManager, configLoader) {
     return new AgentDelegator(stateManager, configLoader);
 }
-//# sourceMappingURL=agent-delegator.js.map

package/dist/delegation/agent-expertise.js

@@ -154,4 +154,3 @@ export function getTopExpertsForDomain(domain, count = 3) {
         .sort((a, b) => b.expertiseLevel - a.expertiseLevel)
         .slice(0, count);
 }
-//# sourceMappingURL=agent-expertise.js.map

package/dist/delegation/analytics/index.js

@@ -10,4 +10,3 @@
 export { RoutingOutcomeTracker, routingOutcomeTracker } from './outcome-tracker.js';
 export { RoutingAnalytics } from './routing-analytics.js';
 export { LearningEngine, learningEngine } from './learning-engine.js';
-//# sourceMappingURL=index.js.map

package/dist/delegation/analytics/learning-engine.js

@@ -275,4 +275,3 @@ export class LearningEngine {
  * Global learning engine instance (enabled by default)
  */
 export const learningEngine = new LearningEngine(true);
-//# sourceMappingURL=learning-engine.js.map

package/dist/delegation/analytics/outcome-tracker.js

@@ -277,4 +277,3 @@ export class RoutingOutcomeTracker {
  * Global routing outcome tracker instance
  */
 export const routingOutcomeTracker = new RoutingOutcomeTracker();
-//# sourceMappingURL=outcome-tracker.js.map

package/dist/delegation/analytics/routing-analytics.js

@@ -191,4 +191,3 @@ export class RoutingAnalytics {
         };
     }
 }
-//# sourceMappingURL=routing-analytics.js.map

package/dist/delegation/ast-code-parser.js

@@ -876,4 +876,3 @@ export class ASTCodeParser {
         return duplicates;
     }
 }
-//# sourceMappingURL=ast-code-parser.js.map

package/dist/delegation/codebase-context-analyzer.js

@@ -1038,4 +1038,3 @@ export class CodebaseContextAnalyzer {
 export const createCodebaseContextAnalyzer = (projectRoot, memoryConfig) => {
     return new CodebaseContextAnalyzer(projectRoot, memoryConfig);
 };
-//# sourceMappingURL=codebase-context-analyzer.js.map

package/dist/delegation/complexity-analyzer.js

@@ -280,4 +280,3 @@ export function getComplexityAnalyzer() {
 }
 // Backward compatibility: export singleton instance
 export const complexityAnalyzer = getComplexityAnalyzer();
-//# sourceMappingURL=complexity-analyzer.js.map

package/dist/delegation/complexity-core.js

@@ -217,4 +217,3 @@ export function generateReasoning(metrics, score, level) {
     }
     return reasoning;
 }
-//# sourceMappingURL=complexity-core.js.map

package/dist/delegation/config/types.js

@@ -4,4 +4,3 @@
  * Type definitions for task-skill routing system.
  */
 export {};
-//# sourceMappingURL=types.js.map

package/dist/delegation/dependency-graph-builder.js

@@ -407,4 +407,3 @@ export class DependencyGraphBuilder {
         return null;
     }
 }
-//# sourceMappingURL=dependency-graph-builder.js.map

package/dist/delegation/index.js

@@ -13,11 +13,9 @@ export { SessionCoordinator, createSessionCoordinator, } from "./session-coordin
 export { RoutingOutcomeTracker, routingOutcomeTracker, } from "./analytics/index.js";
 export { RoutingAnalytics } from "./analytics/index.js";
 export { LearningEngine, learningEngine } from "./analytics/index.js";
+export { VotingCoordinator, createVotingCoordinator, } from "./voting-coordinator.js";
 export { WeightedVotingAggregator, createWeightedVotingAggregator, createDetailedVotingResult, DEFAULT_HISTORICAL_CONFIG, DEFAULT_CONFIDENCE_CONFIG, } from "./weighted-voting-aggregator.js";
 export { AdaptiveStrategySelector, adaptiveStrategySelector, selectVotingStrategy, } from "./strategy-selector.js";
-export { getAgentExpertise, getAgentExpertiseLevel, getVotingWeight, } from "./agent-expertise.js";
-export { scoreComplexity, routeToAgent, scoreAndRoute, } from "../nucleus/thin-dispatch.js";
-export { assessComplexity, shouldDelegate, getDelegationStrategy, } from "../tools/assess-complexity-tool.js";
-export { queryRouting, listAllRoutes, } from "../tools/query-routing-tool.js";
+export { getAgentExpertise, getAgentExpertiseLevel, getVotingWeight, getAgentsWithExpertiseDomain, getTopExpertsForDomain, } from "./agent-expertise.js";
 export { AgentMetricsSystem, getAgentMetricsSystem, initializeAgentMetrics, resetAgentMetricsSystem, } from "../metrics/agent-metrics.js";
-//# sourceMappingURL=index.js.map
+export { scoreComplexity, routeToAgent, scoreAndRoute } from "../nucleus/thin-dispatch.js";

package/dist/delegation/metrics-aggregator.js

@@ -333,4 +333,3 @@ export function exportMetrics(stateManager, format = "json") {
             return exportMetrics(stateManager, "json");
     }
 }
-//# sourceMappingURL=metrics-aggregator.js.map

package/dist/delegation/session-coordinator.js

@@ -350,4 +350,3 @@ export class SessionCoordinator {
 export const createSessionCoordinator = (stateManager) => {
     return new SessionCoordinator(stateManager);
 };
-//# sourceMappingURL=session-coordinator.js.map

package/dist/delegation/strategy-selector.js

@@ -106,4 +106,3 @@ export const adaptiveStrategySelector = new AdaptiveStrategySelector();
 export function selectVotingStrategy(complexity, riskLevel, hasSecurityConcerns = false, hasArchitecturalImpact = false, participantCount = 3) {
     return adaptiveStrategySelector.selectStrategyWithDefaults(complexity, riskLevel, hasSecurityConcerns, hasArchitecturalImpact, participantCount);
 }
-//# sourceMappingURL=strategy-selector.js.map