nexus-agents 2.102.8 → 2.103.0

package/dist/{chunk-WVZT4JGL.js → chunk-3TOHOAB2.js}

@@ -6,10 +6,10 @@ import {
 import {
   getTokenEnvVars,
   resolveToken
-} from "./chunk-ZW6NKOXT.js";
+} from "./chunk-YMBG7LCM.js";
 import {
   executeExpert
-} from "./chunk-NBAARQC6.js";
+} from "./chunk-F6X6UH6D.js";
 import {
   EventTopics,
   JobStatusSchema,
@@ -30,7 +30,7 @@ import {
   writeJobComplete,
   writeJobFailed,
   writeJobPending
-} from "./chunk-P6TYLTER.js";
+} from "./chunk-TY2M7UQD.js";
 import {
   REGISTRY_PATH,
   getProjectRoot,
@@ -39,19 +39,19 @@ import {
   normalizeTopicToCanonical,
   savePapersRegistry,
   synthesizeResearch
-} from "./chunk-GAX6YG5E.js";
+} from "./chunk-STLETCQJ.js";
 import {
   IssueTriage,
   createAuditTrail,
   createGraphAuditBridge
-} from "./chunk-G3QQOU4H.js";
+} from "./chunk-3VSLKTD6.js";
 import {
   resolveEnvMode,
   sanitizeInput
-} from "./chunk-Q7FINCKE.js";
+} from "./chunk-NO66DOR2.js";
 import {
   withPrerequisite
-} from "./chunk-TLTWQAHI.js";
+} from "./chunk-4FIY62UC.js";
 import {
   NOOP_NOTIFIER,
   RateLimiter,
@@ -71,10 +71,10 @@ import {
   withAccessPolicy,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-VJFUIP6N.js";
+} from "./chunk-FESEHMBN.js";
 import {
   generateSecurityPlan
-} from "./chunk-ER6YMAZU.js";
+} from "./chunk-BUZ62ZOK.js";
 import {
   analyzeGitHubRepo
 } from "./chunk-HFOQKCD2.js";
@@ -82,26 +82,26 @@ import {
   getContextForTask,
   inferTaskCategory,
   summarizeContextForPrompt
-} from "./chunk-74QFV5ON.js";
+} from "./chunk-ANHBUWOI.js";
 import {
   DEFAULT_RELEVANCE_CONFIG,
   MemoryImportance,
   calculateTextJaccardSimilarity,
   getToolMemory
-} from "./chunk-OIFFZHSV.js";
+} from "./chunk-S5LL7Y77.js";
 import {
   DEFAULT_TASK_TTL_MS,
   DEFAULT_TOOL_RATE_LIMITS,
   clampTaskTtl
-} from "./chunk-2NSCF4PI.js";
+} from "./chunk-FPY53SSC.js";
 import {
   getAvailabilityCache,
   getCliForModelId,
   resolveFallback
-} from "./chunk-UXBZ346L.js";
+} from "./chunk-6XWIR6JJ.js";
 import {
   DEFAULTS
-} from "./chunk-GUHVV3Q4.js";
+} from "./chunk-M6QD4H7S.js";
 import {
   resolveInsideRoot
 } from "./chunk-NUBSJGQZ.js";
@@ -117,11 +117,11 @@ import {
   getAvailableClis,
   sleep,
   withTimeout
-} from "./chunk-ODN2O3XZ.js";
+} from "./chunk-K4H5LCSU.js";
 import {
   generateHyphenId,
   generateUUID
-} from "./chunk-WPGVI2F2.js";
+} from "./chunk-VOGIG42V.js";
 import {
   BUILT_IN_EXPERTS,
   BuiltInExpertTypeSchema,
@@ -133,7 +133,7 @@ import {
 } from "./chunk-PQHVC4BD.js";
 import {
   createSessionMemory
-} from "./chunk-JEOFSMRI.js";
+} from "./chunk-QSTVUC2C.js";
 import {
   AGENT_ROUTER_TIMEOUTS,
   API_TIMEOUTS,
@@ -164,6 +164,7 @@ import {
   WeatherReportInputSchema,
   WorkflowError,
   buildCapabilityProfiles,
+  buildDefaultModelSources,
   categorizeOutcomeErrorMessage,
   clamp,
   clamp01,
@@ -181,6 +182,7 @@ import {
   formatZodError,
   generateWeatherReport,
   getAdaptiveBonus,
+  getDefaultAvailableModelsCache,
   getDefaultModelForCli,
   getDefaultRegistry,
   getErrorMessage,
@@ -205,7 +207,7 @@ import {
   resolveModelIdentitySync,
   toExpertTaskAnalysisResult,
   withStep
-} from "./chunk-EYIIQ7KE.js";
+} from "./chunk-Q732LOXE.js";
 import {
   nexusDataPath,
   nexusDataPathEnsure
@@ -23567,10 +23569,10 @@ function calculateZStatistic(params) {
 function calculateDifferenceCI(p1, p2, total1, total2, confidence) {
   const difference = p1 - p2;
   const seDiff = Math.sqrt(p1 * (1 - p1) / (total1 || 1) + p2 * (1 - p2) / (total2 || 1));
-  const z113 = getZScore(confidence);
+  const z114 = getZScore(confidence);
   return {
-    lower: difference - z113 * seDiff,
-    upper: difference + z113 * seDiff,
+    lower: difference - z114 * seDiff,
+    upper: difference + z114 * seDiff,
     estimate: difference,
     confidence,
     n: total1 + total2,
@@ -23593,11 +23595,11 @@ function proportionConfidenceInterval(successes, total, options = {}) {
       standardError: 0
     };
   }
-  const z113 = getZScore(opts.confidence);
-  const z210 = z113 * z113;
+  const z114 = getZScore(opts.confidence);
+  const z210 = z114 * z114;
   const denominator = 1 + z210 / n;
   const center = (p + z210 / (2 * n)) / denominator;
-  const margin = z113 / denominator * Math.sqrt(p * (1 - p) / n + z210 / (4 * n * n));
+  const margin = z114 / denominator * Math.sqrt(p * (1 - p) / n + z210 / (4 * n * n));
   const lower = Math.max(0, center - margin);
   const upper = Math.min(1, center + margin);
   const standardError = Math.sqrt(p * (1 - p) / n);
@@ -23627,8 +23629,8 @@ function meanConfidenceInterval(values, options = {}) {
   const variance = values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / (n - 1 || 1);
   const stdDev = Math.sqrt(variance);
   const standardError = stdDev / Math.sqrt(n);
-  const z113 = getZScore(opts.confidence);
-  const margin = z113 * standardError;
+  const z114 = getZScore(opts.confidence);
+  const margin = z114 * standardError;
   return {
     lower: mean - margin,
     upper: mean + margin,
@@ -26129,14 +26131,64 @@ function registerExpertsResource(server, logger56) {
   logger56.info("Registered experts resource", { uri: EXPERTS_RESOURCE_URI });
 }
 
+// src/mcp/resources/available-models-resource.ts
+var AVAILABLE_MODELS_URI = "nexus://available-models";
+var AVAILABLE_MODELS_NAME = "available-models";
+async function buildAvailableModelsPayload(cache = getDefaultAvailableModelsCache()) {
+  const all = await cache.getAll();
+  const bySource = /* @__PURE__ */ new Map();
+  for (const m of all) {
+    const list = bySource.get(m.source) ?? [];
+    list.push(m.id);
+    bySource.set(m.source, list);
+  }
+  return {
+    total: all.length,
+    sources: [...bySource.entries()].map(([source, ids]) => ({
+      source,
+      modelCount: ids.length,
+      ids
+    })),
+    note: "Live discovered model set (existence only). Empty if dynamic discovery is not enabled (NEXUS_DYNAMIC_MODELS)."
+  };
+}
+function registerAvailableModelsResource(server, logger56) {
+  server.registerResource(
+    AVAILABLE_MODELS_NAME,
+    AVAILABLE_MODELS_URI,
+    {
+      description: "Live, dynamically-discovered model set per transport (what routing can dispatch to now)",
+      mimeType: "application/json"
+    },
+    async () => {
+      logger56.debug("Reading available-models resource");
+      const payload = await buildAvailableModelsPayload();
+      return {
+        contents: [
+          {
+            uri: AVAILABLE_MODELS_URI,
+            mimeType: "application/json",
+            text: JSON.stringify(payload, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  logger56.info("Registered available-models resource", { uri: AVAILABLE_MODELS_URI });
+}
+
 // src/mcp/resources/index.ts
 function registerResources(server, logger56) {
   const log = logger56 ?? createLogger({ component: "mcp-resources" });
   log.info("Registering MCP resources");
-  registerModelsResource(server, log);
-  registerResearchResource(server, log);
-  registerExpertsResource(server, log);
-  log.info("All MCP resources registered", { count: 3 });
+  const registrars = [
+    registerModelsResource,
+    registerResearchResource,
+    registerExpertsResource,
+    registerAvailableModelsResource
+  ];
+  for (const register of registrars) register(server, log);
+  log.info("All MCP resources registered", { count: registrars.length });
 }
 
 // src/mcp/tools/run-workflow-types.ts
@@ -27013,7 +27065,7 @@ async function populateUnifiedContextOnState(state) {
   try {
     const taskCandidate = state["task"];
     if (typeof taskCandidate !== "string" || taskCandidate === "") return;
-    const { getContextForTask: getContextForTask2, inferTaskCategory: inferTaskCategory2 } = await import("./context-retriever-BE4DNAPM.js");
+    const { getContextForTask: getContextForTask2, inferTaskCategory: inferTaskCategory2 } = await import("./context-retriever-EFEWHU3Z.js");
     const ctx = await getContextForTask2({
       task: taskCandidate,
       category: inferTaskCategory2(taskCandidate),
@@ -42762,7 +42814,7 @@ async function tryIssueTriage(task) {
   try {
     const issueMatch = task.match(/github\.com\/([^/]+\/[^/]+)\/issues\/(\d+)/);
     if (issueMatch === null) return null;
-    const { createIssueTriage } = await import("./issue-triage-JGQTQVQI.js");
+    const { createIssueTriage } = await import("./issue-triage-MBNGFPVS.js");
     const triage = createIssueTriage();
     const owner = issueMatch[1] ?? "";
     const num = issueMatch[2] ?? "";
@@ -42790,7 +42842,7 @@ var VALID_TEMPLATES = /* @__PURE__ */ new Set([
 ]);
 async function classifyWithLLM(task) {
   try {
-    const { executeExpert: executeExpert2 } = await import("./expert-bridge-HLSKV3PK.js");
+    const { executeExpert: executeExpert2 } = await import("./expert-bridge-P4NWKKOI.js");
     const prompt = [
       "Classify this task into exactly one pipeline template.",
       "Templates: dev (implementation/bug fix/refactor), research (investigate/evaluate/compare),",
@@ -43696,7 +43748,7 @@ var memoryInitPromise = null;
 async function initPipelineMemory() {
   if (cachedMemory !== null) return cachedMemory;
   try {
-    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-O77ISZYP.js");
+    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-AG4IM3JY.js");
     const { getLearningDir } = await import("./learning-persistence-UKPO7RYK.js");
     const mem = createSessionMemory2(getLearningDir());
     mem.startSession(`pipeline-${String(getTimeProvider().now())}`);
@@ -43753,7 +43805,7 @@ function recordRoutingExperience(category, success, durationMs, tokensUsed = 0)
     callRecord(routingMemoryCache);
     return;
   }
-  routingMemoryInitPromise ??= import("./routing-memory-SCPATSY6.js").then(({ createRoutingMemory }) => {
+  routingMemoryInitPromise ??= import("./routing-memory-YECWDSDV.js").then(({ createRoutingMemory }) => {
     routingMemoryCache ??= createRoutingMemory();
     return routingMemoryCache;
   }).catch((error) => {
@@ -43787,7 +43839,7 @@ ${text}` : "";
 }
 async function getWeatherContext() {
   try {
-    const { generateWeatherReport: generateWeatherReport2 } = await import("./weather-report-BUPURZ6J.js");
+    const { generateWeatherReport: generateWeatherReport2 } = await import("./weather-report-WAOVQRGI.js");
     const report = generateWeatherReport2({ includeAdaptive: true });
     const mappings = "recommendedMappings" in report ? report.recommendedMappings : [];
     if (!Array.isArray(mappings) || mappings.length === 0) return "";
@@ -43805,7 +43857,7 @@ ${lines}
 }
 async function getMemoryContext(task) {
   try {
-    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-O77ISZYP.js");
+    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-AG4IM3JY.js");
     const { getLearningDir } = await import("./learning-persistence-UKPO7RYK.js");
     const memory = createSessionMemory2(getLearningDir(), { maxLearningsInContext: 10 });
     const learnings = memory.searchLearnings(task.slice(0, 200));
@@ -43914,7 +43966,7 @@ ${contextBlock}`;
       const strategy = config.votingStrategy ?? "higher_order";
       await postProgress(config, "Vote", `Running consensus with ${strategy} strategy...`);
       try {
-        const { executeVoting } = await import("./consensus-vote-VGQW6LCB.js");
+        const { executeVoting } = await import("./consensus-vote-4W2MOXL2.js");
         const votingResult = await executeVoting(
           {
             proposal: buildVoteProposal(plan, research),
@@ -44909,7 +44961,7 @@ async function searchCodebaseForTask(task) {
 }
 async function queryResearchRegistry(task) {
   try {
-    const { synthesizeResearch: synthesizeResearch2 } = await import("./research-helpers-synthesize-2HHHQP5I.js");
+    const { synthesizeResearch: synthesizeResearch2 } = await import("./research-helpers-synthesize-KJ7H75QA.js");
     const topic = task.split(/[.!?\n]/).filter((s) => s.trim().length > 10)[0]?.trim();
     if (topic === void 0) return null;
     const result = await synthesizeResearch2(topic.slice(0, 50));
@@ -44980,7 +45032,7 @@ function createScanStageWrapper() {
       try {
         const slug = ctx.task.match(/([a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+)/)?.[1];
         if (slug !== void 0) {
-          const { generateSecurityPlan: generateSecurityPlan2 } = await import("./repo-security-plan-6QUW6JW5.js");
+          const { generateSecurityPlan: generateSecurityPlan2 } = await import("./repo-security-plan-JRL6NQKO.js");
           const plan = await generateSecurityPlan2({ repo: slug, maxScanners: 10 });
           const recs = plan.recommendations.slice(0, 5).map((r) => `${r.priority}: ${r.displayName} (${r.category})`).join("; ");
           return output(PIPELINE_STATE_KEYS.FINDINGS, recs, getTimeProvider().now() - start, true);
@@ -46468,19 +46520,113 @@ function registerSuggestResearchTasksTool(server, deps) {
   logger56.info("Registered suggest_research_tasks tool");
 }
 
-// src/mcp/tools/pipeline-tool.ts
+// src/mcp/tools/list-available-models-tool.ts
 import { z as z104 } from "zod";
+var DESCRIPTION4 = "Probe every model-discovery transport (OpenRouter API + opencode/claude/codex/gemini CLIs) and report a per-transport health summary: probe ok/failed, model count, and a sample of ids. Use it to validate the CLIs and APIs are wired and reachable. Read-only; does not change routing.";
+var PROBE_TIMEOUT_MS = 12e3;
+var ListAvailableModelsInputSchema = z104.object({
+  includeModelIds: z104.boolean().optional().describe("Include the full model-id list per transport (default false \u2192 sample of 5 only)."),
+  includeOpenRouter: z104.boolean().optional().describe("Probe the OpenRouter live catalog (default true).")
+});
+async function probeSource(source, includeModelIds) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      reject(new Error(`probe timed out after ${String(PROBE_TIMEOUT_MS)}ms`));
+    }, PROBE_TIMEOUT_MS);
+  });
+  try {
+    const models = await Promise.race([source.listModels(), timeout]);
+    const ids = models.map((m) => m.id);
+    return {
+      transport: source.name,
+      ok: true,
+      modelCount: ids.length,
+      sampleModelIds: ids.slice(0, 5),
+      ...includeModelIds ? { modelIds: ids } : {}
+    };
+  } catch (error) {
+    return {
+      transport: source.name,
+      ok: false,
+      modelCount: 0,
+      sampleModelIds: [],
+      error: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+async function defaultSources(includeOpenRouter) {
+  const { createAllAdapters: createAllAdapters2 } = await import("./factory-BSWATZK3.js");
+  const adapters = createAllAdapters2();
+  return buildDefaultModelSources(adapters, { includeOpenRouter });
+}
+async function listAvailableModelsHandler(args, deps, logger56) {
+  const parsed = ListAvailableModelsInputSchema.safeParse(args);
+  if (!parsed.success) {
+    return toolStructuredError({
+      errorCategory: "validation",
+      message: `Validation error: ${formatZodError(parsed.error)}`
+    });
+  }
+  const includeModelIds = parsed.data.includeModelIds ?? false;
+  const includeOpenRouter = parsed.data.includeOpenRouter ?? true;
+  const sources = deps.sourcesFactory !== void 0 ? deps.sourcesFactory(includeOpenRouter) : await defaultSources(includeOpenRouter);
+  const transports = await Promise.all(sources.map((s) => probeSource(s, includeModelIds)));
+  const response = {
+    transports,
+    healthyTransports: transports.filter((t) => t.ok).length,
+    totalTransports: transports.length,
+    totalModels: transports.reduce((sum, t) => sum + t.modelCount, 0),
+    note: "Probe results \u2014 existence only; the in-tree registry remains authoritative for pricing/capability."
+  };
+  logger56.debug("list_available_models probed transports", {
+    healthy: response.healthyTransports,
+    total: response.totalTransports
+  });
+  return toolSuccess(JSON.stringify(response, null, 2));
+}
+function registerListAvailableModelsTool(server, deps) {
+  const logger56 = deps.logger ?? createLogger({ tool: "list_available_models" });
+  const toolSchema = {
+    includeModelIds: z104.boolean().optional().describe("Include the full model-id list per transport (default false \u2192 sample of 5 only)."),
+    includeOpenRouter: z104.boolean().optional().describe("Probe the OpenRouter live catalog (default true).")
+  };
+  const secureHandler = createSecureHandler(
+    (args) => listAvailableModelsHandler(args, deps, logger56),
+    { toolName: "list_available_models", rateLimiter: deps.rateLimiter, logger: logger56 }
+  );
+  const timeoutMs = getToolTimeout("list_available_models", deps.security);
+  const wrappedHandler = wrapToolWithTimeout("list_available_models", secureHandler, {
+    timeoutMs,
+    logger: logger56
+  });
+  server.registerTool(
+    "list_available_models",
+    {
+      description: DESCRIPTION4,
+      inputSchema: toolSchema,
+      annotations: getToolAnnotations("list_available_models")
+    },
+    toSdkCallback(wrappedHandler)
+  );
+  logger56.info("Registered list_available_models tool");
+}
+
+// src/mcp/tools/pipeline-tool.ts
+import { z as z105 } from "zod";
 import * as fs13 from "fs";
 import * as path12 from "path";
-var PipelineInputSchema = z104.object({
+var PipelineInputSchema = z105.object({
   /** The task to execute. */
-  task: z104.string().min(5).max(1e4).describe("Task description \u2014 pipeline template auto-selected based on content"),
+  task: z105.string().min(5).max(1e4).describe("Task description \u2014 pipeline template auto-selected based on content"),
   /** Path to a spec file (.md, .yaml) to use as task input. */
-  specFile: z104.string().max(500).optional().describe("Path to a spec file \u2014 content prepended to task for greenfield projects"),
+  specFile: z105.string().max(500).optional().describe("Path to a spec file \u2014 content prepended to task for greenfield projects"),
   /** Override template — see `listTemplateIds()` for the canonical list (#2728). Auto-detected if omitted. */
-  template: z104.string().max(50).optional().describe(`Pipeline template override. Available: ${listTemplateIds().join(", ")}`),
+  template: z105.string().max(50).optional().describe(`Pipeline template override. Available: ${listTemplateIds().join(", ")}`),
   /** Voting strategy for consensus stages. */
-  votingStrategy: z104.enum([
+  votingStrategy: z105.enum([
     "simple_majority",
     "supermajority",
     "unanimous",
@@ -46491,13 +46637,13 @@ var PipelineInputSchema = z104.object({
     "Voting strategy for plan approval. simple_majority (default), supermajority (67%), unanimous, higher_order (Bayesian), proof_of_learning, opinion_wise"
   ),
   /** Use 3 agents instead of 6 for faster voting. */
-  quickMode: z104.boolean().default(false).describe("Use 3 agents instead of 6 for faster consensus voting"),
+  quickMode: z105.boolean().default(false).describe("Use 3 agents instead of 6 for faster consensus voting"),
   /** Maximum execution time per stage in milliseconds (min 30s, max 600s). */
-  timeoutMs: z104.number().int().min(3e4).max(6e5).optional().describe("Max time per stage in ms (30000-600000). Default: varies by stage complexity"),
+  timeoutMs: z105.number().int().min(3e4).max(6e5).optional().describe("Max time per stage in ms (30000-600000). Default: varies by stage complexity"),
   /** Stop after planning/voting (no implementation). */
-  dryRun: z104.boolean().default(false).describe("Stop after vote stage (no implementation)"),
+  dryRun: z105.boolean().default(false).describe("Stop after vote stage (no implementation)"),
   /** TESTS ONLY — random output, must not be used for real decisions. (#2319) */
-  simulateVotes: z104.boolean().default(false).describe("TESTS ONLY \u2014 random output, must not be used for real decisions (#2319)")
+  simulateVotes: z105.boolean().default(false).describe("TESTS ONLY \u2014 random output, must not be used for real decisions (#2319)")
 });
 function buildOutput2(result) {
   return {
@@ -46599,7 +46745,7 @@ function registerPipelineTool(server, deps) {
 }
 
 // src/mcp/tools/supply-chain-tradeoff-panel.ts
-import { z as z105 } from "zod";
+import { z as z106 } from "zod";
 var DEFAULT_AXES = [
   "build_time_determinism",
   "supply_chain_risk",
@@ -46619,16 +46765,16 @@ var FULL_PANEL = [
   "scope_steward"
 ];
 var QUICK_PANEL = ["architect", "security", "scope_steward"];
-var SupplyChainTradeoffPanelInputSchema = z105.object({
-  proposal: z105.string().min(1).max(MAX_PROPOSAL_LENGTH).describe('The proposal under tradeoff review (e.g. "Should aegis-boot adopt cargo-nextest?")'),
-  axes: z105.array(z105.string().min(1).max(MAX_AXIS_NAME_LENGTH)).min(1).max(MAX_AXES).optional().describe(
+var SupplyChainTradeoffPanelInputSchema = z106.object({
+  proposal: z106.string().min(1).max(MAX_PROPOSAL_LENGTH).describe('The proposal under tradeoff review (e.g. "Should aegis-boot adopt cargo-nextest?")'),
+  axes: z106.array(z106.string().min(1).max(MAX_AXIS_NAME_LENGTH)).min(1).max(MAX_AXES).optional().describe(
     `Tradeoff axes to evaluate. Default: ${DEFAULT_AXES.join(", ")}. Custom axes accepted; max ${String(MAX_AXES)}.`
   ),
-  context: z105.string().max(MAX_CONTEXT_LENGTH).optional().describe(
+  context: z106.string().max(MAX_CONTEXT_LENGTH).optional().describe(
     "Optional context: relevant repo state, dependency tree, vendor publishing patterns, etc."
   ),
-  quickMode: z105.boolean().optional().default(false).describe("Use 3 voters (architect, security, scope_steward) instead of 7"),
-  simulate: z105.boolean().optional().default(false).describe("Use simulated voters (testing only)")
+  quickMode: z106.boolean().optional().default(false).describe("Use 3 voters (architect, security, scope_steward) instead of 7"),
+  simulate: z106.boolean().optional().default(false).describe("Use simulated voters (testing only)")
 });
 function buildTradeoffProposal(input) {
   const axes = input.axes ?? DEFAULT_AXES;
@@ -46989,7 +47135,8 @@ var REGISTERED_TOOL_NAMES = [
   "supply_chain_tradeoff_panel",
   "improvement_review",
   "run_quality_gate",
-  "suggest_research_tasks"
+  "suggest_research_tasks",
+  "list_available_models"
 ];
 function registerTools(server, options) {
   const logger56 = options?.logger ?? createMcpLogger({ component: "tools" });
@@ -47124,40 +47271,40 @@ var RiskLevel = /* @__PURE__ */ ((RiskLevel2) => {
 })(RiskLevel || {});
 
 // src/mcp/safety/stpa-schemas.ts
-import { z as z106 } from "zod";
-var HazardCategorySchema = z106.enum(HazardCategory);
-var HazardSeveritySchema = z106.enum(HazardSeverity);
-var ConstraintPrioritySchema = z106.enum(ConstraintPriority);
-var RiskLevelSchema = z106.enum(RiskLevel);
-var TriggerPatternSchema = z106.object({
-  parameter: z106.string().min(1),
-  matchType: z106.enum(["contains", "regex", "equals", "startsWith", "endsWith"]),
-  pattern: z106.string(),
-  reason: z106.string()
+import { z as z107 } from "zod";
+var HazardCategorySchema = z107.enum(HazardCategory);
+var HazardSeveritySchema = z107.enum(HazardSeverity);
+var ConstraintPrioritySchema = z107.enum(ConstraintPriority);
+var RiskLevelSchema = z107.enum(RiskLevel);
+var TriggerPatternSchema = z107.object({
+  parameter: z107.string().min(1),
+  matchType: z107.enum(["contains", "regex", "equals", "startsWith", "endsWith"]),
+  pattern: z107.string(),
+  reason: z107.string()
 });
-var HazardSchema = z106.object({
-  id: z106.string().min(1),
-  description: z106.string(),
+var HazardSchema = z107.object({
+  id: z107.string().min(1),
+  description: z107.string(),
   category: HazardCategorySchema,
   severity: HazardSeveritySchema,
-  likelihood: z106.enum(["almost_certain", "likely", "possible", "unlikely", "rare"]),
-  triggerConditions: z106.array(z106.string()),
-  consequences: z106.array(z106.string())
+  likelihood: z107.enum(["almost_certain", "likely", "possible", "unlikely", "rare"]),
+  triggerConditions: z107.array(z107.string()),
+  consequences: z107.array(z107.string())
 });
-var UnsafeControlActionSchema = z106.object({
-  id: z106.string().min(1),
-  toolName: z106.string().min(1),
-  type: z106.enum(["not_provided", "provided_causes_hazard", "wrong_timing", "wrong_duration"]),
-  description: z106.string(),
-  unsafeContext: z106.string(),
-  relatedHazards: z106.array(z106.string()),
-  triggerPatterns: z106.array(TriggerPatternSchema).optional()
+var UnsafeControlActionSchema = z107.object({
+  id: z107.string().min(1),
+  toolName: z107.string().min(1),
+  type: z107.enum(["not_provided", "provided_causes_hazard", "wrong_timing", "wrong_duration"]),
+  description: z107.string(),
+  unsafeContext: z107.string(),
+  relatedHazards: z107.array(z107.string()),
+  triggerPatterns: z107.array(TriggerPatternSchema).optional()
 });
-var SafetyConstraintSchema = z106.object({
-  id: z106.string().min(1),
-  description: z106.string(),
-  mitigates: z106.array(z106.string()),
-  enforcement: z106.enum([
+var SafetyConstraintSchema = z107.object({
+  id: z107.string().min(1),
+  description: z107.string(),
+  mitigates: z107.array(z107.string()),
+  enforcement: z107.enum([
     "prevent",
     "require_confirmation",
     "alert",
@@ -47165,54 +47312,54 @@ var SafetyConstraintSchema = z106.object({
     "rate_limit",
     "require_privilege"
   ]),
-  validationFunction: z106.string().optional(),
+  validationFunction: z107.string().optional(),
   priority: ConstraintPrioritySchema
 });
-var PropertySchemaSchema = z106.object({
-  type: z106.string(),
-  description: z106.string().optional(),
-  enum: z106.array(z106.unknown()).optional(),
-  pattern: z106.string().optional(),
-  minimum: z106.number().optional(),
-  maximum: z106.number().optional()
+var PropertySchemaSchema = z107.object({
+  type: z107.string(),
+  description: z107.string().optional(),
+  enum: z107.array(z107.unknown()).optional(),
+  pattern: z107.string().optional(),
+  minimum: z107.number().optional(),
+  maximum: z107.number().optional()
 });
-var ToolInputSchemaSchema = z106.object({
-  type: z106.string(),
-  properties: z106.record(z106.string(), PropertySchemaSchema).optional(),
-  required: z106.array(z106.string()).optional(),
-  additionalProperties: z106.boolean().optional()
+var ToolInputSchemaSchema = z107.object({
+  type: z107.string(),
+  properties: z107.record(z107.string(), PropertySchemaSchema).optional(),
+  required: z107.array(z107.string()).optional(),
+  additionalProperties: z107.boolean().optional()
 });
-var ToolDefinitionSchema = z106.object({
-  name: z106.string().min(1),
-  description: z106.string(),
+var ToolDefinitionSchema = z107.object({
+  name: z107.string().min(1),
+  description: z107.string(),
   inputSchema: ToolInputSchemaSchema
 });
-var AnalysisConfigurationSchema = z106.object({
-  includeLowSeverity: z106.boolean().default(true),
-  generateAllConstraints: z106.boolean().default(true),
-  checkInteractions: z106.boolean().default(true),
-  maxHazardsPerTool: z106.number().int().min(1).max(100).default(50),
-  categories: z106.array(HazardCategorySchema).default([])
+var AnalysisConfigurationSchema = z107.object({
+  includeLowSeverity: z107.boolean().default(true),
+  generateAllConstraints: z107.boolean().default(true),
+  checkInteractions: z107.boolean().default(true),
+  maxHazardsPerTool: z107.number().int().min(1).max(100).default(50),
+  categories: z107.array(HazardCategorySchema).default([])
 });
-var ConstraintViolationSchema = z106.object({
-  constraintId: z106.string().min(1),
-  constraintDescription: z106.string(),
+var ConstraintViolationSchema = z107.object({
+  constraintId: z107.string().min(1),
+  constraintDescription: z107.string(),
   severity: HazardSeveritySchema,
-  details: z106.string(),
-  remediation: z106.string()
+  details: z107.string(),
+  remediation: z107.string()
 });
-var ValidationWarningSchema = z106.object({
-  code: z106.string().min(1),
-  message: z106.string(),
-  affected: z106.string()
+var ValidationWarningSchema = z107.object({
+  code: z107.string().min(1),
+  message: z107.string(),
+  affected: z107.string()
 });
-var ValidationResultSchema = z106.object({
-  valid: z106.boolean(),
-  toolName: z106.string().min(1),
-  violations: z106.array(ConstraintViolationSchema),
-  passed: z106.array(z106.string()),
-  warnings: z106.array(ValidationWarningSchema),
-  validatedAt: z106.date()
+var ValidationResultSchema = z107.object({
+  valid: z107.boolean(),
+  toolName: z107.string().min(1),
+  violations: z107.array(ConstraintViolationSchema),
+  passed: z107.array(z107.string()),
+  warnings: z107.array(ValidationWarningSchema),
+  validatedAt: z107.date()
 });
 
 // src/mcp/safety/stpa-types.ts
@@ -48297,43 +48444,43 @@ var GeminiResponseParser = class {
 };
 
 // src/cli-adapters/router-types.ts
-import { z as z107 } from "zod";
-var RouterConfigSchema = z107.object({
-  minCapacityThreshold: z107.number().min(0).max(1).default(0.1),
-  preferCostEfficient: z107.boolean().default(false),
-  maxDecisionTimeMs: z107.number().min(1).max(1e3).default(100)
+import { z as z108 } from "zod";
+var RouterConfigSchema = z108.object({
+  minCapacityThreshold: z108.number().min(0).max(1).default(0.1),
+  preferCostEfficient: z108.boolean().default(false),
+  maxDecisionTimeMs: z108.number().min(1).max(1e3).default(100)
 });
 
 // src/cli-adapters/agreement-cascade-types.ts
-import { z as z108 } from "zod";
-var AgreementCascadeConfigSchema = z108.object({
-  agreementThreshold: z108.number().min(0.5).max(1).default(0.7),
-  maxStages: z108.number().int().min(1).max(5).default(3),
-  modelTimeoutMs: z108.number().int().min(1e3).max(3e5).default(6e4)
+import { z as z109 } from "zod";
+var AgreementCascadeConfigSchema = z109.object({
+  agreementThreshold: z109.number().min(0.5).max(1).default(0.7),
+  maxStages: z109.number().int().min(1).max(5).default(3),
+  modelTimeoutMs: z109.number().int().min(1e3).max(3e5).default(6e4)
 });
 
 // src/cli-adapters/agreement-cascade-router.ts
 var logger46 = createLogger({ component: "agreement-cascade-router" });
 
 // src/cli-adapters/task-classifier.ts
-import { z as z109 } from "zod";
-var ClassificationPatternsSchema = z109.object({
-  code: z109.array(z109.string()).readonly(),
-  research: z109.array(z109.string()).readonly(),
-  documentation: z109.array(z109.string()).readonly(),
-  analysis: z109.array(z109.string()).readonly()
+import { z as z110 } from "zod";
+var ClassificationPatternsSchema = z110.object({
+  code: z110.array(z110.string()).readonly(),
+  research: z110.array(z110.string()).readonly(),
+  documentation: z110.array(z110.string()).readonly(),
+  analysis: z110.array(z110.string()).readonly()
 });
 
 // src/cli-adapters/response-cache-types.ts
-import { z as z110 } from "zod";
-var ResponseCacheConfigSchema = z110.object({
-  defaultTTL: z110.number().min(1e3).max(36e5).default(3e5),
+import { z as z111 } from "zod";
+var ResponseCacheConfigSchema = z111.object({
+  defaultTTL: z111.number().min(1e3).max(36e5).default(3e5),
   // 5 minutes
-  maxEntries: z110.number().min(10).max(1e5).default(1e3),
-  maxMemoryMB: z110.number().min(1).max(1e3).default(50),
-  cleanupInterval: z110.number().min(1e3).max(6e5).default(6e4),
+  maxEntries: z111.number().min(10).max(1e5).default(1e3),
+  maxMemoryMB: z111.number().min(1).max(1e3).default(50),
+  cleanupInterval: z111.number().min(1e3).max(6e5).default(6e4),
   // 1 minute
-  enableLogging: z110.boolean().default(false)
+  enableLogging: z111.boolean().default(false)
 });
 
 // src/cli-adapters/response-cache-utils.ts
@@ -48341,12 +48488,12 @@ import { createHash as createHash4 } from "crypto";
 var logger47 = createLogger({ component: "ResponseCacheUtils" });
 
 // src/cli-adapters/unified-routing-types.ts
-import { z as z111 } from "zod";
-var UnifiedRoutingDecisionSchema = z111.object({
-  selectedCli: z111.string(),
-  confidence: z111.number().min(0).max(1),
-  reason: z111.string(),
-  strategy: z111.enum([
+import { z as z112 } from "zod";
+var UnifiedRoutingDecisionSchema = z112.object({
+  selectedCli: z112.string(),
+  confidence: z112.number().min(0).max(1),
+  reason: z112.string(),
+  strategy: z112.enum([
     "composite",
     "quality",
     "budget",
@@ -48358,57 +48505,57 @@ var UnifiedRoutingDecisionSchema = z111.object({
     "linucb",
     "direct"
   ]),
-  decisionTimeMs: z111.number().nonnegative(),
-  alternatives: z111.array(z111.string()).readonly(),
-  stagesExecuted: z111.array(z111.string()).readonly(),
-  withinBudget: z111.boolean().optional(),
-  estimatedComplexity: z111.enum(["simple", "moderate", "complex", "expert"]).optional(),
-  estimatedTokens: z111.number().int().positive().optional(),
-  topsisScore: z111.number().optional(),
-  ucbScore: z111.number().optional(),
-  resolvedAtStage: z111.number().int().nonnegative().optional(),
-  consensusReached: z111.boolean().optional(),
-  agreementScore: z111.number().min(0).max(1).optional(),
-  metadata: z111.record(z111.string(), z111.unknown()).optional()
+  decisionTimeMs: z112.number().nonnegative(),
+  alternatives: z112.array(z112.string()).readonly(),
+  stagesExecuted: z112.array(z112.string()).readonly(),
+  withinBudget: z112.boolean().optional(),
+  estimatedComplexity: z112.enum(["simple", "moderate", "complex", "expert"]).optional(),
+  estimatedTokens: z112.number().int().positive().optional(),
+  topsisScore: z112.number().optional(),
+  ucbScore: z112.number().optional(),
+  resolvedAtStage: z112.number().int().nonnegative().optional(),
+  consensusReached: z112.boolean().optional(),
+  agreementScore: z112.number().min(0).max(1).optional(),
+  metadata: z112.record(z112.string(), z112.unknown()).optional()
 });
 
 // src/learning/outcome-feedback-types.ts
-import { z as z112 } from "zod";
-var QualitySignalsSchema = z112.object({
-  testsPass: z112.boolean().optional(),
-  lintErrors: z112.number().int().min(0).optional(),
-  userApproved: z112.boolean().optional(),
-  retryCount: z112.number().int().min(0).default(0),
-  completionRatio: z112.number().min(0).max(1).default(1),
-  validStructure: z112.boolean().optional(),
-  coherenceScore: z112.number().min(0).max(1).optional()
+import { z as z113 } from "zod";
+var QualitySignalsSchema = z113.object({
+  testsPass: z113.boolean().optional(),
+  lintErrors: z113.number().int().min(0).optional(),
+  userApproved: z113.boolean().optional(),
+  retryCount: z113.number().int().min(0).default(0),
+  completionRatio: z113.number().min(0).max(1).default(1),
+  validStructure: z113.boolean().optional(),
+  coherenceScore: z113.number().min(0).max(1).optional()
 });
-var RoutingDecisionSchema = z112.object({
-  id: z112.uuid(),
-  timestamp: z112.iso.datetime(),
-  query: z112.string(),
-  routerType: z112.enum(["linucb", "preference", "quality", "cascade", "topsis"]),
-  selectedModel: z112.string(),
-  selectedTier: z112.enum(["strong", "weak"]).optional(),
-  armIndex: z112.number().int().min(0).optional(),
-  banditContext: z112.record(z112.string(), z112.unknown()).optional(),
-  queryFeatures: z112.record(z112.string(), z112.unknown()).optional(),
-  ucbScore: z112.number().optional(),
-  confidence: z112.number().min(0).max(1).optional(),
-  traceId: z112.string(),
-  domain: z112.string().optional()
+var RoutingDecisionSchema = z113.object({
+  id: z113.uuid(),
+  timestamp: z113.iso.datetime(),
+  query: z113.string(),
+  routerType: z113.enum(["linucb", "preference", "quality", "cascade", "topsis"]),
+  selectedModel: z113.string(),
+  selectedTier: z113.enum(["strong", "weak"]).optional(),
+  armIndex: z113.number().int().min(0).optional(),
+  banditContext: z113.record(z113.string(), z113.unknown()).optional(),
+  queryFeatures: z113.record(z113.string(), z113.unknown()).optional(),
+  ucbScore: z113.number().optional(),
+  confidence: z113.number().min(0).max(1).optional(),
+  traceId: z113.string(),
+  domain: z113.string().optional()
 });
-var TaskOutcomeSchema = z112.object({
-  routingDecisionId: z112.uuid(),
-  timestamp: z112.iso.datetime(),
-  outcomeClass: z112.enum(["success", "partial", "failure", "timeout", "error"]),
-  success: z112.boolean(),
-  qualityScore: z112.number().min(0).max(1),
-  durationMs: z112.number().min(0),
-  tokenUsage: z112.number().int().min(0),
-  errorMessage: z112.string().optional(),
+var TaskOutcomeSchema = z113.object({
+  routingDecisionId: z113.uuid(),
+  timestamp: z113.iso.datetime(),
+  outcomeClass: z113.enum(["success", "partial", "failure", "timeout", "error"]),
+  success: z113.boolean(),
+  qualityScore: z113.number().min(0).max(1),
+  durationMs: z113.number().min(0),
+  tokenUsage: z113.number().int().min(0),
+  errorMessage: z113.string().optional(),
   qualitySignals: QualitySignalsSchema,
-  traceId: z112.string()
+  traceId: z113.string()
 });
 var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   maxPendingDecisions: 1e3,
@@ -48423,17 +48570,17 @@ var DEFAULT_FEEDBACK_COLLECTOR_CONFIG = {
   targetTokenUsage: 2e3,
   maxHistorySize: 1e4
 };
-var FeedbackCollectorConfigSchema = z112.object({
-  maxPendingDecisions: z112.number().int().positive().default(1e3),
-  pendingTimeoutMs: z112.number().positive().default(3e5),
-  enableAutoReward: z112.boolean().default(true),
-  qualityWeight: z112.number().min(0).max(1).default(0.5),
-  speedWeight: z112.number().min(0).max(1).default(0.2),
-  efficiencyWeight: z112.number().min(0).max(1).default(0.2),
-  retryPenalty: z112.number().min(0).max(1).default(0.1),
-  targetDurationMs: z112.number().positive().default(5e3),
-  targetTokenUsage: z112.number().positive().default(2e3),
-  maxHistorySize: z112.number().int().positive().default(1e4)
+var FeedbackCollectorConfigSchema = z113.object({
+  maxPendingDecisions: z113.number().int().positive().default(1e3),
+  pendingTimeoutMs: z113.number().positive().default(3e5),
+  enableAutoReward: z113.boolean().default(true),
+  qualityWeight: z113.number().min(0).max(1).default(0.5),
+  speedWeight: z113.number().min(0).max(1).default(0.2),
+  efficiencyWeight: z113.number().min(0).max(1).default(0.2),
+  retryPenalty: z113.number().min(0).max(1).default(0.1),
+  targetDurationMs: z113.number().positive().default(5e3),
+  targetTokenUsage: z113.number().positive().default(2e3),
+  maxHistorySize: z113.number().int().positive().default(1e4)
 });
 
 // src/learning/outcome-feedback-helpers.ts
@@ -50025,7 +50172,7 @@ var GitHubTaskTracker = class {
   cachedProvider = null;
   async getProvider() {
     if (this.cachedProvider !== null) return this.cachedProvider;
-    const { createScmProvider } = await import("./factory-2A2CZPQR.js");
+    const { createScmProvider } = await import("./factory-OHAMFHSF.js");
     const result = await createScmProvider({ repo: this.config.repo ?? "" });
     if (!result.ok) throw new Error(`SCM provider error: ${result.error.message}`);
     this.cachedProvider = result.value;
@@ -50667,6 +50814,7 @@ export {
   registerVerifyAuditChainTool,
   checkForResearchTriggers,
   registerSuggestResearchTasksTool,
+  registerListAvailableModelsTool,
   PIPELINE_STATE_KEYS,
   compilePipelineGraph,
   runGraphPipeline,
@@ -50735,4 +50883,4 @@ export {
   detectBackend,
   createTaskTracker
 };
-//# sourceMappingURL=chunk-WVZT4JGL.js.map
+//# sourceMappingURL=chunk-3TOHOAB2.js.map