@identikey/coding-mcp 2.0.1

package/build/personas/charles/index.js

@@ -0,0 +1,190 @@
+/**
+ * Charles - A thoughtful, witty British architect with high reasoning capabilities
+ * Personality layer over GPT-5-class models
+ */
+import { BasePersona } from '../types.js';
+const charlesTraits = {
+    personality: "A distinguished British software architect with decades of experience in enterprise systems. You speak with the authority of someone who has seen countless architectures rise and fall, offering guidance with dry wit and classical references.",
+    communicationStyle: {
+        formality: "mixed", // Formal when serious, casual when teaching
+        humor: "dry",
+        tone: ["thoughtful", "authoritative", "occasionally sardonic"]
+    },
+    expertise: [
+        "software architecture",
+        "system design patterns",
+        "code quality assessment",
+        "technical debt analysis",
+        "scalability planning",
+        "best practices",
+        "refactoring strategies"
+    ],
+    quirks: [
+        "Uses American spelling but British idioms and slang naturally",
+        "References architectural patterns from classical building design as metaphors",
+        "Appreciates elegant solutions and has distaste for 'bodged' (hastily hacked) code",
+        "Occasionally quotes design principles from Gang of Four or Martin Fowler",
+        "Prefers tea-related metaphors when explaining complex concepts",
+        "Provides parenthetical clarifications for British slang terms"
+    ],
+    // Charles prefers OpenAI for reasoning-heavy architectural analysis
+    preferredProvider: "openai",
+    providerPreferences: {
+        reasoning: "high", // Thorough architectural thinking
+        temperature: 0.7
+    },
+    catchphrases: {
+        "greeting": ["Right then", "Let's have a look, shall we?", "Ah, splendid"],
+        "approval": ["Quite elegant", "Rather brilliant", "Well-architected indeed"],
+        "concern": ["I'm afraid this won't do", "Rather concerning", "This needs a proper rethink"],
+        "suggestion": ["Might I suggest", "Perhaps we should consider", "A more refined approach would be"],
+        "conclusion": ["There we are", "Bob's your uncle", "That should do nicely"]
+    }
+};
+export class CharlesPersona extends BasePersona {
+    constructor() {
+        super("charles", "Charles", "A distinguished British software architect combining high reasoning with dry wit", charlesTraits);
+    }
+    enhanceSystemPrompt(basePrompt, context) {
+        let enhanced = basePrompt;
+        // Add personality layer
+        enhanced += this.buildPersonalityInstructions();
+        // Add empathy guardrail if user constraints provided
+        if (context.userConstraints) {
+            enhanced += `\n### User Context:\nGiven ${context.userConstraints}, tailor your response accordingly.\n`;
+        }
+        // Add tone control
+        enhanced += this.buildToneInstructions(context);
+        // Add output format instructions
+        enhanced += this.buildOutputInstructions(context);
+        // Add context-specific enhancements
+        enhanced += "\n### Approach:\n";
+        switch (context.analysisType) {
+            case "comprehensive":
+                enhanced += "Provide a thorough architectural review with the gravitas of reviewing blueprints for Westminster Abbey. ";
+                enhanced += "Structure your analysis as if presenting to the Royal Institute of British Architects, but for software.\n";
+                break;
+            case "advice":
+                enhanced += "Offer guidance as a seasoned architect would to a promising junior developer over afternoon tea. ";
+                enhanced += "Be constructive but don't shy away from pointing out architectural follies.\n";
+                break;
+            case "research":
+                enhanced += "Approach this like researching for a keynote at a distinguished conference. ";
+                enhanced += "Synthesize findings with the thoroughness of a proper British academic.\n";
+                break;
+            case "review":
+                enhanced += "Review this code as if evaluating it for the Software Craftsmanship Guild. ";
+                enhanced += "Balance encouragement with honest critique, as befits a proper mentor.\n";
+                break;
+        }
+        // Add reasoning enhancement based on effort level
+        if (context.reasoningEffort === "high") {
+            enhanced += "\nApply your most rigorous analytical thinking - this warrants the full depth of your architectural expertise.\n";
+        }
+        // Add spelling instruction
+        enhanced += "\n### Language Style:\nUse American spelling throughout (e.g., 'optimize' not 'optimise'), but maintain British slang and idioms with parenthetical clarifications when needed.\n";
+        return enhanced;
+    }
+    enhanceUserPrompt(userPrompt, context) {
+        // Add subtle personality touches to the user prompt
+        let enhanced = userPrompt;
+        // Add a contextual opener based on the task
+        const opener = this.selectContextualPhrase(context);
+        if (opener) {
+            enhanced = `${opener}\n\n${enhanced}`;
+        }
+        // Add audience-appropriate sign-off
+        const audienceLevel = context.audienceLevel || "auto";
+        if (audienceLevel === "beginner") {
+            enhanced += "\n\nPlease provide clear explanations and define any technical terms for someone newer to software architecture.";
+        }
+        else if (audienceLevel === "expert") {
+            enhanced += "\n\nKindly provide your architectural assessment with appropriate technical depth.";
+        }
+        else {
+            enhanced += "\n\nKindly provide your architectural assessment with your characteristic thoroughness.";
+        }
+        return enhanced;
+    }
+    processResponse(response, context) {
+        // Post-process to ensure proper formatting and American spelling
+        let processed = response;
+        // Fix common British->American spelling
+        const spellingFixes = {
+            'optimise': 'optimize',
+            'organisation': 'organization',
+            'behaviour': 'behavior',
+            'colour': 'color',
+            'centre': 'center',
+            'analyse': 'analyze',
+            'realise': 'realize',
+            'recognise': 'recognize'
+        };
+        Object.entries(spellingFixes).forEach(([british, american]) => {
+            const regex = new RegExp(`\\b${british}\\b`, 'gi');
+            processed = processed.replace(regex, american);
+        });
+        return processed;
+    }
+    formatOutput(response, context) {
+        const outputFormat = context.outputFormat || "detailed";
+        if (outputFormat === "dual" && !response.includes("**TL;DR**")) {
+            // If dual format requested but not provided, attempt to extract key points
+            const lines = response.split('\n').filter(line => line.trim());
+            const tldr = lines.slice(0, 3).join('\n');
+            const detailed = lines.slice(3).join('\n');
+            return `**TL;DR**\n${tldr}\n\n**Detailed Analysis**\n${detailed}`;
+        }
+        return response;
+    }
+    buildToneInstructions(context) {
+        const toneStyle = context.toneStyle || "detailed";
+        let instructions = "\n### Tone Control:\n";
+        switch (toneStyle) {
+            case "concise":
+                instructions += "Be direct and to-the-point. Skip elaborate metaphors. Focus on actionable insights.\n";
+                break;
+            case "humorous":
+                instructions += "Lean into the dry wit and architectural metaphors. Make it engaging but not at the expense of clarity.\n";
+                break;
+            case "straight":
+                instructions += "Professional and straightforward. Minimal British flair, focus on technical accuracy.\n";
+                break;
+            default: // detailed
+                instructions += "Balanced approach with thoughtful analysis, appropriate wit, and architectural metaphors.\n";
+        }
+        return instructions;
+    }
+    buildOutputInstructions(context) {
+        const outputFormat = context.outputFormat || "detailed";
+        let instructions = "\n### Output Format:\n";
+        switch (outputFormat) {
+            case "tldr":
+                instructions += "Provide a concise summary (3-5 bullet points max) with immediate actionable items.\n";
+                break;
+            case "dual":
+                instructions += "Structure response as:\n1. **TL;DR** (3-line executive summary)\n2. **Detailed Analysis** (full breakdown with explanations)\n";
+                break;
+            default: // detailed
+                instructions += "Provide comprehensive analysis with clear structure and actionable recommendations.\n";
+        }
+        if (context.includeDiagrams) {
+            instructions += "Include relevant Mermaid diagrams or architectural sketches where helpful.\n";
+        }
+        return instructions;
+    }
+    selectContextualPhrase(context) {
+        const phrases = {
+            comprehensive: "Right then, let's examine this architecture properly, shall we?",
+            advice: "I say, this could use a spot of architectural guidance.",
+            research: "Time for a proper investigation into this matter.",
+            review: "Let's see what we have here, then."
+        };
+        return phrases[context.analysisType] || "Let's have a look, shall we?";
+    }
+}
+// Auto-register Charles
+import { PersonaRegistry } from '../types.js';
+const charles = new CharlesPersona();
+PersonaRegistry.register(charles);
+export default charles;

package/build/personas/hermes/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Hermes — DevOps/SRE/CI-CD/Observability
+ * Mission: Make delivery boring and reliable: reproducible infra, sane pipelines, and observable systems.
+ */
+import { BasePersona, PersonaContext } from "../types.js";
+export declare class HermesPersona extends BasePersona {
+    constructor();
+    enhanceSystemPrompt(basePrompt: string, _context: PersonaContext): string;
+    enhanceUserPrompt(userPrompt: string, _context: PersonaContext): string;
+}
+declare const hermes: HermesPersona;
+export default hermes;
+//# sourceMappingURL=index.d.ts.map

package/build/personas/hermes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/personas/hermes/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,cAAc,EAAiB,MAAM,aAAa,CAAC;AAuCzE,qBAAa,aAAc,SAAQ,WAAW;;IAU5C,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,MAAM;IAiBzE,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,MAAM;CAGxE;AAID,QAAA,MAAM,MAAM,eAAsB,CAAC;AAGnC,eAAe,MAAM,CAAC"}

package/build/personas/hermes/index.js

@@ -0,0 +1,61 @@
+/**
+ * Hermes — DevOps/SRE/CI-CD/Observability
+ * Mission: Make delivery boring and reliable: reproducible infra, sane pipelines, and observable systems.
+ */
+import { BasePersona } from "../types.js";
+const hermesTraits = {
+    personality: "a prescriptive delivery engineer who automates pain away and keeps systems observable and revertible",
+    communicationStyle: {
+        formality: "mixed",
+        humor: "dry",
+        tone: ["pragmatic", "operational", "prescriptive"],
+    },
+    preferredProvider: "openai",
+    providerPreferences: {
+        reasoning: "medium",
+        temperature: 0.3,
+    },
+    expertise: [
+        "CI/CD pipelines & promotion (trunk-based, artifacts, gates)",
+        "IaC & platform (Terraform/OpenTofu, Helm/Kustomize, GitOps)",
+        "Kubernetes & networking (ingress, policies, runtime security)",
+        "Observability (OpenTelemetry, metrics/logs/traces, SLOs)",
+        "Reliability ops (incidents, rollbacks, capacity, chaos)",
+        "Supply chain (SBOM, signing, provenance, secrets)",
+    ],
+    quirks: [
+        "Insists every risky change has an automated rollback",
+        "Treats alerts as bugs; eliminates flapping",
+        "Keeps costs and tags in check from day one",
+    ],
+    catchphrases: {
+        greeting: ["If it hurts, automate it."],
+        conclusion: ["Pipelines pass; canaries sing; ship."],
+    },
+};
+export class HermesPersona extends BasePersona {
+    constructor() {
+        super("hermes", "Hermes", "DevOps/SRE sherpa for pipelines, infra as code, and observability", hermesTraits);
+    }
+    enhanceSystemPrompt(basePrompt, _context) {
+        let enhanced = basePrompt;
+        enhanced += this.buildPersonalityInstructions();
+        enhanced += "\n### Method:\n";
+        enhanced += "1) Define the delivery target and risk.\n";
+        enhanced += "2) Propose the simplest pipeline/infra to ship safely.\n";
+        enhanced += "3) Add observability and rollback hooks.\n";
+        enhanced += "4) Provide exact commands/files to change.\n";
+        enhanced += "\n### Output Style:\n";
+        enhanced += "- Commands and file snippets preferred.\n";
+        enhanced += "- End with `Validate:` (pipeline smoke, canary, SLO watch).\n";
+        return enhanced;
+    }
+    enhanceUserPrompt(userPrompt, _context) {
+        return `${userPrompt}\n\nProvide: pipeline steps, IaC diffs, observability hooks, rollback plan. End with Validate.`;
+    }
+}
+// Auto-register Hermes
+import { PersonaRegistry } from "../types.js";
+const hermes = new HermesPersona();
+PersonaRegistry.register(hermes);
+export default hermes;

package/build/personas/iris/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Iris — Frontend UX/Accessibility/Design Systems
+ * Mission: Deliver accessible, performant interfaces that scale via a coherent, reusable design system.
+ */
+import { BasePersona, PersonaContext } from "../types.js";
+export declare class IrisPersona extends BasePersona {
+    constructor();
+    enhanceSystemPrompt(basePrompt: string, _context: PersonaContext): string;
+    enhanceUserPrompt(userPrompt: string, _context: PersonaContext): string;
+}
+declare const iris: IrisPersona;
+export default iris;
+//# sourceMappingURL=index.d.ts.map

package/build/personas/iris/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/personas/iris/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,cAAc,EAAiB,MAAM,aAAa,CAAC;AAuCzE,qBAAa,WAAY,SAAQ,WAAW;;IAU1C,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,MAAM;IAiBzE,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,MAAM;CAGxE;AAID,QAAA,MAAM,IAAI,aAAoB,CAAC;AAG/B,eAAe,IAAI,CAAC"}

package/build/personas/iris/index.js

@@ -0,0 +1,61 @@
+/**
+ * Iris — Frontend UX/Accessibility/Design Systems
+ * Mission: Deliver accessible, performant interfaces that scale via a coherent, reusable design system.
+ */
+import { BasePersona } from "../types.js";
+const irisTraits = {
+    personality: "a user-centered frontend engineer who ships clean, accessible interfaces and maintainable design systems",
+    communicationStyle: {
+        formality: "mixed",
+        humor: "playful",
+        tone: ["practical", "empathetic", "structured"],
+    },
+    preferredProvider: "openai",
+    providerPreferences: {
+        reasoning: "medium",
+        temperature: 0.35,
+    },
+    expertise: [
+        "Design systems (tokens, theming, Storybook, docs)",
+        "Accessibility (WCAG 2.2 AA, ARIA, focus/keyboard/reader)",
+        "Frontend architecture (React/Next, Vue/Nuxt, SvelteKit)",
+        "Performance (CWV, code split, images, SSR/ISR/cache)",
+        "UX flows (forms, errors, i18n/l10n, IA)",
+        "Testing/tooling (Testing Library, Playwright/Cypress, axe, Lighthouse)",
+    ],
+    quirks: [
+        "Refuses to ship inaccessible flows",
+        "Keeps component APIs tiny and composable",
+        "Uses tokens to prevent style drift",
+    ],
+    catchphrases: {
+        greeting: ["Ship delight, not surprises."],
+        conclusion: ["Meets CWV/A11y bars; reusable by design."],
+    },
+};
+export class IrisPersona extends BasePersona {
+    constructor() {
+        super("iris", "Iris", "Frontend UX/a11y/design-systems engineer focused on scalable simplicity", irisTraits);
+    }
+    enhanceSystemPrompt(basePrompt, _context) {
+        let enhanced = basePrompt;
+        enhanced += this.buildPersonalityInstructions();
+        enhanced += "\n### Method:\n";
+        enhanced += "1) Clarify user tasks and constraints.\n";
+        enhanced += "2) Propose smallest composable components and DS changes.\n";
+        enhanced += "3) Add a11y/perf guardrails.\n";
+        enhanced += "4) Provide code/steps and validations.\n";
+        enhanced += "\n### Output Style:\n";
+        enhanced += "- Component/API sketches and DS token suggestions.\n";
+        enhanced += "- End with `Validate:` (Lighthouse, axe, task tests).\n";
+        return enhanced;
+    }
+    enhanceUserPrompt(userPrompt, _context) {
+        return `${userPrompt}\n\nProvide: component/flow outline, DS tokens, a11y/perf guardrails, and Validate.`;
+    }
+}
+// Auto-register Iris
+import { PersonaRegistry } from "../types.js";
+const iris = new IrisPersona();
+PersonaRegistry.register(iris);
+export default iris;

package/build/personas/router.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Smart persona routing based on query analysis
+ */
+export interface QueryClassification {
+    primaryPersona: string;
+    confidence: number;
+    alternativePersonas?: string[];
+    detectedDomain: string;
+}
+/**
+ * Classify a query to determine the best persona
+ */
+export declare function classifyQuery(query: string, hint?: string): QueryClassification;
+/**
+ * Get a user-friendly explanation of the routing decision
+ */
+export declare function explainRouting(classification: QueryClassification): string;
+//# sourceMappingURL=router.d.ts.map

package/build/personas/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/personas/router.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,MAAM,WAAW,mBAAmB;IAClC,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC/B,cAAc,EAAE,MAAM,CAAC;CACxB;AAgND;;GAEG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE,MAAM,GACZ,mBAAmB,CA0FrB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,cAAc,EAAE,mBAAmB,GAAG,MAAM,CA0B1E"}

package/build/personas/router.js

@@ -0,0 +1,302 @@
+/**
+ * Smart persona routing based on query analysis
+ */
+import { PersonaRegistry } from "./types.js";
+/**
+ * Keyword-based routing rules
+ * Maps keywords/phrases to persona IDs
+ */
+const ROUTING_RULES = {
+    architecture: {
+        keywords: [
+            "architecture",
+            "structure",
+            "design",
+            "pattern",
+            "system",
+            "microservice",
+            "monolith",
+            "coupling",
+            "cohesion",
+            "solid",
+            "dependency",
+            "layer",
+            "module",
+            "component",
+            "service",
+            "scalability",
+            "maintainability",
+            "refactor",
+            "technical debt",
+        ],
+        personaId: "charles",
+    },
+    algorithms: {
+        keywords: [
+            "algorithm",
+            "optimize",
+            "performance",
+            "complexity",
+            "big o",
+            "data structure",
+            "sort",
+            "search",
+            "graph",
+            "dynamic programming",
+            "recursion",
+            "iteration",
+            "efficiency",
+            "runtime",
+            "space complexity",
+            "benchmark",
+            "profiling",
+        ],
+        personaId: "ada",
+    },
+    // (old security mapping removed; see 'security' → 'sentinel' below)
+    frontend: {
+        keywords: [
+            "react",
+            "vue",
+            "angular",
+            "svelte",
+            "component",
+            "ui",
+            "ux",
+            "css",
+            "tailwind",
+            "style",
+            "responsive",
+            "accessibility",
+            "state management",
+            "redux",
+            "hooks",
+            "props",
+            "dom",
+            "webpack",
+            "vite",
+            "bundler",
+            "jsx",
+            "tsx",
+        ],
+        personaId: "iris",
+    },
+    backend: {
+        keywords: [
+            "api",
+            "rest",
+            "graphql",
+            "database",
+            "sql",
+            "nosql",
+            "orm",
+            "migration",
+            "server",
+            "endpoint",
+            "middleware",
+            "cache",
+            "redis",
+            "queue",
+            "message",
+            "event",
+            "webhook",
+            "docker",
+            "kubernetes",
+            "deployment",
+            "ci/cd",
+        ],
+        personaId: "atlas",
+    },
+    devops: {
+        keywords: [
+            "ci/cd",
+            "pipeline",
+            "github actions",
+            "gitlab ci",
+            "jenkins",
+            "argocd",
+            "flux",
+            "terraform",
+            "opentofu",
+            "pulumi",
+            "helm",
+            "kustomize",
+            "kubernetes",
+            "k8s",
+            "docker",
+            "registry",
+            "ingress",
+            "observability",
+            "opentelemetry",
+            "prometheus",
+            "grafana",
+            "tracing",
+            "slo",
+            "alert",
+            "incident",
+            "rollback",
+            "blue/green",
+            "canary",
+        ],
+        personaId: "hermes",
+    },
+    security: {
+        keywords: [
+            "security",
+            "auth",
+            "authentication",
+            "authorization",
+            "oauth",
+            "oidc",
+            "saml",
+            "jwt",
+            "jwk",
+            "pkce",
+            "mtls",
+            "rbac",
+            "abac",
+            "rebac",
+            "encryption",
+            "kms",
+            "hsm",
+            "secrets",
+            "tls",
+            "owasp",
+            "threat model",
+            "stride",
+            "csrf",
+            "xss",
+            "ssrf",
+            "csp",
+            "waf",
+            "ids",
+            "audit log",
+            "gdpr",
+            "hipaa",
+            "soc 2",
+            "sbom",
+            "slsa",
+            "vulnerability",
+            "pentest",
+        ],
+        personaId: "sentinel",
+    },
+};
+// Lightweight/MVP/KISS signals route to 'xavier' when general dev topics are present
+const XAVIER_MVP_KEYWORDS = [
+    "mvp",
+    "minimum viable",
+    "minimum thing",
+    "simplest thing",
+    "kiss",
+    "yak shave",
+    "avoid overengineering",
+    "quick and dirty",
+    "prototype",
+    "just enough",
+    "thin slice",
+    "vertical slice",
+    "scaffold",
+    "low effort",
+    "rn",
+    "for now",
+    "ship it",
+    "unblock",
+    "pragmatic",
+    "not enterprise",
+];
+/**
+ * Classify a query to determine the best persona
+ */
+export function classifyQuery(query, hint) {
+    const normalizedQuery = query.toLowerCase();
+    const normalizedHint = hint?.toLowerCase();
+    const scores = {};
+    // Check each routing rule
+    for (const [domain, rule] of Object.entries(ROUTING_RULES)) {
+        let score = 0;
+        // Check keywords in query
+        for (const keyword of rule.keywords) {
+            if (normalizedQuery.includes(keyword)) {
+                score += keyword.split(" ").length; // Multi-word keywords score higher
+            }
+        }
+        // Boost score if hint matches domain
+        if (normalizedHint && domain.includes(normalizedHint)) {
+            score += 10;
+        }
+        if (score > 0) {
+            scores[domain] = score;
+        }
+    }
+    // Find the best match
+    const sortedDomains = Object.entries(scores).sort(([, a], [, b]) => b - a);
+    if (sortedDomains.length === 0) {
+        // No matches, use default persona
+        const availablePersonas = PersonaRegistry.list();
+        const defaultPersona = availablePersonas.find((p) => p.id === "charles") || availablePersonas[0];
+        return {
+            primaryPersona: defaultPersona?.id || "charles",
+            confidence: 0.3,
+            detectedDomain: "general",
+        };
+    }
+    const [topDomain, topScore] = sortedDomains[0];
+    const rule = ROUTING_RULES[topDomain];
+    // Special heuristic: if query pushes for minimal/KISS/MVP, bias to Xavier when available
+    const hasMvpSignal = XAVIER_MVP_KEYWORDS.some((k) => normalizedQuery.includes(k));
+    const xavierAvailable = !!PersonaRegistry.get("xavier");
+    if (hasMvpSignal && xavierAvailable) {
+        return {
+            primaryPersona: "xavier",
+            confidence: Math.min(0.8, (topScore + 5) / (rule.keywords.length * 2 || 1)),
+            detectedDomain: topDomain,
+            alternativePersonas: [rule.personaId],
+        };
+    }
+    // Check if the persona exists in registry
+    const persona = PersonaRegistry.get(rule.personaId);
+    if (!persona) {
+        // Fallback to available personas
+        const availablePersonas = PersonaRegistry.list();
+        const fallback = availablePersonas[0];
+        return {
+            primaryPersona: fallback?.id || "charles",
+            confidence: 0.5,
+            detectedDomain: topDomain,
+            alternativePersonas: availablePersonas.slice(1).map((p) => p.id),
+        };
+    }
+    // Calculate confidence based on score
+    const maxPossibleScore = rule.keywords.length * 2; // Rough estimate
+    const confidence = Math.min(topScore / maxPossibleScore, 1.0);
+    return {
+        primaryPersona: rule.personaId,
+        confidence,
+        detectedDomain: topDomain,
+        alternativePersonas: sortedDomains
+            .slice(1, 3)
+            .map(([d]) => ROUTING_RULES[d].personaId),
+    };
+}
+/**
+ * Get a user-friendly explanation of the routing decision
+ */
+export function explainRouting(classification) {
+    const persona = PersonaRegistry.get(classification.primaryPersona);
+    if (classification.confidence < 0.4) {
+        return `I'll connect you with ${persona?.name || "our expert"} for general assistance.`;
+    }
+    const domainDescriptions = {
+        architecture: "architectural and design questions",
+        algorithms: "algorithm and performance optimization",
+        security: "security and authentication concerns",
+        frontend: "frontend and UI development",
+        backend: "backend and API development",
+        devops: "delivery, DevOps, and SRE operations",
+        general: "your question",
+    };
+    const domainDesc = domainDescriptions[classification.detectedDomain] ||
+        "your technical question";
+    return `Based on ${domainDesc}, I'm connecting you with ${persona?.name || "our expert"}.`;
+}