config

type ConceptSynonyms map[string][]string

type ConfusionPair struct {
	// ToolA is the first tool in the pair.
	ToolA string `yaml:"tool_a"`

	// ToolB is the second tool in the pair.
	ToolB string `yaml:"tool_b"`

	// ToolAPatterns boost ToolA when matched.
	ToolAPatterns []string `yaml:"tool_a_patterns"`

	// ToolBPatterns boost ToolB when matched.
	ToolBPatterns []string `yaml:"tool_b_patterns"`

	// BoostAmount is the score boost applied (default 3.0).
	BoostAmount float64 `yaml:"boost_amount"`
}

type EncyclopediaEntry struct {
	// Tool is the target tool name.
	Tool string `yaml:"tool"`

	// Tier is the action tier: "force", "boost", or "hint".
	Tier string `yaml:"tier"`

	// BoostAmount is the score bonus applied when tier=boost. Ignored for other tiers.
	// Range [0.0, 0.30] to nudge without overriding embedding scores.
	BoostAmount float64 `yaml:"boost_amount"`

	// Intents are regex or substring patterns describing user intent.
	Intents []IntentPattern `yaml:"intents"`

	// AntiSignals suppress this entry when ANY anti-signal matches the query.
	// Use specific phrases, not single words.
	AntiSignals []string `yaml:"anti_signals"`

	// ConflictWith names a tool that conflicts with this entry.
	// Used for documentation and future conflict resolution.
	ConflictWith string `yaml:"conflict_with,omitempty"`

	// Reason explains why this mapping exists (for logging/tracing).
	Reason string `yaml:"reason"`
}

type ForcedMapping struct {
	// Patterns are substring or regex patterns to match against the query.
	Patterns []string `yaml:"patterns"`

	// Tool is the tool to force when a pattern matches.
	Tool string `yaml:"tool"`

	// Reason explains why this mapping exists (for logging/tracing).
	Reason string `yaml:"reason"`
}

type IntentPattern struct {
	// Pattern is the matching pattern (regex if contains ".*", otherwise substring).
	Pattern string `yaml:"pattern"`

	// Description optionally explains what this pattern matches.
	Description string `yaml:"description,omitempty"`
}

type NegationRule struct {
	// NegationWords are words that negate meaning (e.g., "no", "not", "never").
	NegationWords []string `yaml:"negation_words"`

	// TriggerKeywords are keywords that, when negated, change the tool choice.
	TriggerKeywords []string `yaml:"trigger_keywords"`

	// WrongTool is the tool the router would likely choose without negation awareness.
	WrongTool string `yaml:"wrong_tool"`

	// CorrectTool is the tool to use when negation is detected.
	CorrectTool string `yaml:"correct_tool"`

	// Action is either "force" (skip router) or "boost" (increase score).
	Action string `yaml:"action"`

	// Reason explains why this rule exists.
	Reason string `yaml:"reason"`
}

type PreFilterConfig struct {
	// Enabled controls whether the pre-filter is active.
	Enabled bool `yaml:"enabled"`

	// MinCandidates is the minimum number of tools to return.
	// Ensures the router always has enough candidates.
	MinCandidates int `yaml:"min_candidates"`

	// MaxCandidates is the maximum number of tools to return.
	// Limits the router's classification space.
	MaxCandidates int `yaml:"max_candidates"`

	// NegationProximity is the maximum word distance between a negation word
	// and a trigger keyword for negation detection to fire.
	NegationProximity int `yaml:"negation_proximity"`

	// ScoringMode controls Phase 3 scoring: "hybrid" (0.4 BM25 + 0.6 embedding)
	// or "embedding_primary" (pure embedding, passthrough on fallback).
	ScoringMode string `yaml:"scoring_mode"`

	// ScoreGapThreshold is the minimum score drop between consecutive tools
	// that triggers a cutoff. Tools below the gap are excluded. Default: 0.15.
	ScoreGapThreshold float64 `yaml:"score_gap_threshold"`

	// ScoreFloor is the minimum absolute score for inclusion. Default: 0.30.
	ScoreFloor float64 `yaml:"score_floor"`

	// AlwaysInclude lists tool names that must always be in the narrowed set.
	AlwaysInclude []string `yaml:"always_include"`

	// ForcedMappings maps exact phrase patterns to deterministic tool selections.
	ForcedMappings []ForcedMapping `yaml:"forced_mappings"`

	// NegationRules detect negation patterns that change tool selection.
	NegationRules []NegationRule `yaml:"negation_rules"`

	// ConfusionPairs resolve ambiguity between frequently confused tools.
	ConfusionPairs []ConfusionPair `yaml:"confusion_pairs"`

	// RoutingEncyclopedia maps user intent patterns to tools with tiered actions.
	// CB-62 Rev 2: Replaces ad-hoc forced_mappings/confusion_pairs over time.
	RoutingEncyclopedia []EncyclopediaEntry `yaml:"routing_encyclopedia"`
}

type ToolEntryYAML struct {
	Name      string                 `yaml:"name"`
	Keywords  []string               `yaml:"keywords"`
	UseWhen   string                 `yaml:"use_when"`
	AvoidWhen string                 `yaml:"avoid_when,omitempty"`
	InsteadOf []ToolSubstitutionYAML `yaml:"instead_of,omitempty"`
	Requires  []string               `yaml:"requires,omitempty"`
}

type ToolMatch struct {
	ToolName        string
	MatchCount      int
	MatchedKeywords []string
	Entry           *ToolRoutingEntry
}

type ToolRegistryYAML struct {
	Tools []ToolEntryYAML `yaml:"tools"`
}

type ToolRoutingEntry struct {
	// Name is the tool name.
	Name string

	// Keywords are query terms that trigger this tool.
	Keywords []string

	// UseWhen describes when to use this tool.
	UseWhen string

	// AvoidWhen describes when NOT to use this tool.
	AvoidWhen string

	// InsteadOf lists tool substitutions.
	InsteadOf []tools.ToolSubstitution

	// Requires lists prerequisites.
	Requires []string
}

type ToolRoutingRegistry struct {
	// contains filtered or unexported fields
}

type ToolSubstitutionYAML struct {
	Tool string `yaml:"tool"`
	When string `yaml:"when"`
}