@peterwangze/claude-trigger-router 1.0.4 → 1.0.5

package/dist/cli.js

@@ -224,6 +224,40 @@ function inferTransformer(protocol) {
   }
   return void 0;
 }
+function inferCompatibilityProfile(item, modelInterface) {
+  if (modelInterface === "anthropic") {
+    return "anthropic-native";
+  }
+  const api = getModelApi(item);
+  const vendorHint = item.metadata?.vendor_hint?.trim().toLowerCase();
+  if (vendorHint === "openrouter" || api.includes("openrouter.ai")) {
+    return "openrouter-like";
+  }
+  if (vendorHint === "qianfan" || vendorHint === "qianfan-coding" || api.includes("qianfan.baidubce.com/v2/coding")) {
+    return "qianfan-coding";
+  }
+  if (vendorHint === "minimax" || vendorHint === "minimax-chatcompletion-v2" || api.includes("/v1/text/chatcompletion_v2")) {
+    return "minimax-chatcompletion-v2";
+  }
+  return "generic-openai-compatible";
+}
+function getDispatchFormatForProfile(modelInterface, compatibilityProfile) {
+  if (modelInterface === "anthropic") {
+    return "anthropic_messages";
+  }
+  switch (compatibilityProfile) {
+    case "openrouter-like":
+    case "qianfan-coding":
+    case "minimax-chatcompletion-v2":
+      return "anthropic_messages";
+    case "anthropic-native":
+      return "anthropic_messages";
+    case "generic-openai-compatible":
+      return "anthropic_messages";
+    default:
+      return "anthropic_messages";
+  }
+}
 function buildCompiledCapabilities(item, modelInterface) {
   const reasoningSupported = item.metadata?.supports_reasoning !== false;
   return {
@@ -255,12 +289,15 @@ function buildModelRegistry(config) {
     const modelMap2 = config.Models.reduce((result, rawItem) => {
       const item = normalizeModelEndpointConfig(rawItem);
       const modelInterface = getModelInterface(item) || "openai";
+      const compatibilityProfile = inferCompatibilityProfile(item, modelInterface);
       result[item.id] = {
         id: item.id,
         providerName: `model__${item.id}`,
         modelName: item.model,
         interface: modelInterface,
         protocol: modelInterface,
+        compatibilityProfile,
+        dispatchFormat: getDispatchFormatForProfile(modelInterface, compatibilityProfile),
         thinking: item.thinking,
         capabilities: buildCompiledCapabilities(item, modelInterface),
         source: "models"
@@ -275,12 +312,23 @@ function buildModelRegistry(config) {
   const providers = config.Providers ?? [];
   const modelMap = providers.reduce((result, provider) => {
     for (const model of provider.models ?? []) {
+      const compatibilityProfile = inferCompatibilityProfile(
+        {
+          api_base_url: provider.api_base_url,
+          metadata: {
+            vendor_hint: provider.transformer?.use?.[0]
+          }
+        },
+        "openai"
+      );
       result[`${provider.name},${model}`] = {
         id: `${provider.name},${model}`,
         providerName: provider.name,
         modelName: model,
         interface: "openai",
         protocol: "openai",
+        compatibilityProfile,
+        dispatchFormat: getDispatchFormatForProfile("openai", compatibilityProfile),
         capabilities: {
           thinking: {
             supported: true
@@ -452,6 +500,9 @@ async function initDir() {
   if (!(0, import_fs.existsSync)(CONFIG_DIR)) {
     (0, import_fs.mkdirSync)(CONFIG_DIR, { recursive: true });
   }
+  if (!(0, import_fs.existsSync)(HOME_DIR)) {
+    (0, import_fs.mkdirSync)(HOME_DIR, { recursive: true });
+  }
 }
 async function loadYamlConfig(path) {
   if (!(0, import_fs.existsSync)(path)) {
@@ -930,6 +981,31 @@ async function probeServiceHealth(port, timeoutMs = 500) {
     return false;
   }
 }
+async function isTcpPortOccupied(port, timeoutMs = 500) {
+  return new Promise((resolve) => {
+    const socket = new import_net.Socket();
+    let settled = false;
+    const finish = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      socket.destroy();
+      resolve(value);
+    };
+    socket.setTimeout(timeoutMs);
+    socket.once("connect", () => finish(true));
+    socket.once("timeout", () => finish(false));
+    socket.once("error", (error) => {
+      if (error.code === "ECONNREFUSED") {
+        finish(false);
+        return;
+      }
+      finish(false);
+    });
+    socket.connect(port, "127.0.0.1");
+  });
+}
 async function waitForService(port, timeoutMs = 5e3) {
   const start = Date.now();
   while (Date.now() - start < timeoutMs) {
@@ -940,10 +1016,11 @@ async function waitForService(port, timeoutMs = 5e3) {
   }
   return false;
 }
-var SERVICE_NAME, SERVICE_HEALTH_PATH;
+var import_net, SERVICE_NAME, SERVICE_HEALTH_PATH;
 var init_service_health = __esm({
   "src/service-health.ts"() {
     "use strict";
+    import_net = require("net");
     SERVICE_NAME = "claude-trigger-router";
     SERVICE_HEALTH_PATH = "/api/health";
   }
@@ -957,25 +1034,25 @@ var init_types = __esm({
 });
 
 // src/governance/trace.ts
-function createGovernanceTrace(input2 = {}) {
+function createGovernanceTrace(input3 = {}) {
   return {
-    requestId: input2.requestId ?? (0, import_crypto.randomUUID)(),
-    sessionKey: input2.sessionKey,
-    initialModel: input2.initialModel,
-    finalModel: input2.finalModel,
-    routeReason: input2.routeReason ? [...input2.routeReason] : [],
-    stickyHit: input2.stickyHit ?? false,
-    alignmentUsed: input2.alignmentUsed ?? false,
-    semanticIntent: input2.semanticIntent,
-    cascadeTriggered: input2.cascadeTriggered ?? false,
-    cascadeEvidence: input2.cascadeEvidence ? [...input2.cascadeEvidence] : [],
-    cascadeNextModel: input2.cascadeNextModel,
-    shadowChecked: input2.shadowChecked ?? false,
-    verificationResult: input2.verificationResult,
-    latencyMs: input2.latencyMs,
-    estimatedCost: input2.estimatedCost,
-    startedAt: input2.startedAt ?? Date.now(),
-    completedAt: input2.completedAt
+    requestId: input3.requestId ?? (0, import_crypto.randomUUID)(),
+    sessionKey: input3.sessionKey,
+    initialModel: input3.initialModel,
+    finalModel: input3.finalModel,
+    routeReason: input3.routeReason ? [...input3.routeReason] : [],
+    stickyHit: input3.stickyHit ?? false,
+    alignmentUsed: input3.alignmentUsed ?? false,
+    semanticIntent: input3.semanticIntent,
+    cascadeTriggered: input3.cascadeTriggered ?? false,
+    cascadeEvidence: input3.cascadeEvidence ? [...input3.cascadeEvidence] : [],
+    cascadeNextModel: input3.cascadeNextModel,
+    shadowChecked: input3.shadowChecked ?? false,
+    verificationResult: input3.verificationResult,
+    latencyMs: input3.latencyMs,
+    estimatedCost: input3.estimatedCost,
+    startedAt: input3.startedAt ?? Date.now(),
+    completedAt: input3.completedAt
   };
 }
 function appendTraceReason(trace, reason) {
@@ -1300,16 +1377,16 @@ function normalizeContentParts(content) {
     }
   });
 }
-function createMessageIR(input2) {
-  const system = typeof input2.system === "string" ? [input2.system] : Array.isArray(input2.system) ? input2.system.flatMap((item) => item?.type === "text" && typeof item.text === "string" ? [item.text] : []) : [];
-  const messages = Array.isArray(input2.messages) ? input2.messages.filter((item) => item?.role).map((item) => ({
+function createMessageIR(input3) {
+  const system = typeof input3.system === "string" ? [input3.system] : Array.isArray(input3.system) ? input3.system.flatMap((item) => item?.type === "text" && typeof item.text === "string" ? [item.text] : []) : [];
+  const messages = Array.isArray(input3.messages) ? input3.messages.filter((item) => item?.role).map((item) => ({
     role: item.role,
     parts: normalizeContentParts(item.content)
   })) : [];
-  const thinking = input2.thinking ? {
-    enabled: input2.thinking?.type === "enabled" || input2.thinking?.enabled === true,
-    effort: input2.thinking?.effort,
-    budget_tokens: input2.thinking?.budget_tokens
+  const thinking = input3.thinking ? {
+    enabled: input3.thinking?.type === "enabled" || input3.thinking?.enabled === true,
+    effort: input3.thinking?.effort,
+    budget_tokens: input3.thinking?.budget_tokens
   } : void 0;
   return {
     system,
@@ -1361,34 +1438,38 @@ function toAnthropicContent(parts) {
     }
   });
 }
-function toAnthropicMessagesRequest(input2) {
+function toAnthropicMessagesRequest(input3) {
   const body = {
-    model: input2.model,
-    messages: input2.ir.messages.map((message) => ({
+    model: input3.model,
+    messages: input3.ir.messages.map((message) => ({
       role: message.role,
       content: toAnthropicContent(message.parts)
     }))
   };
-  if (input2.max_tokens !== void 0) {
-    body.max_tokens = input2.max_tokens;
+  if (input3.max_tokens !== void 0) {
+    body.max_tokens = input3.max_tokens;
   }
-  if (input2.stream !== void 0) {
-    body.stream = input2.stream;
+  if (input3.stream !== void 0) {
+    body.stream = input3.stream;
   }
-  if (input2.metadata) {
-    body.metadata = input2.metadata;
+  if (input3.metadata) {
+    body.metadata = input3.metadata;
   }
-  if (input2.tools) {
-    body.tools = input2.tools;
+  if (input3.tools) {
+    body.tools = input3.tools.map((tool) => ({
+      name: tool?.name ?? tool?.function?.name,
+      description: tool?.description ?? tool?.function?.description,
+      input_schema: tool?.input_schema ?? tool?.function?.parameters
+    }));
   }
-  if (input2.ir.system.length) {
-    body.system = input2.ir.system.map((text) => ({ type: "text", text }));
+  if (input3.ir.system.length) {
+    body.system = input3.ir.system.map((text) => ({ type: "text", text }));
   }
-  if (input2.ir.options?.thinking?.enabled) {
+  if (input3.ir.options?.thinking?.enabled) {
     body.thinking = {
       type: "enabled",
-      ...input2.ir.options.thinking.effort ? { effort: input2.ir.options.thinking.effort } : {},
-      ...input2.ir.options.thinking.budget_tokens ? { budget_tokens: input2.ir.options.thinking.budget_tokens } : {}
+      ...input3.ir.options.thinking.effort ? { effort: input3.ir.options.thinking.effort } : {},
+      ...input3.ir.options.thinking.budget_tokens ? { budget_tokens: input3.ir.options.thinking.budget_tokens } : {}
     };
   }
   return body;
@@ -2121,17 +2202,17 @@ var init_SSEParser_transform = __esm({
 
 // src/governance/stream-response-governance.ts
 function serializeEvent(event2) {
-  let output2 = "";
+  let output3 = "";
   if (event2.event) {
-    output2 += `event: ${event2.event}
+    output3 += `event: ${event2.event}
 `;
   }
   if (event2.data !== void 0) {
-    output2 += `data: ${typeof event2.data === "string" ? event2.data : JSON.stringify(event2.data)}
+    output3 += `data: ${typeof event2.data === "string" ? event2.data : JSON.stringify(event2.data)}
 `;
   }
-  output2 += "\n";
-  return new TextEncoder().encode(output2);
+  output3 += "\n";
+  return new TextEncoder().encode(output3);
 }
 async function collectSSE(stream) {
   const parser = new SSEParserTransform();
@@ -2241,17 +2322,17 @@ var init_stream_response_governance = __esm({
 });
 
 // src/governance/metrics.ts
-function normalizeAnomalyThresholds(input2) {
+function normalizeAnomalyThresholds(input3) {
   return {
-    minSampleSize: input2?.minSampleSize ?? DEFAULT_ANOMALY_THRESHOLDS.minSampleSize,
-    cascadeWarnRate: input2?.cascadeWarnRate ?? DEFAULT_ANOMALY_THRESHOLDS.cascadeWarnRate,
-    cascadeCriticalRate: input2?.cascadeCriticalRate ?? DEFAULT_ANOMALY_THRESHOLDS.cascadeCriticalRate,
-    shadowWarnRate: input2?.shadowWarnRate ?? DEFAULT_ANOMALY_THRESHOLDS.shadowWarnRate,
-    shadowCriticalRate: input2?.shadowCriticalRate ?? DEFAULT_ANOMALY_THRESHOLDS.shadowCriticalRate,
-    latencyWarnMs: input2?.latencyWarnMs ?? DEFAULT_ANOMALY_THRESHOLDS.latencyWarnMs,
-    latencyCriticalMs: input2?.latencyCriticalMs ?? DEFAULT_ANOMALY_THRESHOLDS.latencyCriticalMs,
-    spikeWarnRate: input2?.spikeWarnRate ?? DEFAULT_ANOMALY_THRESHOLDS.spikeWarnRate,
-    spikeDeltaRate: input2?.spikeDeltaRate ?? DEFAULT_ANOMALY_THRESHOLDS.spikeDeltaRate
+    minSampleSize: input3?.minSampleSize ?? DEFAULT_ANOMALY_THRESHOLDS.minSampleSize,
+    cascadeWarnRate: input3?.cascadeWarnRate ?? DEFAULT_ANOMALY_THRESHOLDS.cascadeWarnRate,
+    cascadeCriticalRate: input3?.cascadeCriticalRate ?? DEFAULT_ANOMALY_THRESHOLDS.cascadeCriticalRate,
+    shadowWarnRate: input3?.shadowWarnRate ?? DEFAULT_ANOMALY_THRESHOLDS.shadowWarnRate,
+    shadowCriticalRate: input3?.shadowCriticalRate ?? DEFAULT_ANOMALY_THRESHOLDS.shadowCriticalRate,
+    latencyWarnMs: input3?.latencyWarnMs ?? DEFAULT_ANOMALY_THRESHOLDS.latencyWarnMs,
+    latencyCriticalMs: input3?.latencyCriticalMs ?? DEFAULT_ANOMALY_THRESHOLDS.latencyCriticalMs,
+    spikeWarnRate: input3?.spikeWarnRate ?? DEFAULT_ANOMALY_THRESHOLDS.spikeWarnRate,
+    spikeDeltaRate: input3?.spikeDeltaRate ?? DEFAULT_ANOMALY_THRESHOLDS.spikeDeltaRate
   };
 }
 function rate(count, total) {
@@ -3262,7 +3343,7 @@ var init_server = __esm({
       server.app.post("/api/restart", async (req, reply) => {
         reply.send({ success: true, message: "Service restart initiated" });
         setTimeout(() => {
-          const { spawn: spawn2 } = require("child_process");
+          const { spawn: spawn3 } = require("child_process");
           const { join: join8 } = require("path");
           const cliPath = join8(__dirname, "cli.js");
           const currentPort = config.initialConfig?.PORT;
@@ -3270,7 +3351,7 @@ var init_server = __esm({
           if (currentPort) {
             restartArgs.push("--port", String(currentPort));
           }
-          spawn2(process.execPath, restartArgs, {
+          spawn3(process.execPath, restartArgs, {
             detached: true,
             stdio: "ignore"
           }).unref();
@@ -3576,18 +3657,18 @@ var init_SSESerializer_transform = __esm({
       constructor() {
         const transformStream = new TransformStream({
           transform: (event2, controller) => {
-            let output2 = "";
+            let output3 = "";
             if (event2.event) {
-              output2 += `event: ${event2.event}
+              output3 += `event: ${event2.event}
 `;
             }
             if (event2.data) {
               const dataStr = typeof event2.data === "string" ? event2.data : JSON.stringify(event2.data);
-              output2 += `data: ${dataStr}
+              output3 += `data: ${dataStr}
 `;
             }
-            output2 += "\n";
-            controller.enqueue(new TextEncoder().encode(output2));
+            output3 += "\n";
+            controller.enqueue(new TextEncoder().encode(output3));
           }
         });
         this.readable = transformStream.readable;
@@ -4377,6 +4458,7 @@ Important:
             method: "POST",
             headers: {
               "Content-Type": "application/json",
+              "x-ctr-smart-router": "1",
               ...apiKey ? { "x-api-key": apiKey } : {}
             },
             body: JSON.stringify(
@@ -4889,6 +4971,15 @@ function toOpenAIToolResultMessages(parts) {
     content: typeof part.content === "string" ? part.content : JSON.stringify(part.content)
   }));
 }
+function getToolName(tool) {
+  return tool?.name ?? tool?.function?.name;
+}
+function getToolDescription(tool) {
+  return tool?.description ?? tool?.function?.description;
+}
+function getToolInputSchema(tool) {
+  return tool?.input_schema ?? tool?.function?.parameters;
+}
 function toOpenAITools(tools) {
   if (!Array.isArray(tools) || !tools.length) {
     return void 0;
@@ -4896,9 +4987,9 @@ function toOpenAITools(tools) {
   return tools.map((tool) => ({
     type: "function",
     function: {
-      name: tool.name,
-      description: tool.description,
-      parameters: tool.input_schema
+      name: getToolName(tool),
+      description: getToolDescription(tool),
+      parameters: getToolInputSchema(tool)
     }
   }));
 }
@@ -4925,10 +5016,10 @@ function toOpenAIToolChoice(toolChoice) {
   }
   return toolChoice;
 }
-function toOpenAIChatRequest(input2) {
+function toOpenAIChatRequest(input3) {
   const messages = [
-    ...input2.ir.system.map((text) => ({ role: "system", content: text })),
-    ...input2.ir.messages.flatMap((message) => {
+    ...input3.ir.system.map((text) => ({ role: "system", content: text })),
+    ...input3.ir.messages.flatMap((message) => {
       const content = toOpenAIContent(message.parts);
       const toolCalls = message.role === "assistant" ? toOpenAIToolCalls(message.parts) : [];
       const toolResults = toOpenAIToolResultMessages(message.parts);
@@ -4947,26 +5038,26 @@ function toOpenAIChatRequest(input2) {
     })
   ];
   const body = {
-    model: input2.model,
+    model: input3.model,
     messages
   };
-  if (input2.max_completion_tokens !== void 0) {
-    body.max_completion_tokens = input2.max_completion_tokens;
+  if (input3.max_completion_tokens !== void 0) {
+    body.max_completion_tokens = input3.max_completion_tokens;
   }
-  if (input2.stream !== void 0) {
-    body.stream = input2.stream;
+  if (input3.stream !== void 0) {
+    body.stream = input3.stream;
   }
-  const tools = toOpenAITools(input2.tools);
+  const tools = toOpenAITools(input3.tools);
   if (tools) {
     body.tools = tools;
   }
-  const toolChoice = toOpenAIToolChoice(input2.tool_choice);
+  const toolChoice = toOpenAIToolChoice(input3.tool_choice);
   if (toolChoice !== void 0) {
     body.tool_choice = toolChoice;
   }
-  if (input2.ir.options?.thinking?.enabled) {
+  if (input3.ir.options?.thinking?.enabled) {
     body.reasoning = {
-      ...input2.ir.options.thinking.effort ? { effort: input2.ir.options.thinking.effort } : {}
+      ...input3.ir.options.thinking.effort ? { effort: input3.ir.options.thinking.effort } : {}
     };
   }
   return body;
@@ -4991,19 +5082,19 @@ function stringifyFallbackContent(value) {
     return String(value);
   }
 }
-function applyCapabilityFallbacks(input2) {
+function applyCapabilityFallbacks(input3) {
   const diagnostics = [];
-  const nextRequest = { ...input2.request };
+  const nextRequest = { ...input3.request };
   const nextIR = {
-    ...input2.ir,
-    system: [...input2.ir.system],
-    messages: input2.ir.messages.map((message) => ({
+    ...input3.ir,
+    system: [...input3.ir.system],
+    messages: input3.ir.messages.map((message) => ({
       ...message,
       parts: message.parts.map((part) => ({ ...part }))
     })),
-    options: input2.ir.options ? { ...input2.ir.options } : void 0
+    options: input3.ir.options ? { ...input3.ir.options } : void 0
   };
-  if (input2.capabilities?.thinking.supported === false && nextIR.options?.thinking) {
+  if (input3.capabilities?.thinking.supported === false && nextIR.options?.thinking) {
     diagnostics.push("thinking_ignored");
     delete nextIR.options.thinking;
     delete nextRequest.thinking;
@@ -5014,7 +5105,7 @@ function applyCapabilityFallbacks(input2) {
   const hasImageParts = nextIR.messages.some(
     (message) => message.parts.some((part) => part.type === "image")
   );
-  if (input2.capabilities?.images === false && hasImageParts) {
+  if (input3.capabilities?.images === false && hasImageParts) {
     diagnostics.push("images_text_fallback");
     nextIR.messages = nextIR.messages.map((message) => ({
       ...message,
@@ -5034,7 +5125,7 @@ function applyCapabilityFallbacks(input2) {
   const hasToolParts = nextIR.messages.some(
     (message) => message.parts.some((part) => part.type === "tool_call" || part.type === "tool_result")
   );
-  if (input2.capabilities?.tools === false && (Array.isArray(nextRequest.tools) && nextRequest.tools.length || hasToolParts)) {
+  if (input3.capabilities?.tools === false && (Array.isArray(nextRequest.tools) && nextRequest.tools.length || hasToolParts)) {
     diagnostics.push("tools_text_fallback");
     delete nextRequest.tools;
     delete nextRequest.tool_choice;
@@ -5080,53 +5171,58 @@ function omitRequestFields(body) {
   } = body;
   return rest;
 }
-function buildUpstreamRequestFromIR(input2) {
+function buildProviderDispatchRequestFromIR(input3) {
   const fallback = applyCapabilityFallbacks({
-    ir: input2.ir,
-    request: input2.request,
-    capabilities: input2.capabilities
+    ir: input3.ir,
+    request: input3.request,
+    capabilities: input3.capabilities
   });
   const passthrough = omitRequestFields(fallback.request);
-  if (input2.interface === "anthropic") {
+  const dispatchFormat = getDispatchFormatForProfile(input3.interface, input3.compatibilityProfile);
+  if (dispatchFormat === "openai_chat") {
     return {
+      dispatchFormat,
       diagnostics: fallback.diagnostics,
       ...passthrough,
-      ...toAnthropicMessagesRequest({
-        model: input2.model,
-        max_tokens: fallback.request.max_tokens,
+      ...toOpenAIChatRequest({
+        model: input3.model,
+        max_completion_tokens: fallback.request.max_tokens ?? fallback.request.max_completion_tokens,
         stream: fallback.request.stream,
-        metadata: fallback.request.metadata,
         tools: fallback.request.tools,
+        tool_choice: fallback.request.tool_choice,
         ir: fallback.ir
       })
     };
   }
   return {
+    dispatchFormat,
     diagnostics: fallback.diagnostics,
     ...passthrough,
-    ...toOpenAIChatRequest({
-      model: input2.model,
-      max_completion_tokens: fallback.request.max_tokens ?? fallback.request.max_completion_tokens,
+    ...toAnthropicMessagesRequest({
+      model: input3.model,
+      max_tokens: fallback.request.max_tokens,
       stream: fallback.request.stream,
+      metadata: fallback.request.metadata,
       tools: fallback.request.tools,
-      tool_choice: fallback.request.tool_choice,
       ir: fallback.ir
     })
   };
 }
-function buildUpstreamRequest(input2) {
-  const ir = createMessageIR(input2.request);
-  const { diagnostics, ...body } = buildUpstreamRequestFromIR({
-    model: input2.model,
-    interface: input2.interface,
-    request: input2.request,
+function buildProviderDispatchRequest(input3) {
+  const ir = createMessageIR(input3.request);
+  const { diagnostics, dispatchFormat, ...body } = buildProviderDispatchRequestFromIR({
+    model: input3.model,
+    interface: input3.interface,
+    compatibilityProfile: input3.compatibilityProfile,
+    request: input3.request,
     ir,
-    capabilities: input2.capabilities
+    capabilities: input3.capabilities
   });
   return {
     ir,
     body,
-    diagnostics
+    diagnostics,
+    dispatchFormat
   };
 }
 var init_protocols = __esm({
@@ -5135,6 +5231,7 @@ var init_protocols = __esm({
     init_message_ir();
     init_anthropic();
     init_openai();
+    init_compile();
   }
 });
 
@@ -5202,7 +5299,7 @@ async function run(options = {}) {
     const hour = pad(date.getHours());
     const minute = pad(date.getMinutes());
     const seconds = pad(date.getSeconds());
-    return `./logs/ctr-${month}${day}${hour}${minute}${seconds}${index ? `_${index}` : ""}.log`;
+    return `ctr-${month}${day}${hour}${minute}${seconds}${index ? `_${index}` : ""}.log`;
   };
   const loggerConfig = config.LOG !== false ? {
     level: config.LOG_LEVEL || "debug",
@@ -5213,10 +5310,11 @@ async function run(options = {}) {
       compress: "gzip"
     })
   } : false;
+  const registry = buildModelRegistry(config);
   const server = createServer({
-    jsonPath: CONFIG_FILE,
+    useJsonFile: false,
     initialConfig: {
-      providers: config.Providers,
+      providers: registry.providers,
       HOST,
       PORT: servicePort,
       LOG_FILE: (0, import_path5.join)(
@@ -5252,9 +5350,10 @@ async function run(options = {}) {
         initialModel: req.body?.model
       });
       appendTraceReason(req.governanceTrace, "request_received");
-      const triggerResult = await triggerRouter.route(req);
+      const bypassTriggerRouter = req.headers["x-ctr-smart-router"] === "1";
+      const triggerResult = bypassTriggerRouter ? { matched: false, confidence: 0, analysisTime: 0 } : await triggerRouter.route(req);
       req.triggerResult = triggerResult;
-      if (triggerResult.matched && triggerResult.model) {
+      if (!bypassTriggerRouter && triggerResult.matched && triggerResult.model) {
         const previousSessionState = req.sessionId ? sessionStateStore.get(req.sessionId) : void 0;
         const previousModel = previousSessionState?.lastSuccessfulModel;
         const alignmentConfig = config.Governance?.sticky?.alignment;
@@ -5319,9 +5418,10 @@ async function run(options = {}) {
       const compiledModel = getCompiledModelRef(config, req.body?.model);
       if (compiledModel?.interface && req.body?.messages) {
         const originalBody = cloneRequestBody(req.body);
-        const upstream = buildUpstreamRequest({
+        const upstream = buildProviderDispatchRequest({
           model: compiledModel.modelName,
           interface: compiledModel.interface,
+          compatibilityProfile: compiledModel.compatibilityProfile,
           request: originalBody,
           capabilities: compiledModel.capabilities
         });
@@ -5508,7 +5608,7 @@ async function run(options = {}) {
     event.emit("onSend", req, reply, payload);
     return payload;
   });
-  server.start();
+  await server.start();
 }
 var import_fs5, import_promises2, import_os2, import_path5, import_json5, import_node_events, import_rotating_file_stream, event;
 var init_index = __esm({
@@ -5542,32 +5642,32 @@ var init_index = __esm({
 });
 
 // src/setup/service.ts
-function decideServiceAction(input2) {
-  if (input2.detectedService.kind === "non_self_occupied") {
+function decideServiceAction(input3) {
+  if (input3.detectedService.kind === "non_self_occupied") {
     throw new Error("target port is occupied by another service");
   }
-  if (input2.detectedService.kind === "none") {
+  if (input3.detectedService.kind === "none") {
     return { kind: "start" };
   }
-  if (input2.detectedService.kind === "self_unhealthy") {
+  if (input3.detectedService.kind === "self_unhealthy") {
     return { kind: "restart" };
   }
-  if (input2.configChanged && input2.detectedService.kind === "self_healthy") {
-    return input2.reloadSupported ? { kind: "reload" } : { kind: "restart" };
+  if (input3.configChanged && input3.detectedService.kind === "self_healthy") {
+    return input3.reloadSupported ? { kind: "reload" } : { kind: "restart" };
   }
   return { kind: "reuse" };
 }
-async function applyServiceAction(input2) {
-  if (input2.action.kind === "start") {
-    await input2.executeStart();
+async function applyServiceAction(input3) {
+  if (input3.action.kind === "start") {
+    await input3.executeStart();
   }
-  if (input2.action.kind === "reload") {
-    await input2.executeReload();
+  if (input3.action.kind === "reload") {
+    await input3.executeReload();
   }
-  if (input2.action.kind === "restart") {
-    await input2.executeRestart();
+  if (input3.action.kind === "restart") {
+    await input3.executeRestart();
   }
-  const healthy = await input2.verifyHealth();
+  const healthy = await input3.verifyHealth();
   if (!healthy) {
     throw new Error("service health check failed");
   }
@@ -5617,9 +5717,12 @@ function inferProtocolFromApiBaseUrl(apiBaseUrl) {
   }
   return "openai";
 }
+function normalizeSegment(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
 function toModelId(name, model, index) {
-  const normalizedName = name.trim() || `provider_${index + 1}`;
-  const normalizedModel = model.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  const normalizedName = normalizeSegment(name) || `provider_${index + 1}`;
+  const normalizedModel = normalizeSegment(model);
   return normalizedModel ? `${normalizedName}_${normalizedModel}` : normalizedName;
 }
 function createEmptyDraft() {
@@ -5634,66 +5737,176 @@ function createNonMigratableResult() {
     draft: createEmptyDraft(),
     skippedFields: [],
     needsCompletion: true,
-    missingFields: ["defaultModel", "apiKey"]
+    missingFields: ["defaultModel", "apiKey", "apiBaseUrl"]
   };
 }
+function inferVendorHintFromLegacyProvider(provider) {
+  const transformerUse = Array.isArray(provider.transformer?.use) ? provider.transformer.use.map((item) => String(item).trim().toLowerCase()) : [];
+  const normalizedName = (provider.name ?? "").trim().toLowerCase();
+  if (transformerUse.includes("openrouter")) {
+    return "openrouter";
+  }
+  if (normalizedName.includes("qianfan")) {
+    return "qianfan-coding";
+  }
+  if (normalizedName.includes("minimax")) {
+    return "minimax-chatcompletion-v2";
+  }
+  return void 0;
+}
 function isLegacyProviderInput(value) {
   return typeof value === "object" && value !== null;
 }
-function migrateLegacyConfig(input2) {
-  if (!Array.isArray(input2.providers)) {
-    return createNonMigratableResult();
+function isLegacyRouterInput(value) {
+  return typeof value === "object" && value !== null;
+}
+function pushUnique(target, value) {
+  if (!target.includes(value)) {
+    target.push(value);
   }
-  if (!input2.providers.every(isLegacyProviderInput)) {
-    return createNonMigratableResult();
+}
+function normalizeLegacyConfig(input3) {
+  const lowerProviders = Array.isArray(input3.providers) && input3.providers.every(isLegacyProviderInput) ? input3.providers : null;
+  const upperProviders = Array.isArray(input3.Providers) && input3.Providers.every(isLegacyProviderInput) ? input3.Providers : null;
+  const providerKey = lowerProviders && lowerProviders.length > 0 ? "providers" : upperProviders && upperProviders.length > 0 ? "Providers" : lowerProviders ? "providers" : upperProviders ? "Providers" : null;
+  if (!providerKey) {
+    return null;
+  }
+  const rawProviders = providerKey === "providers" ? lowerProviders : upperProviders;
+  if (!rawProviders) {
+    return null;
   }
   const skippedFields = [];
-  const providers = input2.providers.map((provider, index) => {
+  const alternateProviderKey = providerKey === "providers" ? "Providers" : "providers";
+  const alternateDefaultKey = providerKey === "providers" ? "Router" : "default";
+  const alternateDefaultValue = providerKey === "providers" ? input3.Router : input3.default;
+  const alternateProviders = providerKey === "providers" ? upperProviders : lowerProviders;
+  if (alternateProviders !== null) {
+    pushUnique(skippedFields, alternateProviderKey);
+  }
+  if (alternateDefaultValue !== void 0) {
+    pushUnique(skippedFields, alternateDefaultKey);
+  }
+  const consumedTopLevelFields = /* @__PURE__ */ new Set([providerKey]);
+  const providers = rawProviders.map((provider, index) => {
     if (provider.transformer !== void 0) {
-      skippedFields.push(`providers[${index}].transformer`);
+      pushUnique(skippedFields, `${providerKey}[${index}].transformer`);
+    }
+    if (provider.headers !== void 0) {
+      pushUnique(skippedFields, `${providerKey}[${index}].headers`);
     }
     return {
       name: provider.name ?? "",
       api_base_url: provider.api_base_url,
       api_key: provider.api_key ?? "",
-      models: Array.isArray(provider.models) ? provider.models : []
+      models: Array.isArray(provider.models) ? provider.models : [],
+      vendor_hint: inferVendorHintFromLegacyProvider(provider)
     };
   });
-  const models = providers.flatMap(
+  let defaultRoute;
+  if (providerKey === "providers") {
+    consumedTopLevelFields.add("default");
+    defaultRoute = typeof input3.default === "string" ? input3.default : void 0;
+  } else {
+    consumedTopLevelFields.add("Router");
+    if (isLegacyRouterInput(input3.Router)) {
+      defaultRoute = typeof input3.Router.default === "string" ? input3.Router.default : void 0;
+      if (input3.Router.background !== void 0) {
+        pushUnique(skippedFields, "Router.background");
+      }
+      if (input3.Router.think !== void 0) {
+        pushUnique(skippedFields, "Router.think");
+      }
+      if (input3.Router.longContext !== void 0) {
+        pushUnique(skippedFields, "Router.longContext");
+      }
+      if (input3.Router.longContextThreshold !== void 0) {
+        pushUnique(skippedFields, "Router.longContextThreshold");
+      }
+    }
+  }
+  for (const key of Object.keys(input3)) {
+    if (consumedTopLevelFields.has(key)) {
+      continue;
+    }
+    pushUnique(skippedFields, key);
+  }
+  return {
+    providers,
+    defaultRoute,
+    skippedFields
+  };
+}
+function migrateLegacyConfig(input3) {
+  const normalized = normalizeLegacyConfig(input3);
+  if (!normalized) {
+    return createNonMigratableResult();
+  }
+  const rawEntries = normalized.providers.flatMap(
     (provider, providerIndex) => (provider.models.length ? provider.models : [""]).map((model) => ({
-      id: toModelId(provider.name, model, providerIndex),
+      candidateId: toModelId(provider.name, model, providerIndex),
       api: provider.api_base_url,
       api_base_url: provider.api_base_url,
       key: provider.api_key,
       api_key: provider.api_key,
       interface: inferProtocolFromApiBaseUrl(provider.api_base_url),
       protocol: inferProtocolFromApiBaseUrl(provider.api_base_url),
-      model
-    }))
-  ).filter((item) => item.model);
-  if (input2.trigger_router !== void 0) {
-    skippedFields.push("trigger_router");
-  }
-  const hasDefaultModel = typeof input2.default === "string" && input2.default.length > 0;
-  const defaultModelId = hasDefaultModel ? (() => {
-    const [providerName, modelName] = String(input2.default).split(",");
-    return models.find((item) => item.id === toModelId(providerName, modelName, 0) || item.id.startsWith(`${providerName}_`) && item.model === modelName)?.id;
+      model,
+      providerName: provider.name,
+      vendorHint: provider.vendor_hint
+    })).filter((item) => item.model)
+  );
+  const seenIds = /* @__PURE__ */ new Map();
+  const routeLookup = /* @__PURE__ */ new Map();
+  const models = rawEntries.map((entry) => {
+    const count = seenIds.get(entry.candidateId) ?? 0;
+    seenIds.set(entry.candidateId, count + 1);
+    const finalId = count === 0 ? entry.candidateId : `${entry.candidateId}_${count + 1}`;
+    routeLookup.set(`${entry.providerName.trim()},${entry.model}`, finalId);
+    return {
+      id: finalId,
+      api: entry.api,
+      api_base_url: entry.api_base_url,
+      key: entry.key,
+      api_key: entry.api_key,
+      interface: entry.interface,
+      protocol: entry.protocol,
+      model: entry.model,
+      metadata: entry.vendorHint ? {
+        vendor_hint: entry.vendorHint
+      } : void 0
+    };
+  });
+  const hasLegacyDefaultRoute = typeof normalized.defaultRoute === "string" && normalized.defaultRoute.length > 0;
+  const defaultModelId = hasLegacyDefaultRoute ? (() => {
+    const [rawProviderName, rawModelName] = String(normalized.defaultRoute).split(",");
+    const providerName = (rawProviderName ?? "").trim();
+    const modelName = (rawModelName ?? "").trim();
+    const fromLookup = routeLookup.get(`${providerName},${modelName}`);
+    if (fromLookup) return fromLookup;
+    return models.find(
+      (item) => item.id === toModelId(providerName, modelName, 0) || item.id.startsWith(`${normalizeSegment(providerName)}_`) && item.model === modelName
+    )?.id;
   })() : void 0;
-  const hasMissingApiKey = providers.some((provider) => provider.api_key.length === 0);
+  const hasMissingApiKey = normalized.providers.some((provider) => provider.api_key.length === 0);
+  const hasMissingApiBaseUrl = normalized.providers.some((provider) => (provider.api_base_url?.trim() ?? "").length === 0);
   const missingFields = [];
-  if (!hasDefaultModel) {
+  if (!defaultModelId) {
     missingFields.push("defaultModel");
   }
   if (hasMissingApiKey) {
     missingFields.push("apiKey");
   }
+  if (hasMissingApiBaseUrl) {
+    missingFields.push("apiBaseUrl");
+  }
   return {
     draft: {
       Providers: [],
       Models: models,
-      Router: hasDefaultModel && defaultModelId ? { default: defaultModelId } : {}
+      Router: defaultModelId ? { default: defaultModelId } : {}
     },
-    skippedFields,
+    skippedFields: normalized.skippedFields,
     needsCompletion: missingFields.length > 0,
     missingFields
   };
@@ -5758,11 +5971,12 @@ function getProviderPreset2(key) {
     api: preset.api,
     api_base_url: preset.api_base_url,
     interface: preset.interface,
-    protocol: preset.protocol
+    protocol: preset.protocol,
+    default_thinking: preset.default_thinking
   };
 }
-function buildMinimalConfig(input2) {
-  const providers = input2.providers;
+function buildMinimalConfig(input3) {
+  const providers = input3.providers;
   const models = providers.map((p) => {
     const preset = p.preset ? getProviderPreset2(p.preset) : void 0;
     const modelDraft = {
@@ -5782,15 +5996,15 @@ function buildMinimalConfig(input2) {
     }
     return modelDraft;
   });
-  let defaultModel = input2.defaultModel?.trim();
-  if (input2.defaultModel && input2.defaultModel.includes(",")) {
-    const [providerName, modelName] = input2.defaultModel.split(",");
+  let defaultModel = input3.defaultModel?.trim();
+  if (input3.defaultModel && input3.defaultModel.includes(",")) {
+    const [providerName, modelName] = input3.defaultModel.split(",");
     const matched = models.find((item) => item.id === providerName && item.model === modelName);
     if (matched) {
       defaultModel = matched.id;
     }
   }
-  if (input2.defaultModel === void 0 && models.length > 0) {
+  if (input3.defaultModel === void 0 && models.length > 0) {
     const firstModelId = models[0].id;
     if (firstModelId && models[0].model) {
       defaultModel = firstModelId;
@@ -5804,31 +6018,68 @@ function buildMinimalConfig(input2) {
     Router: defaultModel ? { default: defaultModel } : {}
   };
 }
+function buildUsableMinimalTemplateConfig() {
+  const openRouterPreset = getProviderPreset("openrouter");
+  const modelId = openRouterPreset?.suggested_id ?? "sonnet";
+  const modelName = openRouterPreset?.default_model ?? "anthropic/claude-sonnet-4";
+  const thinking = openRouterPreset?.default_thinking ?? "auto";
+  const draft = buildMinimalConfig({
+    providers: [
+      {
+        name: "openrouter",
+        model_id: modelId,
+        preset: "openrouter",
+        api_key: "sk-xxx",
+        models: [modelName]
+      }
+    ],
+    defaultModel: modelId
+  });
+  const primaryModel = draft.Models?.[0];
+  return {
+    HOST: DEFAULT_CONFIG2.HOST,
+    PORT: DEFAULT_CONFIG2.PORT,
+    LOG: DEFAULT_CONFIG2.LOG,
+    LOG_LEVEL: DEFAULT_CONFIG2.LOG_LEVEL,
+    Models: primaryModel ? [
+      {
+        id: primaryModel.id,
+        api: primaryModel.api,
+        key: primaryModel.key,
+        interface: primaryModel.interface,
+        model: primaryModel.model,
+        thinking
+      }
+    ] : [],
+    Router: draft.Router
+  };
+}
 var init_templates = __esm({
   "src/setup/templates.ts"() {
     "use strict";
+    init_constants();
     init_provider_presets();
   }
 });
 
 // src/setup/persist.ts
-async function persistSetupConfig(input2) {
-  const errors = input2.validateConfig(input2.config);
+async function persistSetupConfig(input3) {
+  const errors = input3.validateConfig(input3.config);
   if (errors.length > 0) {
     throw new Error("config validation failed");
   }
   let backupPath;
-  if (input2.hasExistingConfig) {
-    const createdBackupPath = await input2.backupCurrentConfig();
+  if (input3.hasExistingConfig) {
+    const createdBackupPath = await input3.backupCurrentConfig();
     if (!createdBackupPath) {
       throw new Error("failed to back up existing config");
     }
     backupPath = createdBackupPath;
   }
-  await input2.writeConfig(input2.config);
+  await input3.writeConfig(input3.config);
   return {
     configChanged: true,
-    configPath: input2.currentConfigPath,
+    configPath: input3.currentConfigPath,
     backupPath
   };
 }
@@ -5877,8 +6128,8 @@ function ensureLegacyFlow(detection, legacyConfigAction) {
 function invalidAction() {
   return invalidCurrentAction();
 }
-function decideSetupBranch(input2) {
-  const { detection, currentConfigAction, legacyConfigAction } = input2;
+function decideSetupBranch(input3) {
+  const { detection, currentConfigAction, legacyConfigAction } = input3;
   if (currentConfigAction === "cancel") {
     ensureNoLegacyAction(legacyConfigAction);
     return { kind: "cancelled" };
@@ -5931,6 +6182,28 @@ function getTargetConfigPath(detection) {
   }
   return CONFIG_FILE;
 }
+function getLegacyProviderCount(input3) {
+  if (typeof input3 !== "object" || input3 === null) {
+    return 0;
+  }
+  const legacyConfig = input3;
+  if (Array.isArray(legacyConfig.providers)) {
+    return legacyConfig.providers.length;
+  }
+  if (Array.isArray(legacyConfig.Providers)) {
+    return legacyConfig.Providers.length;
+  }
+  return 0;
+}
+function getMigratedModelCount(draft) {
+  if (Array.isArray(draft.Models)) {
+    return draft.Models.length;
+  }
+  if (Array.isArray(draft.Providers)) {
+    return draft.Providers.reduce((total, provider) => total + (provider.models?.length ?? 0), 0);
+  }
+  return 0;
+}
 async function runSetup(deps) {
   const detection = await deps.detectSetupEnvironment();
   const currentConfigAction = await deps.chooseCurrentConfigAction({
@@ -5938,7 +6211,7 @@ async function runSetup(deps) {
     legacyConfig: detection.legacyConfig
   });
   let legacyConfigAction;
-  if (currentConfigAction === "create" || currentConfigAction === "overwrite") {
+  if (currentConfigAction === "create" || currentConfigAction === "overwrite" || currentConfigAction === "fresh") {
     if (detection.legacyConfig.kind === "found" || detection.legacyConfig.kind === "read_error") {
       legacyConfigAction = await deps.chooseLegacyConfigAction({
         legacyConfig: detection.legacyConfig
@@ -6012,6 +6285,16 @@ async function runSetup(deps) {
       throw new Error("migrate_legacy requires legacy config");
     }
     const migrated = deps.migrateLegacyConfig(detection.legacyConfig.config);
+    deps.io.info(`\u5DF2\u8BC6\u522B\u65E7\u914D\u7F6E\u4E2D\u7684 ${getLegacyProviderCount(detection.legacyConfig.config)} \u4E2A provider\u3002`);
+    deps.io.info(`\u5DF2\u4ECE\u65E7\u914D\u7F6E\u8FC1\u79FB ${getMigratedModelCount(migrated.draft)} \u4E2A\u6A21\u578B\u3002`);
+    if (migrated.draft.Router.default) {
+      deps.io.info(`\u8FC1\u79FB\u540E\u7684\u9ED8\u8BA4\u6A21\u578B\uFF1A${migrated.draft.Router.default}`);
+    } else {
+      deps.io.info("\u8FC1\u79FB\u540E\u7684\u9ED8\u8BA4\u6A21\u578B\u4ECD\u9700\u8865\u5168\u3002");
+    }
+    if (migrated.skippedFields.length > 0) {
+      deps.io.info(`\u4EE5\u4E0B\u65E7\u5B57\u6BB5\u672A\u81EA\u52A8\u8FC1\u79FB\uFF1A${migrated.skippedFields.join(", ")}`);
+    }
     let finalDraft = migrated.draft;
     if (migrated.needsCompletion) {
       finalDraft = await deps.completeDraft({
@@ -6046,6 +6329,96 @@ var init_setup = __esm({
 
 // src/setup/index.ts
 function createConsoleIO() {
+  if (process.env.CTR_SETUP_FORCE_SCRIPTED_INPUT === "1") {
+    const scriptedInput = (0, import_fs6.readFileSync)(0, "utf-8");
+    const answers = scriptedInput.split(/\r?\n/).map((item) => item.trim()).filter((item) => item.length > 0);
+    let cursor = 0;
+    const nextAnswer = async () => answers[cursor++] ?? "";
+    return {
+      async choose(message, options) {
+        import_process.stdout.write(`${message}
+`);
+        options.forEach((option, index) => {
+          import_process.stdout.write(`  ${index + 1}. ${option}
+`);
+        });
+        const answer = await nextAnswer();
+        const pickedIndex = Number(answer);
+        if (Number.isInteger(pickedIndex) && pickedIndex >= 1 && pickedIndex <= options.length) {
+          return options[pickedIndex - 1];
+        }
+        const matched = options.find((option) => option === answer);
+        if (matched) {
+          return matched;
+        }
+        throw new Error(`invalid scripted answer for "${message}": ${answer || "<empty>"}`);
+      },
+      async input(message, defaultValue) {
+        const suffix = defaultValue ? ` (${defaultValue})` : "";
+        import_process.stdout.write(`${message}${suffix}: `);
+        const answer = await nextAnswer();
+        return answer || defaultValue || "";
+      },
+      info(message) {
+        import_process.stdout.write(`${message}
+`);
+      },
+      close() {
+      }
+    };
+  }
+  if (!import_process.stdin.isTTY) {
+    let loaded = false;
+    let answers = [];
+    let cursor = 0;
+    const loadAnswers = async () => {
+      if (loaded) {
+        return;
+      }
+      loaded = true;
+      const chunks = [];
+      for await (const chunk of import_process.stdin) {
+        chunks.push(String(chunk));
+      }
+      answers = chunks.join("").split(/\r?\n/).map((item) => item.trim()).filter((item) => item.length > 0);
+    };
+    const nextAnswer = async () => {
+      await loadAnswers();
+      return answers[cursor++] ?? "";
+    };
+    return {
+      async choose(message, options) {
+        import_process.stdout.write(`${message}
+`);
+        options.forEach((option, index) => {
+          import_process.stdout.write(`  ${index + 1}. ${option}
+`);
+        });
+        const answer = await nextAnswer();
+        const pickedIndex = Number(answer);
+        if (Number.isInteger(pickedIndex) && pickedIndex >= 1 && pickedIndex <= options.length) {
+          return options[pickedIndex - 1];
+        }
+        const matched = options.find((option) => option === answer);
+        if (matched) {
+          return matched;
+        }
+        throw new Error(`invalid scripted answer for "${message}": ${answer || "<empty>"}`);
+      },
+      async input(message, defaultValue) {
+        const suffix = defaultValue ? ` (${defaultValue})` : "";
+        import_process.stdout.write(`${message}${suffix}: `);
+        const answer = await nextAnswer();
+        return answer || defaultValue || "";
+      },
+      info(message) {
+        import_process.stdout.write(`${message}
+`);
+      },
+      close() {
+      }
+    };
+  }
   const rl = (0, import_promises3.createInterface)({ input: import_process.stdin, output: import_process.stdout });
   const ask = async (message) => {
     const answer = await rl.question(message);
@@ -6080,6 +6453,9 @@ function createConsoleIO() {
     info(message) {
       import_process.stdout.write(`${message}
 `);
+    },
+    close() {
+      rl.close();
     }
   };
 }
@@ -6090,14 +6466,79 @@ function readStructuredConfigFile(filePath) {
   }
   return import_js_yaml.default.load(content);
 }
+function getCurrentRuntimeFields() {
+  const candidates = [CONFIG_FILE, CONFIG_FILE_YML, CONFIG_FILE_JSON];
+  const currentPath = candidates.find((filePath) => (0, import_fs6.existsSync)(filePath));
+  if (!currentPath) {
+    return {};
+  }
+  try {
+    const config = readStructuredConfigFile(currentPath);
+    if (!config || typeof config !== "object") {
+      return {};
+    }
+    const fields = {};
+    for (const key of ["HOST", "PORT", "LOG", "LOG_LEVEL", "API_TIMEOUT_MS"]) {
+      if (config[key] !== void 0) {
+        fields[key] = config[key];
+      }
+    }
+    return fields;
+  } catch {
+    return {};
+  }
+}
+function getConfiguredPortFromCurrentFiles() {
+  const candidates = [CONFIG_FILE, CONFIG_FILE_YML, CONFIG_FILE_JSON];
+  const currentPath = candidates.find((filePath) => (0, import_fs6.existsSync)(filePath));
+  if (!currentPath) {
+    return DEFAULT_CONFIG2.PORT;
+  }
+  try {
+    const config = readStructuredConfigFile(currentPath);
+    if (config && typeof config.PORT === "number" && Number.isFinite(config.PORT) && config.PORT > 0) {
+      return config.PORT;
+    }
+  } catch {
+  }
+  return DEFAULT_CONFIG2.PORT;
+}
+async function getAvailablePort() {
+  const server = (0, import_net2.createServer)();
+  try {
+    return await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(0, "127.0.0.1", () => {
+        const address = server.address();
+        if (!address || typeof address === "string") {
+          reject(new Error("failed to resolve available port"));
+          return;
+        }
+        resolve(address.port);
+      });
+    });
+  } finally {
+    if (server.listening) {
+      await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+    }
+  }
+}
+function readLegacyConfigFile(filePath) {
+  const content = (0, import_fs6.readFileSync)(filePath, "utf-8");
+  if (filePath.endsWith(".json")) {
+    return import_json52.default.parse(content);
+  }
+  return import_js_yaml.default.load(content);
+}
 async function readLegacyConfig(deps = {}) {
   const baseHomeDir = deps.homeDir || (0, import_os3.homedir)();
   const exists = deps.exists || import_fs6.existsSync;
-  const readConfig = deps.readConfig || readStructuredConfigFile;
+  const readConfig = deps.readConfig || readLegacyConfigFile;
   const overridePath = process.env.CTR_SETUP_LEGACY_CONFIG_PATH;
   const candidatePaths = overridePath ? [overridePath] : [
     (0, import_path6.join)(baseHomeDir, ".ccr", "config.yaml"),
-    (0, import_path6.join)(baseHomeDir, ".claude-code-router", "config.yaml")
+    (0, import_path6.join)(baseHomeDir, ".claude-code-router", "config.yaml"),
+    (0, import_path6.join)(baseHomeDir, ".claude-code-router", "config.json")
   ];
   const legacyPath = candidatePaths.find((filePath) => exists(filePath));
   if (!legacyPath) {
@@ -6140,16 +6581,30 @@ async function readCurrentConfig() {
   }
 }
 async function probeService() {
-  const healthy = await waitForService(DEFAULT_CONFIG2.PORT, 500);
-  return healthy ? { kind: "self_healthy", port: DEFAULT_CONFIG2.PORT } : { kind: "none" };
+  const port = getConfiguredPortFromCurrentFiles();
+  const healthy = await waitForService(port, 500);
+  if (healthy) {
+    return isServiceRunning() ? { kind: "self_healthy", port } : { kind: "non_self_occupied", port };
+  }
+  const occupied = await isTcpPortOccupied(port, 500);
+  if (!occupied) {
+    return { kind: "none" };
+  }
+  return isServiceRunning() ? { kind: "self_unhealthy", port } : { kind: "non_self_occupied", port };
 }
 async function enterClaudeCode() {
+  if (process.env.CTR_SETUP_SKIP_ENTER_CODE === "1") {
+    return;
+  }
   const cliModule = await Promise.resolve().then(() => (init_cli(), cli_exports));
   await cliModule.runClaudeCode();
 }
+function shouldAutoEnterClaudeCodeAfterSetup() {
+  return process.env.CTR_SETUP_AUTO_ENTER_CODE === "1";
+}
 async function executeStart() {
   const childProcess = await import("child_process");
-  childProcess.spawn(process.execPath, [process.argv[1], "start", "--daemon"], {
+  childProcess.spawn(process.execPath, [process.argv[1], "start"], {
     detached: true,
     stdio: "ignore",
     env: { ...process.env, CTR_DAEMON: "1" }
@@ -6339,12 +6794,12 @@ async function buildFreshConfig(io) {
   }
   return draft;
 }
-async function completeDraft(input2) {
-  const draft = toDraftFromConfig(input2.draft);
-  if (input2.fields.includes("defaultModel")) {
+async function completeDraft(input3) {
+  const draft = toDraftFromConfig(input3.draft);
+  if (input3.fields.includes("defaultModel")) {
     const defaultProvider = draft.Models?.[0]?.id ?? draft.Providers?.[0]?.name ?? "provider";
     const defaultModel = draft.Models?.[0]?.model ?? draft.Providers?.[0]?.models?.[0] ?? "";
-    const model = await input2.io.input("\u9ED8\u8BA4\u6A21\u578B", defaultModel);
+    const model = await input3.io.input("\u9ED8\u8BA4\u6A21\u578B", defaultModel);
     if (draft.Models?.[0]) {
       draft.Models[0].model = model;
       draft.Router.default = defaultProvider;
@@ -6353,16 +6808,16 @@ async function completeDraft(input2) {
       draft.Router.default = `${defaultProvider},${model}`;
     }
   }
-  if (input2.fields.includes("apiKey")) {
-    const apiKey = await input2.io.input("API Key");
+  if (input3.fields.includes("apiKey")) {
+    const apiKey = await input3.io.input("API Key");
     if (draft.Models?.length) {
       draft.Models = draft.Models.map((model) => ({ ...model, key: model.key || apiKey, api_key: model.api_key || apiKey }));
     } else {
       draft.Providers = draft.Providers?.map((provider) => ({ ...provider, api_key: provider.api_key || apiKey }));
     }
   }
-  if (input2.fields.includes("apiBaseUrl")) {
-    const apiBaseUrl = await input2.io.input("API Base URL");
+  if (input3.fields.includes("apiBaseUrl")) {
+    const apiBaseUrl = await input3.io.input("API Base URL");
     if (draft.Models?.length) {
       draft.Models = draft.Models.map((model) => ({
         ...model,
@@ -6376,8 +6831,8 @@ async function completeDraft(input2) {
       }));
     }
   }
-  if (input2.fields.includes("capabilityHints") && draft.Models?.[0]) {
-    await promptCapabilityMetadataForDraft(draft, input2.io);
+  if (input3.fields.includes("capabilityHints") && draft.Models?.[0]) {
+    await promptCapabilityMetadataForDraft(draft, input3.io);
   }
   return draft;
 }
@@ -6391,112 +6846,150 @@ function createDefaultDeps(io = createConsoleIO()) {
     executeStart,
     executeReload: executeRestart,
     executeRestart,
-    verifyHealth: () => waitForService(DEFAULT_CONFIG2.PORT, 5e3),
+    verifyHealth: () => waitForService(getConfiguredPortFromCurrentFiles(), 5e3),
     enterClaudeCode,
     io
   };
 }
+function printRoutingNextSteps(io) {
+  io.info("\u4F60\u53EF\u4EE5\u6309\u9700\u7EE7\u7EED\u914D\u7F6E\u8DEF\u7531\u80FD\u529B\uFF1A");
+  io.info("  - TriggerRouter\uFF1A\u9002\u5408\u9AD8\u786E\u5B9A\u6027\u4EFB\u52A1\uFF0C\u628A\u67B6\u6784\u8BBE\u8BA1\u3001\u4EE3\u7801\u5BA1\u67E5\u7B49\u8BF7\u6C42\u56FA\u5B9A\u5207\u5230\u6307\u5B9A\u6A21\u578B");
+  io.info("  - SmartRouter\uFF1A\u9002\u5408\u6A21\u7CCA\u4EFB\u52A1\uFF0C\u5728\u5019\u9009\u6A21\u578B\u4E4B\u95F4\u81EA\u52A8\u9009\u62E9\u66F4\u5408\u9002\u7684\u6A21\u578B");
+  io.info("  - \u914D\u7F6E\u6A21\u677F\u53C2\u8003\uFF1Aconfig/trigger.advanced.yaml");
+}
 async function runSetupCli(customDeps) {
   const defaults = createDefaultDeps(customDeps?.io);
   const deps = { ...defaults, ...customDeps };
-  await runSetup({
-    detectSetupEnvironment: () => detectSetupEnvironment({
-      readCurrentConfig: deps.readCurrentConfig,
-      readLegacyConfig: deps.readLegacyConfig,
-      probeService: deps.probeService
-    }),
-    chooseCurrentConfigAction: async ({ currentConfig }) => {
-      if (currentConfig.kind === "missing") {
-        return "create";
-      }
-      if (currentConfig.kind === "valid") {
-        deps.io.info("\u68C0\u6D4B\u5230\u5F53\u524D claude-trigger-router \u914D\u7F6E\u5DF2\u53EF\u7528\u3002");
-        if (currentConfig.warnings.length > 0) {
-          deps.io.info(`\u5F53\u524D\u914D\u7F6E\u63D0\u793A\uFF1A${currentConfig.warnings.join("; ")}`);
-        }
-        return mapValidCurrentConfigChoice(
-          await deps.io.choose("\u4F60\u60F3\u76F4\u63A5\u4F7F\u7528\u5B83\uFF0C\u8FD8\u662F\u91CD\u65B0\u8C03\u6574\uFF1F", [
-            "\u76F4\u63A5\u4F7F\u7528\u5F53\u524D\u914D\u7F6E\uFF08\u63A8\u8350\uFF09",
-            "\u68C0\u67E5\u5E76\u8C03\u6574\u5F53\u524D\u914D\u7F6E",
-            "\u653E\u5F03\u5F53\u524D\u914D\u7F6E\uFF0C\u91CD\u65B0\u5F00\u59CB"
-          ])
-        );
-      }
-      if (currentConfig.kind === "invalid") {
-        deps.io.info(`\u5F53\u524D\u914D\u7F6E\u6821\u9A8C\u5931\u8D25\uFF1A${currentConfig.errors.join("; ")}`);
-        if (currentConfig.warnings.length > 0) {
-          deps.io.info(`\u5F53\u524D\u914D\u7F6E\u63D0\u793A\uFF1A${currentConfig.warnings.join("; ")}`);
+  try {
+    await runSetup({
+      detectSetupEnvironment: () => detectSetupEnvironment({
+        readCurrentConfig: deps.readCurrentConfig,
+        readLegacyConfig: deps.readLegacyConfig,
+        probeService: deps.probeService
+      }),
+      chooseCurrentConfigAction: async ({ currentConfig }) => {
+        if (currentConfig.kind === "missing") {
+          return "create";
+        }
+        if (currentConfig.kind === "valid") {
+          deps.io.info("\u68C0\u6D4B\u5230\u5F53\u524D claude-trigger-router \u914D\u7F6E\u5DF2\u53EF\u7528\u3002");
+          if (currentConfig.warnings.length > 0) {
+            deps.io.info(`\u5F53\u524D\u914D\u7F6E\u63D0\u793A\uFF1A${currentConfig.warnings.join("; ")}`);
+          }
+          return mapValidCurrentConfigChoice(
+            await deps.io.choose("\u4F60\u60F3\u76F4\u63A5\u4F7F\u7528\u5B83\uFF0C\u8FD8\u662F\u91CD\u65B0\u8C03\u6574\uFF1F", [
+              "\u76F4\u63A5\u4F7F\u7528\u5F53\u524D\u914D\u7F6E\uFF08\u63A8\u8350\uFF09",
+              "\u68C0\u67E5\u5E76\u8C03\u6574\u5F53\u524D\u914D\u7F6E",
+              "\u653E\u5F03\u5F53\u524D\u914D\u7F6E\uFF0C\u91CD\u65B0\u5F00\u59CB"
+            ])
+          );
         }
-        return await deps.io.choose("\u9009\u62E9\u4E0B\u4E00\u6B65", ["repair", "overwrite", "cancel"]);
-      }
-      deps.io.info(`\u5F53\u524D\u914D\u7F6E\u65E0\u6CD5\u89E3\u6790\uFF1A${currentConfig.error}`);
-      return await deps.io.choose("\u9009\u62E9\u4E0B\u4E00\u6B65", ["rebuild", "cancel"]);
-    },
-    chooseLegacyConfigAction: async ({ legacyConfig }) => {
-      if (legacyConfig.kind === "found") {
-        return mapLegacyConfigChoice(
-          await deps.io.choose("\u68C0\u6D4B\u5230\u65E7 claude-code-router \u914D\u7F6E\u3002\u662F\u5426\u8FC1\u79FB\u4E3A\u5F53\u524D\u63A8\u8350\u914D\u7F6E\uFF1F", [
-            "\u8FC1\u79FB\u65E7\u914D\u7F6E\uFF08\u63A8\u8350\uFF09",
-            "\u8DF3\u8FC7\u8FC1\u79FB\uFF0C\u624B\u52A8\u65B0\u5EFA"
-          ])
-        );
-      }
-      if (legacyConfig.kind === "read_error") {
-        deps.io.info(`\u65E7 ccr \u914D\u7F6E\u8BFB\u53D6\u5931\u8D25\uFF1A${legacyConfig.error}`);
-      }
-      return "skip";
-    },
-    buildFreshConfig: () => buildFreshConfig(deps.io),
-    buildRepairConfig: async ({ currentConfig }) => toDraftFromConfig(currentConfig),
-    completeDraft: ({ draft, fields }) => completeDraft({ draft, fields, io: deps.io }),
-    migrateLegacyConfig,
-    mapConfigErrorsToRepairFields,
-    persistConfig: async ({ config, currentConfigPath, hasExistingConfig }) => {
-      const normalized = normalizeAndValidateConfig(config);
-      const persisted = await persistSetupConfig({
-        config: normalized.config,
-        currentConfigPath,
-        hasExistingConfig,
-        validateConfig: (inputConfig) => normalizeAndValidateConfig(inputConfig).errors,
-        backupCurrentConfig: deps.backupCurrentConfig,
-        writeConfig: deps.writeConfig
-      });
-      if (normalized.warnings.length > 0) {
-        deps.io.info(`\u914D\u7F6E\u63D0\u793A\uFF1A${normalized.warnings.join("; ")}`);
-      }
-      return persisted;
-    },
-    ensureServiceReady: async ({ configChanged, detectedService, reloadSupported }) => {
-      const action = decideServiceAction({
-        configChanged,
-        detectedService,
-        reloadSupported
-      });
-      await applyServiceAction({
-        action,
-        executeStart: deps.executeStart,
-        executeReload: deps.executeReload,
-        executeRestart: deps.executeRestart,
-        verifyHealth: deps.verifyHealth
-      });
-      return {
-        action: action.kind,
-        healthChecked: true
-      };
-    },
-    enterClaudeCode: deps.enterClaudeCode,
-    reloadSupported: false
-  });
+        if (currentConfig.kind === "invalid") {
+          deps.io.info(`\u5F53\u524D\u914D\u7F6E\u6821\u9A8C\u5931\u8D25\uFF1A${currentConfig.errors.join("; ")}`);
+          if (currentConfig.warnings.length > 0) {
+            deps.io.info(`\u5F53\u524D\u914D\u7F6E\u63D0\u793A\uFF1A${currentConfig.warnings.join("; ")}`);
+          }
+          return await deps.io.choose("\u9009\u62E9\u4E0B\u4E00\u6B65", ["repair", "overwrite", "cancel"]);
+        }
+        deps.io.info(`\u5F53\u524D\u914D\u7F6E\u65E0\u6CD5\u89E3\u6790\uFF1A${currentConfig.error}`);
+        return await deps.io.choose("\u9009\u62E9\u4E0B\u4E00\u6B65", ["rebuild", "cancel"]);
+      },
+      chooseLegacyConfigAction: async ({ legacyConfig }) => {
+        if (legacyConfig.kind === "found") {
+          return mapLegacyConfigChoice(
+            await deps.io.choose("\u68C0\u6D4B\u5230\u65E7 claude-code-router \u914D\u7F6E\u3002\u662F\u5426\u8FC1\u79FB\u4E3A\u5F53\u524D\u63A8\u8350\u914D\u7F6E\uFF1F", [
+              "\u8FC1\u79FB\u65E7\u914D\u7F6E\uFF08\u63A8\u8350\uFF09",
+              "\u8DF3\u8FC7\u8FC1\u79FB\uFF0C\u624B\u52A8\u65B0\u5EFA"
+            ])
+          );
+        }
+        if (legacyConfig.kind === "read_error") {
+          deps.io.info(`\u65E7 ccr \u914D\u7F6E\u8BFB\u53D6\u5931\u8D25\uFF1A${legacyConfig.error}`);
+        }
+        return "skip";
+      },
+      buildFreshConfig: () => buildFreshConfig(deps.io),
+      buildRepairConfig: async ({ currentConfig }) => toDraftFromConfig(currentConfig),
+      completeDraft: ({ draft, fields }) => completeDraft({ draft, fields, io: deps.io }),
+      migrateLegacyConfig,
+      mapConfigErrorsToRepairFields,
+      io: deps.io,
+      persistConfig: async ({ config, currentConfigPath, hasExistingConfig }) => {
+        let normalized = normalizeAndValidateConfig({
+          ...hasExistingConfig ? getCurrentRuntimeFields() : {},
+          ...config
+        });
+        {
+          const targetPort = normalized.config.PORT ?? DEFAULT_CONFIG2.PORT;
+          const occupied = await isTcpPortOccupied(targetPort, 500);
+          if (occupied && !isServiceRunning()) {
+            const fallbackPort = await getAvailablePort();
+            deps.io.info(`\u68C0\u6D4B\u5230\u9ED8\u8BA4\u7AEF\u53E3 ${targetPort} \u5DF2\u88AB\u5360\u7528\uFF0Csetup \u5DF2\u81EA\u52A8\u6539\u7528\u53EF\u7528\u7AEF\u53E3 ${fallbackPort}\u3002`);
+            normalized = normalizeAndValidateConfig({
+              ...normalized.config,
+              PORT: fallbackPort
+            });
+          }
+        }
+        const persisted = await persistSetupConfig({
+          config: normalized.config,
+          currentConfigPath,
+          hasExistingConfig,
+          validateConfig: (inputConfig) => normalizeAndValidateConfig(inputConfig).errors,
+          backupCurrentConfig: deps.backupCurrentConfig,
+          writeConfig: deps.writeConfig
+        });
+        if (normalized.warnings.length > 0) {
+          deps.io.info(`\u914D\u7F6E\u63D0\u793A\uFF1A${normalized.warnings.join("; ")}`);
+        }
+        return persisted;
+      },
+      ensureServiceReady: async ({ configChanged, detectedService, reloadSupported }) => {
+        const effectiveDetectedService = configChanged ? await deps.probeService() : detectedService;
+        const action = decideServiceAction({
+          configChanged,
+          detectedService: effectiveDetectedService,
+          reloadSupported
+        });
+        await applyServiceAction({
+          action,
+          executeStart: deps.executeStart,
+          executeReload: deps.executeReload,
+          executeRestart: deps.executeRestart,
+          verifyHealth: deps.verifyHealth
+        });
+        return {
+          action: action.kind,
+          healthChecked: true
+        };
+      },
+      enterClaudeCode: async () => {
+        printRoutingNextSteps(deps.io);
+        if (!shouldAutoEnterClaudeCodeAfterSetup()) {
+          deps.io.info("\u4E3A\u907F\u514D setup \u7ED3\u675F\u540E\u63A5\u7BA1\u5F53\u524D\u7EC8\u7AEF\uFF0C\u8BF7\u624B\u52A8\u8FD0\u884C\uFF1Actr code");
+          deps.io.info("\u5982\u679C\u4F60\u660E\u786E\u9700\u8981 setup \u7ED3\u675F\u540E\u81EA\u52A8\u8FDB\u5165 Claude Code\uFF0C\u53EF\u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF CTR_SETUP_AUTO_ENTER_CODE=1");
+          return;
+        }
+        deps.io.close?.();
+        await deps.enterClaudeCode();
+      },
+      reloadSupported: false
+    });
+  } finally {
+    deps.io.close?.();
+  }
 }
-var import_fs6, import_os3, import_path6, import_promises3, import_process, import_js_yaml;
+var import_fs6, import_net2, import_os3, import_path6, import_promises3, import_process, import_json52, import_js_yaml;
 var init_setup2 = __esm({
   "src/setup/index.ts"() {
     "use strict";
     import_fs6 = require("fs");
+    import_net2 = require("net");
     import_os3 = require("os");
     import_path6 = require("path");
     import_promises3 = require("readline/promises");
     import_process = require("process");
+    import_json52 = __toESM(require("json5"));
     import_js_yaml = __toESM(require("js-yaml"));
     init_constants();
     init_provider_presets();
@@ -6513,6 +7006,525 @@ var init_setup2 = __esm({
   }
 });
 
+// src/doctor/index.ts
+function hasArg(flag) {
+  return process.argv.slice(2).includes(flag);
+}
+function createConsoleIO2() {
+  if (process.env.CTR_DOCTOR_FORCE_SCRIPTED_INPUT === "1") {
+    const scriptedInput = (0, import_fs7.readFileSync)(0, "utf-8");
+    const answers = scriptedInput.split(/\r?\n/).map((item) => item.trim()).filter(Boolean);
+    let cursor = 0;
+    const nextAnswer = async () => answers[cursor++] ?? "";
+    return {
+      info(message) {
+        import_process2.stdout.write(`${message}
+`);
+      },
+      error(message) {
+        import_process2.stdout.write(`${message}
+`);
+      },
+      async choose(message, options) {
+        import_process2.stdout.write(`${message}
+`);
+        options.forEach((option, index2) => import_process2.stdout.write(`  ${index2 + 1}. ${option}
+`));
+        const answer = await nextAnswer();
+        const index = Number(answer);
+        if (Number.isInteger(index) && index >= 1 && index <= options.length) {
+          return options[index - 1];
+        }
+        return options.find((option) => option === answer) ?? options[0];
+      },
+      async input(message, defaultValue) {
+        import_process2.stdout.write(`${message}${defaultValue ? ` (${defaultValue})` : ""}: `);
+        const answer = await nextAnswer();
+        return answer || defaultValue || "";
+      },
+      async confirm(message, defaultValue = true) {
+        import_process2.stdout.write(`${message} ${defaultValue ? "[Y/n]" : "[y/N]"}
+`);
+        const answer = (await nextAnswer()).toLowerCase();
+        if (!answer) {
+          return defaultValue;
+        }
+        return ["y", "yes", "1", "true"].includes(answer);
+      },
+      close() {
+      }
+    };
+  }
+  const rl = (0, import_promises4.createInterface)({ input: import_process2.stdin, output: import_process2.stdout });
+  const ask = async (message) => (await rl.question(message)).trim();
+  return {
+    info(message) {
+      import_process2.stdout.write(`${message}
+`);
+    },
+    error(message) {
+      import_process2.stdout.write(`${message}
+`);
+    },
+    async choose(message, options) {
+      import_process2.stdout.write(`${message}
+`);
+      options.forEach((option, index) => import_process2.stdout.write(`  ${index + 1}. ${option}
+`));
+      while (true) {
+        const answer = await ask("> ");
+        const index = Number(answer);
+        if (Number.isInteger(index) && index >= 1 && index <= options.length) {
+          return options[index - 1];
+        }
+        const matched = options.find((option) => option === answer);
+        if (matched) {
+          return matched;
+        }
+        import_process2.stdout.write("\u8BF7\u8F93\u5165\u9009\u9879\u7F16\u53F7\u3002\n");
+      }
+    },
+    async input(message, defaultValue) {
+      const answer = await ask(`${message}${defaultValue ? ` (${defaultValue})` : ""}: `);
+      return answer || defaultValue || "";
+    },
+    async confirm(message, defaultValue = true) {
+      const answer = (await ask(`${message} ${defaultValue ? "[Y/n]" : "[y/N]"}: `)).toLowerCase();
+      if (!answer) {
+        return defaultValue;
+      }
+      return ["y", "yes"].includes(answer);
+    },
+    close() {
+      rl.close();
+    }
+  };
+}
+function getConfigCandidates() {
+  return [CONFIG_FILE, CONFIG_FILE_YML, CONFIG_FILE_JSON];
+}
+function inferInterfaceFromApi(api) {
+  const trimmed = api?.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  return trimmed.includes("/v1/messages") ? "anthropic" : "openai";
+}
+function sanitizeModelId(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "model";
+}
+function tryLoadStructuredConfig(filePath, content) {
+  if (filePath.endsWith(".json")) {
+    try {
+      return { config: JSON.parse(content), repairedParse: false, messages: [] };
+    } catch {
+      return {
+        config: import_json53.default.parse(content),
+        repairedParse: true,
+        messages: ["\u68C0\u6D4B\u5230 JSON \u914D\u7F6E\u5305\u542B\u5BBD\u677E\u8BED\u6CD5\uFF0Cdoctor \u5DF2\u6309\u6807\u51C6 JSON \u7ED3\u6784\u91CD\u65B0\u5F52\u4E00\u5316\u3002"]
+      };
+    }
+  }
+  try {
+    return { config: import_js_yaml2.default.load(content), repairedParse: false, messages: [] };
+  } catch (error) {
+    const sanitized = content.replace(/\t/g, "  ");
+    if (sanitized !== content) {
+      return {
+        config: import_js_yaml2.default.load(sanitized),
+        repairedParse: true,
+        messages: ["\u68C0\u6D4B\u5230 YAML \u4F7F\u7528\u4E86 Tab \u7F29\u8FDB\uFF0Cdoctor \u5DF2\u81EA\u52A8\u4FEE\u590D\u4E3A\u7A7A\u683C\u7F29\u8FDB\u3002"]
+      };
+    }
+    throw error;
+  }
+}
+function loadCurrentConfig() {
+  const existingPath = getConfigCandidates().find((filePath) => (0, import_fs7.existsSync)(filePath));
+  const path = existingPath ?? CONFIG_FILE;
+  if (!existingPath) {
+    return {
+      path,
+      existed: false,
+      repairedParse: false,
+      messages: ["\u672A\u68C0\u6D4B\u5230\u5F53\u524D Claude Trigger Router \u914D\u7F6E\u3002"]
+    };
+  }
+  const content = (0, import_fs7.readFileSync)(existingPath, "utf-8");
+  const loaded = tryLoadStructuredConfig(existingPath, content);
+  return {
+    path,
+    existed: true,
+    repairedParse: loaded.repairedParse,
+    messages: loaded.messages,
+    config: loaded.config
+  };
+}
+function getModelLookupId(model) {
+  return model.id?.trim() || sanitizeModelId(model.model ?? "");
+}
+function repairDeterministicConfig(config) {
+  const nextConfig = {
+    ...config,
+    HOST: config.HOST ?? DEFAULT_CONFIG2.HOST,
+    PORT: config.PORT ?? DEFAULT_CONFIG2.PORT,
+    LOG: config.LOG ?? DEFAULT_CONFIG2.LOG,
+    LOG_LEVEL: config.LOG_LEVEL ?? DEFAULT_CONFIG2.LOG_LEVEL
+  };
+  const changes = [];
+  if (Array.isArray(config.Models) && config.Models.length > 0) {
+    nextConfig.Models = config.Models.map((item, index) => {
+      const api = getModelApi(item);
+      const key = getModelKey(item);
+      const inferredInterface = getModelInterface(item) ?? inferInterfaceFromApi(api);
+      const id = item.id?.trim() || (item.model ? sanitizeModelId(item.model) : `model_${index + 1}`);
+      if (!item.id?.trim()) {
+        changes.push(`\u5DF2\u8865\u5168 Models[${index}].id -> ${id}`);
+      }
+      if (inferredInterface && !getModelInterface(item)) {
+        changes.push(`\u5DF2\u8865\u5168 Models[${index}].interface -> ${inferredInterface}`);
+      }
+      if (api && item.api !== api) {
+        changes.push(`\u5DF2\u5F52\u4E00 Models[${index}].api`);
+      }
+      if (key && item.key !== key) {
+        changes.push(`\u5DF2\u5F52\u4E00 Models[${index}].key`);
+      }
+      return {
+        ...item,
+        id,
+        api: api || void 0,
+        api_base_url: api || void 0,
+        key: key || void 0,
+        api_key: key || void 0,
+        interface: inferredInterface,
+        protocol: inferredInterface
+      };
+    });
+    if (!nextConfig.Router?.default) {
+      if (nextConfig.Models.length === 1) {
+        nextConfig.Router = {
+          ...nextConfig.Router ?? {},
+          default: getModelLookupId(nextConfig.Models[0])
+        };
+        changes.push(`\u5DF2\u8865\u5168 Router.default -> ${nextConfig.Router.default}`);
+      } else if (typeof config.Router?.default === "string" && config.Router.default.includes(",")) {
+        const [providerName, modelName] = config.Router.default.split(",").map((item) => item.trim());
+        const matched = nextConfig.Models.find(
+          (item) => item.model === modelName && (item.id === providerName || item.id.startsWith(`${sanitizeModelId(providerName)}_`))
+        );
+        if (matched) {
+          nextConfig.Router = {
+            ...nextConfig.Router ?? {},
+            default: matched.id
+          };
+          changes.push(`\u5DF2\u5F52\u4E00 Router.default -> ${matched.id}`);
+        }
+      }
+    }
+  } else if (Array.isArray(config.Providers) && config.Providers.length > 0) {
+    const migrated = migrateLegacyConfig(config);
+    nextConfig.Models = migrated.draft.Models;
+    nextConfig.Router = {
+      ...nextConfig.Router ?? {},
+      ...migrated.draft.Router
+    };
+    nextConfig.Providers = [];
+    changes.push("\u5DF2\u5C06 legacy Providers \u7ED3\u6784\u5F52\u4E00\u4E3A Models \u7ED3\u6784\u3002");
+  }
+  return { config: nextConfig, changes };
+}
+async function completeMissingModelFields(config, io) {
+  const changes = [];
+  const nextConfig = {
+    ...config,
+    Models: Array.isArray(config.Models) ? config.Models.map((item) => ({ ...item })) : [],
+    Router: { ...config.Router ?? {} }
+  };
+  for (let index = 0; index < (nextConfig.Models?.length ?? 0); index += 1) {
+    const model = nextConfig.Models[index];
+    const label = model.id || model.model || `Models[${index}]`;
+    if (!model.id?.trim()) {
+      model.id = sanitizeModelId(await io.input(`\u8865\u5168 ${label} \u7684\u6A21\u578B ID`, sanitizeModelId(model.model || `model_${index + 1}`)));
+      changes.push(`\u5DF2\u8865\u5168 ${label} \u7684\u6A21\u578B ID -> ${model.id}`);
+    }
+    if (!getModelApi(model)) {
+      const api = await io.input(`\u8865\u5168 ${label} \u7684 API Base URL`);
+      model.api = api;
+      model.api_base_url = api;
+      changes.push(`\u5DF2\u8865\u5168 ${label} \u7684 API Base URL`);
+    }
+    if (!getModelKey(model)) {
+      const key = await io.input(`\u8865\u5168 ${label} \u7684 API Key`);
+      model.key = key;
+      model.api_key = key;
+      changes.push(`\u5DF2\u8865\u5168 ${label} \u7684 API Key`);
+    }
+    if (!getModelInterface(model)) {
+      const interfaceChoice = await io.choose(`\u8865\u5168 ${label} \u7684\u63A5\u53E3\u7C7B\u578B`, ["openai", "anthropic"]);
+      model.interface = interfaceChoice;
+      model.protocol = model.interface;
+      changes.push(`\u5DF2\u8865\u5168 ${label} \u7684\u63A5\u53E3\u7C7B\u578B -> ${model.interface}`);
+    }
+    if (!model.model?.trim()) {
+      model.model = await io.input(`\u8865\u5168 ${label} \u7684\u4E0A\u6E38\u6A21\u578B\u540D`);
+      changes.push(`\u5DF2\u8865\u5168 ${label} \u7684\u4E0A\u6E38\u6A21\u578B\u540D`);
+    }
+  }
+  if (!nextConfig.Router?.default) {
+    if ((nextConfig.Models?.length ?? 0) === 1) {
+      nextConfig.Router.default = nextConfig.Models[0].id;
+      changes.push(`\u5DF2\u8865\u5168 Router.default -> ${nextConfig.Router.default}`);
+    } else if ((nextConfig.Models?.length ?? 0) > 1) {
+      const choice = await io.choose("\u8865\u5168\u9ED8\u8BA4\u6A21\u578B", nextConfig.Models.map((item) => item.id));
+      nextConfig.Router.default = choice;
+      changes.push(`\u5DF2\u8865\u5168 Router.default -> ${choice}`);
+    }
+  }
+  return { config: nextConfig, changes };
+}
+async function probeModelAvailability(model) {
+  const api = getModelApi(model);
+  const key = getModelKey(model);
+  const modelInterface = getModelInterface(model);
+  if (!api || !key || !modelInterface || !model.model) {
+    return {
+      kind: "failure",
+      category: "protocol_mismatch",
+      message: "\u6A21\u578B\u914D\u7F6E\u7F3A\u5C11 api/key/interface/model\uFF0C\u65E0\u6CD5\u53D1\u8D77\u63A2\u6D4B\u3002"
+    };
+  }
+  try {
+    const registry = buildModelRegistry({
+      Providers: [],
+      Models: [model],
+      Router: {
+        default: model.id
+      }
+    });
+    const compiledModel = registry.modelMap[model.id];
+    const dispatchRequest = compiledModel ? buildProviderDispatchRequest({
+      model: compiledModel.modelName,
+      interface: compiledModel.interface ?? modelInterface,
+      compatibilityProfile: compiledModel.compatibilityProfile,
+      capabilities: compiledModel.capabilities,
+      request: {
+        model: compiledModel.id,
+        max_tokens: 1,
+        stream: true,
+        messages: [
+          {
+            role: "user",
+            content: [
+              {
+                type: "text",
+                text: "ok"
+              }
+            ]
+          }
+        ]
+      }
+    }) : null;
+    const response = await fetch(api, {
+      method: "POST",
+      signal: AbortSignal.timeout(1e4),
+      headers: modelInterface === "anthropic" ? {
+        "content-type": "application/json",
+        "x-api-key": key,
+        "anthropic-version": "2023-06-01"
+      } : {
+        "content-type": "application/json",
+        authorization: `Bearer ${key}`
+      },
+      body: JSON.stringify(dispatchRequest?.body ?? (modelInterface === "anthropic" ? {
+        model: model.model,
+        max_tokens: 1,
+        stream: true,
+        messages: [
+          {
+            role: "user",
+            content: [
+              {
+                type: "text",
+                text: "ok"
+              }
+            ]
+          }
+        ]
+      } : {
+        model: model.model,
+        max_tokens: 1,
+        stream: true,
+        messages: [
+          {
+            role: "user",
+            content: "ok"
+          }
+        ]
+      }))
+    });
+    if (response.ok) {
+      return { kind: "success" };
+    }
+    const body = await response.text();
+    if (response.status === 401 || response.status === 403) {
+      return { kind: "failure", category: "auth_error", message: `${response.status} ${body}` };
+    }
+    if (response.status === 404) {
+      return { kind: "failure", category: "model_not_found", message: `${response.status} ${body}` };
+    }
+    if (response.status === 400) {
+      return { kind: "failure", category: "protocol_mismatch", message: `${response.status} ${body}` };
+    }
+    return { kind: "failure", category: "remote_error", message: `${response.status} ${body}` };
+  } catch (error) {
+    return {
+      kind: "failure",
+      category: "endpoint_unreachable",
+      message: error?.message || String(error)
+    };
+  }
+}
+async function ensureServiceUsable(config, deps, configChanged) {
+  const port = config.PORT ?? DEFAULT_CONFIG2.PORT;
+  const healthy = await deps.probeServiceHealth(port, 500);
+  const occupied = await deps.isTcpPortOccupied(port, 500);
+  const running = deps.isServiceRunning();
+  if (healthy && !configChanged) {
+    deps.io.info(`\u670D\u52A1\u5065\u5EB7\u68C0\u67E5\u901A\u8FC7\uFF1Ahttp://127.0.0.1:${port}`);
+    return;
+  }
+  if (occupied && !healthy && !running) {
+    throw new Error(`\u7AEF\u53E3 ${port} \u5DF2\u88AB\u5176\u4ED6\u670D\u52A1\u5360\u7528\uFF0Cdoctor \u65E0\u6CD5\u81EA\u52A8\u542F\u52A8\u5F53\u524D\u670D\u52A1\u3002`);
+  }
+  if (running) {
+    const info = deps.readServiceInfo();
+    if (info) {
+      try {
+        deps.killProcess(info.pid);
+      } catch {
+      }
+    }
+  }
+  await deps.startDaemon();
+  const verified = await deps.waitForService(port, 5e3);
+  if (!verified) {
+    throw new Error(`doctor \u81EA\u52A8\u542F\u52A8\u540E\u5065\u5EB7\u68C0\u67E5\u4ECD\u672A\u901A\u8FC7\uFF08\u7AEF\u53E3 ${port}\uFF09\u3002`);
+  }
+  deps.io.info(`\u670D\u52A1\u5DF2\u5C31\u7EEA\uFF1Ahttp://127.0.0.1:${port}`);
+}
+function createDefaultDeps2(io = createConsoleIO2()) {
+  return {
+    readLegacyConfig,
+    backupCurrentConfig: backupConfigFile,
+    writeConfig: writeConfigFile,
+    isServiceRunning,
+    readServiceInfo,
+    killProcess,
+    probeServiceHealth,
+    isTcpPortOccupied,
+    waitForService,
+    io,
+    startDaemon: async () => {
+      (0, import_child_process2.spawn)(process.execPath, [process.argv[1], "start", "--daemon"], {
+        detached: true,
+        stdio: "ignore",
+        env: { ...process.env, CTR_DAEMON: "1" }
+      }).unref();
+    }
+  };
+}
+async function runDoctorCli(customDeps) {
+  const defaults = createDefaultDeps2(customDeps?.io);
+  const deps = { ...defaults, ...customDeps };
+  let configChanged = false;
+  try {
+    deps.io.info("\u5F00\u59CB\u8BCA\u65AD\u5F53\u524D Claude Trigger Router \u914D\u7F6E...");
+    const current = loadCurrentConfig();
+    current.messages.forEach((message) => deps.io.info(message));
+    let workingConfig = current.config;
+    if (!workingConfig) {
+      const legacy = await deps.readLegacyConfig();
+      if (legacy.kind === "found") {
+        deps.io.info("\u672A\u68C0\u6D4B\u5230\u5F53\u524D\u914D\u7F6E\uFF0C\u4F46\u53D1\u73B0\u65E7 claude-code-router \u914D\u7F6E\uFF0Cdoctor \u5C06\u5148\u5C1D\u8BD5\u8FC1\u79FB\u3002");
+        const migrated = migrateLegacyConfig(legacy.config);
+        workingConfig = {
+          ...buildUsableMinimalTemplateConfig(),
+          ...migrated.draft
+        };
+      } else {
+        throw new Error("\u672A\u68C0\u6D4B\u5230\u53EF\u8BCA\u65AD\u7684\u5F53\u524D\u914D\u7F6E\uFF1B\u8BF7\u5148\u8FD0\u884C ctr setup \u6216 ctr init --force\u3002");
+      }
+    }
+    const deterministic = repairDeterministicConfig(workingConfig);
+    workingConfig = deterministic.config;
+    deterministic.changes.forEach((message) => deps.io.info(message));
+    const completed = await completeMissingModelFields(workingConfig, deps.io);
+    workingConfig = completed.config;
+    completed.changes.forEach((message) => deps.io.info(message));
+    const normalized = normalizeAndValidateConfig(workingConfig);
+    if (normalized.errors.length > 0) {
+      deps.io.error(`doctor \u4ECD\u53D1\u73B0\u65E0\u6CD5\u81EA\u52A8\u4FEE\u590D\u7684\u914D\u7F6E\u9519\u8BEF\uFF1A${normalized.errors.join("; ")}`);
+      throw new Error("doctor could not fully repair config");
+    }
+    if (normalized.warnings.length > 0) {
+      deps.io.info(`\u914D\u7F6E\u63D0\u793A\uFF1A${normalized.warnings.join("; ")}`);
+    }
+    const needWrite = current.repairedParse || deterministic.changes.length > 0 || completed.changes.length > 0 || !current.existed;
+    if (needWrite) {
+      if (current.existed) {
+        const backupPath = await deps.backupCurrentConfig();
+        if (backupPath) {
+          deps.io.info(`\u5DF2\u5907\u4EFD\u5F53\u524D\u914D\u7F6E\uFF1A${backupPath}`);
+        }
+      }
+      await deps.writeConfig(normalized.config);
+      deps.io.info(`\u5DF2\u5199\u56DE\u4FEE\u590D\u540E\u7684\u914D\u7F6E\uFF1A${current.path}`);
+      configChanged = true;
+    }
+    await ensureServiceUsable(normalized.config, deps, configChanged);
+    const shouldProbeModels = hasArg("--check-models") ? await deps.io.confirm(`\u5373\u5C06\u5411 ${normalized.config.Models?.length ?? 0} \u4E2A\u6A21\u578B\u53D1\u9001\u6700\u5C0F\u63A2\u6D4B\u8BF7\u6C42\uFF0C\u53EF\u80FD\u6D88\u8017\u5C11\u91CF\u989D\u5EA6\uFF0C\u662F\u5426\u7EE7\u7EED\uFF1F`, true) : await deps.io.confirm(`\u662F\u5426\u7EE7\u7EED\u63A2\u6D4B ${normalized.config.Models?.length ?? 0} \u4E2A\u6A21\u578B\u7684\u53EF\u7528\u6027\uFF1F\u8FD9\u4F1A\u6D88\u8017\u5C11\u91CF\u989D\u5EA6\u3002`, false);
+    if (!shouldProbeModels) {
+      deps.io.info("\u5DF2\u8DF3\u8FC7\u6A21\u578B\u63A2\u6D4B\u3002\u914D\u7F6E\u548C\u670D\u52A1\u8BCA\u65AD\u5DF2\u5B8C\u6210\u3002");
+      return;
+    }
+    for (const model of normalized.config.Models ?? []) {
+      const result = await probeModelAvailability(model);
+      if (result.kind === "success") {
+        deps.io.info(`\u6A21\u578B\u63A2\u6D4B\u6210\u529F\uFF1A${model.id}`);
+        continue;
+      }
+      deps.io.error(`\u6A21\u578B\u63A2\u6D4B\u5931\u8D25\uFF1A${model.id} -> ${result.category} -> ${result.message}`);
+      deps.io.info("\u8FD9\u7C7B\u8FDC\u7AEF\u5931\u8D25\u9700\u8981\u4F60\u786E\u8BA4\u5E76\u624B\u52A8\u5904\u7406\uFF1Bdoctor \u4E0D\u4F1A\u81EA\u52A8\u4FEE\u6539\u6A21\u578B\u8BED\u4E49\u6216\u8FDC\u7AEF\u8D26\u53F7\u914D\u7F6E\u3002");
+    }
+    deps.io.info("doctor \u8BCA\u65AD\u5B8C\u6210\u3002");
+  } finally {
+    deps.io.close?.();
+  }
+}
+var import_fs7, import_promises4, import_process2, import_child_process2, import_json53, import_js_yaml2;
+var init_doctor = __esm({
+  "src/doctor/index.ts"() {
+    "use strict";
+    import_fs7 = require("fs");
+    import_promises4 = require("readline/promises");
+    import_process2 = require("process");
+    import_child_process2 = require("child_process");
+    import_json53 = __toESM(require("json5"));
+    import_js_yaml2 = __toESM(require("js-yaml"));
+    init_constants();
+    init_utils();
+    init_migrate();
+    init_setup2();
+    init_schema();
+    init_compile();
+    init_protocols();
+    init_processCheck();
+    init_service_health();
+    init_templates();
+  }
+});
+
 // src/cli.ts
 var cli_exports = {};
 __export(cli_exports, {
@@ -6522,7 +7534,7 @@ __export(cli_exports, {
 });
 module.exports = __toCommonJS(cli_exports);
 function getPackageInfo() {
-  const content = (0, import_fs7.readFileSync)(PACKAGE_JSON_PATH, "utf-8");
+  const content = (0, import_fs8.readFileSync)(PACKAGE_JSON_PATH, "utf-8");
   const pkg = JSON.parse(content);
   return {
     name: pkg.name ?? "@peterwangze/claude-trigger-router",
@@ -6535,7 +7547,7 @@ function getArgs() {
 function getCommand() {
   return getArgs()[0];
 }
-function hasArg(flag, shortFlag) {
+function hasArg2(flag, shortFlag) {
   const args = getArgs();
   return args.includes(flag) || (shortFlag ? args.includes(shortFlag) : false);
 }
@@ -6544,23 +7556,34 @@ function getArgValue(flag, shortFlag) {
   const index = args.indexOf(flag) !== -1 ? args.indexOf(flag) : shortFlag ? args.indexOf(shortFlag) : -1;
   return index !== -1 ? args[index + 1] : void 0;
 }
+function parsePortValue(portValue, sourceLabel) {
+  const trimmed = portValue.trim();
+  if (!/^\d+$/.test(trimmed)) {
+    throw new Error(`${sourceLabel} \u4E0D\u662F\u5408\u6CD5\u7AEF\u53E3\uFF1A${portValue}`);
+  }
+  const port = Number.parseInt(trimmed, 10);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`${sourceLabel} \u8D85\u51FA\u5408\u6CD5\u8303\u56F4\uFF081-65535\uFF09\uFF1A${portValue}`);
+  }
+  return port;
+}
 function getPort() {
   const portValue = getArgValue("--port", "-p");
   if (portValue) {
-    return parseInt(portValue, 10);
+    return parsePortValue(portValue, "\u547D\u4EE4\u884C\u7AEF\u53E3\u53C2\u6570");
   }
   try {
-    const yaml3 = require("js-yaml");
-    if ((0, import_fs7.existsSync)(CONFIG_FILE)) {
-      const content = (0, import_fs7.readFileSync)(CONFIG_FILE, "utf-8");
-      const config = yaml3.load(content);
+    const yaml4 = require("js-yaml");
+    if ((0, import_fs8.existsSync)(CONFIG_FILE)) {
+      const content = (0, import_fs8.readFileSync)(CONFIG_FILE, "utf-8");
+      const config = yaml4.load(content);
       if (config?.PORT) return config.PORT;
-    } else if ((0, import_fs7.existsSync)(CONFIG_FILE_YML)) {
-      const content = (0, import_fs7.readFileSync)(CONFIG_FILE_YML, "utf-8");
-      const config = yaml3.load(content);
+    } else if ((0, import_fs8.existsSync)(CONFIG_FILE_YML)) {
+      const content = (0, import_fs8.readFileSync)(CONFIG_FILE_YML, "utf-8");
+      const config = yaml4.load(content);
       if (config?.PORT) return config.PORT;
-    } else if ((0, import_fs7.existsSync)(CONFIG_FILE_JSON)) {
-      const content = (0, import_fs7.readFileSync)(CONFIG_FILE_JSON, "utf-8");
+    } else if ((0, import_fs8.existsSync)(CONFIG_FILE_JSON)) {
+      const content = (0, import_fs8.readFileSync)(CONFIG_FILE_JSON, "utf-8");
       const config = JSON.parse(content);
       if (config?.PORT) return config.PORT;
     }
@@ -6569,7 +7592,7 @@ function getPort() {
   return DEFAULT_CONFIG2.PORT;
 }
 function isDaemonMode() {
-  return hasArg("--daemon", "-d");
+  return hasArg2("--daemon", "-d");
 }
 function printHelp() {
   console.log(`
@@ -6579,6 +7602,7 @@ Claude Trigger Router - \u667A\u80FD\u89E6\u53D1\u8DEF\u7531\u5668
 
 \u547D\u4EE4\uFF1A
   setup       \u68C0\u6D4B\u5E76\u590D\u7528\u5DF2\u6709\u914D\u7F6E\uFF0C\u5FC5\u8981\u65F6\u8FC1\u79FB\u65E7\u914D\u7F6E\u6216\u65B0\u5EFA\u6700\u5C0F\u914D\u7F6E
+  doctor      \u8BCA\u65AD\u5E76\u4FEE\u590D\u5F53\u524D\u914D\u7F6E\uFF0C\u6309\u9700\u63A2\u6D4B\u6A21\u578B\u53EF\u7528\u6027
   init        \u521D\u59CB\u5316\u6700\u5C0F\u914D\u7F6E\u6A21\u677F
   start       \u542F\u52A8\u8DEF\u7531\u670D\u52A1\uFF08\u9ED8\u8BA4\u524D\u53F0\u8FD0\u884C\uFF09
   stop        \u505C\u6B62\u540E\u53F0\u670D\u52A1
@@ -6587,7 +7611,7 @@ Claude Trigger Router - \u667A\u80FD\u89E6\u53D1\u8DEF\u7531\u5668
   version     \u67E5\u770B\u5F53\u524D\u5B89\u88C5\u7248\u672C\u4E0E\u5305\u4FE1\u606F
   upgrade     \u67E5\u770B\u5347\u7EA7\u5230\u6700\u65B0 npm \u7248\u672C\u7684\u6307\u5F15
   code        \u901A\u8FC7\u8DEF\u7531\u5668\u8FD0\u884C Claude Code\uFF08\u9700\u5148\u542F\u52A8\u670D\u52A1\uFF09
-  ui          \u6253\u5F00\u7BA1\u7406 API \u8BF4\u660E\u9875\uFF08Web UI \u5F00\u53D1\u4E2D\uFF09
+  ui          \u6253\u5F00\u672C\u5730\u7BA1\u7406\u9875\uFF08\u914D\u7F6E\u9884\u89C8\u4E0E\u8C03\u8BD5\uFF09
   help        \u663E\u793A\u6B64\u5E2E\u52A9\u4FE1\u606F
 
 \u9009\u9879\uFF1A
@@ -6597,6 +7621,7 @@ Claude Trigger Router - \u667A\u80FD\u89E6\u53D1\u8DEF\u7531\u5668
 
 \u4F7F\u7528\u793A\u4F8B\uFF1A
   ctr setup                # \u590D\u7528\u5F53\u524D\u914D\u7F6E / \u8FC1\u79FB\u65E7\u914D\u7F6E / \u65B0\u5EFA\u6700\u5C0F\u914D\u7F6E
+  ctr doctor               # \u8BCA\u65AD\u914D\u7F6E / \u4FEE\u590D\u683C\u5F0F\u95EE\u9898 / \u6309\u9700\u63A2\u6D4B\u6A21\u578B\u53EF\u7528\u6027
   ctr init                 # \u521D\u59CB\u5316\u6700\u5C0F\u914D\u7F6E\u6A21\u677F
   ctr version              # \u67E5\u770B\u5F53\u524D\u5B89\u88C5\u7248\u672C
   ctr upgrade              # \u67E5\u770B\u5347\u7EA7\u5230\u6700\u65B0\u7248\u672C\u7684\u547D\u4EE4
@@ -6604,6 +7629,7 @@ Claude Trigger Router - \u667A\u80FD\u89E6\u53D1\u8DEF\u7531\u5668
   ctr start --daemon       # \u540E\u53F0\u542F\u52A8
   ctr status               # \u67E5\u770B\u670D\u52A1\u72B6\u6001
   ctr code                 # \u542F\u52A8 Claude Code\uFF08\u9700\u5148\u8FD0\u884C ctr start\uFF09
+  ctr ui                   # \u6253\u5F00\u672C\u5730\u7BA1\u7406\u9875\uFF08\u53EF\u9009\uFF09
   ctr stop                 # \u505C\u6B62\u540E\u53F0\u670D\u52A1
   ctr restart --daemon     # \u91CD\u542F\u540E\u53F0\u670D\u52A1
 
@@ -6613,10 +7639,29 @@ Claude Trigger Router - \u667A\u80FD\u89E6\u53D1\u8DEF\u7531\u5668
 
 \u914D\u7F6E\u76EE\u5F55\uFF1A${CONFIG_DIR}
 
+\u8865\u5145\u8BF4\u660E\uFF1A
+  ctr restart \u5F53\u524D\u9ED8\u8BA4\u6309\u540E\u53F0\u6A21\u5F0F\u91CD\u542F\uFF1B\u53EF\u5199 ctr restart \u6216 ctr restart --daemon
+
 \u66F4\u591A\u4FE1\u606F\uFF1Ahttps://github.com/peterwangze/claude-trigger-router
 `);
 }
-async function getLatestPackageVersion(timeoutMs = 1500) {
+function getLatestPackageVersionViaNpm(packageName, timeoutMs = 5e3) {
+  try {
+    const result = (0, import_child_process3.spawnSync)("npm", ["view", packageName, "version", "--registry", PACKAGE_REGISTRY_URL], {
+      encoding: "utf-8",
+      timeout: timeoutMs,
+      shell: process.platform === "win32"
+    });
+    if (result.status !== 0) {
+      return null;
+    }
+    const value = result.stdout?.trim();
+    return value ? value : null;
+  } catch {
+    return null;
+  }
+}
+async function getLatestPackageVersion(packageName, timeoutMs = 4e3) {
   try {
     const response = await fetch(PACKAGE_REGISTRY_LATEST_URL, {
       signal: AbortSignal.timeout(timeoutMs)
@@ -6625,10 +7670,12 @@ async function getLatestPackageVersion(timeoutMs = 1500) {
       return null;
     }
     const payload = await response.json();
-    return typeof payload.version === "string" ? payload.version : null;
+    if (typeof payload.version === "string") {
+      return payload.version;
+    }
   } catch {
-    return null;
   }
+  return getLatestPackageVersionViaNpm(packageName);
 }
 function isNewerVersion(current, latest) {
   const currentParts = current.split(".").map((part) => Number.parseInt(part, 10));
@@ -6648,7 +7695,7 @@ function isNewerVersion(current, latest) {
 }
 async function printVersion() {
   const pkg = getPackageInfo();
-  const latestVersion = await getLatestPackageVersion();
+  const latestVersion = await getLatestPackageVersion(pkg.name);
   console.log(`Package: ${pkg.name}`);
   console.log(`Version: ${pkg.version}`);
   console.log(`Latest: ${latestVersion ?? "unavailable"}`);
@@ -6668,30 +7715,42 @@ function printUpgradeGuidance() {
   console.log("\u5168\u5C40\u5B89\u88C5\u5728\u67D0\u4E9B\u73AF\u5883\u4E0B\u53EF\u80FD\u9700\u8981\u7BA1\u7406\u5458/root \u6743\u9650\u3002");
   console.log(`NPM: ${PACKAGE_PAGE_URL}`);
 }
+function printRestartGuidanceHint() {
+  console.log("\u8BF4\u660E\uFF1A`ctr restart` \u5F53\u524D\u9ED8\u8BA4\u6309\u540E\u53F0\u6A21\u5F0F\u91CD\u542F\u670D\u52A1\uFF0C`--daemon` \u53EA\u662F\u663E\u5F0F\u5199\u6CD5\u3002");
+}
+function isClaudeCommandAvailable(timeoutMs = 3e3) {
+  try {
+    const result = (0, import_child_process3.spawnSync)("claude", ["--version"], {
+      encoding: "utf-8",
+      timeout: timeoutMs,
+      stdio: "ignore",
+      shell: process.platform === "win32"
+    });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
 function initConfig2() {
-  const force = hasArg("--force");
-  const existingConfig = [CONFIG_FILE, CONFIG_FILE_YML, CONFIG_FILE_JSON].find(import_fs7.existsSync);
+  const force = hasArg2("--force");
+  const existingConfig = [CONFIG_FILE, CONFIG_FILE_YML, CONFIG_FILE_JSON].find(import_fs8.existsSync);
   if (existingConfig && !force) {
     console.log(`\u26A0\uFE0F  \u914D\u7F6E\u6587\u4EF6\u5DF2\u5B58\u5728\uFF1A${existingConfig}`);
     console.log("    \u5982\u9700\u8986\u76D6\uFF0C\u8BF7\u4F7F\u7528 --force \u53C2\u6570\u3002");
     return;
   }
-  if (!(0, import_fs7.existsSync)(CONFIG_DIR)) {
-    (0, import_fs7.mkdirSync)(CONFIG_DIR, { recursive: true });
-  }
-  const examplePaths = [
-    (0, import_path7.join)(__dirname, "..", "config", "trigger.example.yaml"),
-    (0, import_path7.join)((0, import_path7.dirname)(process.argv[1]), "..", "config", "trigger.example.yaml")
-  ];
-  const exampleFile = examplePaths.find((p) => (0, import_fs7.existsSync)(p));
-  if (!exampleFile) {
-    console.error("\u274C \u627E\u4E0D\u5230\u793A\u4F8B\u914D\u7F6E\u6587\u4EF6\u3002");
-    console.log(`   \u8BF7\u624B\u52A8\u521B\u5EFA ${CONFIG_FILE}`);
-    console.log("   \u53C2\u8003\u6587\u6863\uFF1Ahttps://github.com/peterwangze/claude-trigger-router#configuration");
-    process.exit(1);
+  if (!(0, import_fs8.existsSync)(CONFIG_DIR)) {
+    (0, import_fs8.mkdirSync)(CONFIG_DIR, { recursive: true });
   }
   try {
-    (0, import_fs7.copyFileSync)(exampleFile, CONFIG_FILE);
+    const yaml4 = require("js-yaml");
+    const templateConfig = buildUsableMinimalTemplateConfig();
+    const content = yaml4.dump(templateConfig, {
+      indent: 2,
+      lineWidth: -1,
+      noRefs: true
+    });
+    (0, import_fs8.writeFileSync)(CONFIG_FILE, content, "utf-8");
     const action = force ? "\u5DF2\u8986\u76D6" : "\u5DF2\u521B\u5EFA";
     console.log(`\u2705 \u914D\u7F6E\u6587\u4EF6${action}\uFF1A${CONFIG_FILE}`);
     console.log("");
@@ -6707,10 +7766,22 @@ function initConfig2() {
   }
 }
 async function startForeground(port) {
+  const targetPort = port ?? getPort();
+  const healthy = await waitForService(targetPort, 500);
+  const occupied = await isTcpPortOccupied(targetPort, 500);
+  if (healthy && occupied && isServiceRunning()) {
+    console.log(`\u2705 Service is already running on port ${targetPort}.`);
+    console.log("   Use 'ctr status' to inspect it or 'ctr stop' before starting again.");
+    return;
+  }
+  if (!healthy && occupied && !isServiceRunning()) {
+    console.error(`\u274C Port ${targetPort} is already occupied by another service.`);
+    process.exit(1);
+  }
   console.log("\u{1F680} Starting Claude Trigger Router (foreground)...");
   console.log("   Press Ctrl+C to stop");
   try {
-    await run({ port });
+    await run({ port: targetPort });
   } catch (error) {
     if (error.message?.includes("Invalid configuration")) {
       console.error("\n\u274C Configuration error. Run 'ctr init' to create a config file.");
@@ -6720,7 +7791,14 @@ async function startForeground(port) {
     process.exit(1);
   }
 }
-function startDaemon(port) {
+async function startDaemon(port) {
+  const targetPort = port ?? getPort();
+  const healthy = await waitForService(targetPort, 500);
+  const occupied = await isTcpPortOccupied(targetPort, 500);
+  if (!healthy && occupied && !isServiceRunning()) {
+    console.log(`\u274C Port ${targetPort} is already occupied by another service.`);
+    return;
+  }
   if (isServiceRunning()) {
     console.log("\u2705 Service is already running in the background.");
     return;
@@ -6731,30 +7809,58 @@ function startDaemon(port) {
   if (port) {
     childArgs.push("--port", String(port));
   }
-  const child = (0, import_child_process2.spawn)(nodeExec, childArgs, {
+  const child = (0, import_child_process3.spawn)(nodeExec, childArgs, {
     detached: true,
     stdio: "ignore",
     env: { ...process.env, CTR_DAEMON: "1" }
   });
   child.unref();
-  const targetPort = port ?? getPort();
-  let waited = 0;
-  const interval = setInterval(() => {
-    waited += 500;
-    if (isServiceRunning()) {
-      clearInterval(interval);
-      console.log(`\u2705 Service started in background (port: ${targetPort})`);
-      console.log(`   Run 'ctr stop' to stop it.`);
-    } else if (waited >= 5e3) {
-      clearInterval(interval);
-      console.log(`\u2705 Service launched in background (port: ${targetPort})`);
-      console.log(`   If it fails to start, run 'ctr start' (without --daemon) to see errors.`);
-    }
-  }, 500);
-}
-function showStatus() {
+  const startConfirmed = await new Promise((resolve, reject) => {
+    let settled = false;
+    const deadline = Date.now() + 5e3;
+    const finish = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      resolve(value);
+    };
+    child.once("error", reject);
+    child.once("exit", () => finish(false));
+    const poll = () => {
+      if (settled) {
+        return;
+      }
+      if (isServiceRunning()) {
+        finish(true);
+        return;
+      }
+      if (Date.now() >= deadline) {
+        finish(false);
+        return;
+      }
+      setTimeout(poll, 250);
+    };
+    poll();
+  });
+  if (!startConfirmed) {
+    console.error(`\u274C Service failed to start in background (port: ${targetPort}).`);
+    console.error("   Run 'ctr start' (without --daemon) to inspect the startup error.");
+    process.exit(1);
+  }
+  console.log(`\u2705 Service started in background (port: ${targetPort})`);
+  console.log(`   Run 'ctr stop' to stop it.`);
+}
+async function showStatus() {
   const info = readServiceInfo();
   if (!info || !isServiceRunning()) {
+    const targetPort = getPort();
+    const healthy = await waitForService(targetPort, 500);
+    const occupied = await isTcpPortOccupied(targetPort, 500);
+    if (!healthy && occupied) {
+      console.log(`\u26A0\uFE0F  \u7AEF\u53E3 ${targetPort} \u5DF2\u88AB\u5176\u4ED6\u670D\u52A1\u5360\u7528\uFF0C\u5F53\u524D\u4E0D\u662F claude-trigger-router\u3002`);
+      return;
+    }
     console.log("\u23F9  \u670D\u52A1\u672A\u8FD0\u884C");
     return;
   }
@@ -6779,9 +7885,10 @@ function stopService() {
     console.error("\u274C \u505C\u6B62\u670D\u52A1\u5931\u8D25:", error.message);
   }
 }
-function restartService() {
+async function restartService() {
   stopService();
-  setTimeout(() => startDaemon(getPort()), 1500);
+  await new Promise((resolve) => setTimeout(resolve, 1500));
+  await startDaemon(getPort());
 }
 async function runClaudeCode() {
   const port = getPort();
@@ -6796,14 +7903,16 @@ async function runClaudeCode() {
     console.log("  1. Start service first:  ctr start --daemon");
     console.log("  2. Or start interactively in another terminal:  ctr start");
     console.log("");
-    const proceed = process.env.CTR_AUTO_START === "1";
-    if (!proceed) {
-      process.exit(1);
-    }
+    process.exit(1);
   }
   console.log(`\u{1F680} Starting Claude Code with Trigger Router (port: ${port})...`);
+  if (!isClaudeCommandAvailable()) {
+    console.error("\u274C \u672A\u68C0\u6D4B\u5230 Claude Code CLI\u3002");
+    console.log("   \u8BF7\u5148\u5B89\u88C5\uFF1Anpm install -g @anthropic-ai/claude-code");
+    process.exit(1);
+  }
   const isWindows = process.platform === "win32";
-  const claude = (0, import_child_process2.spawn)("claude", [], {
+  const claude = (0, import_child_process3.spawn)("claude", [], {
     stdio: "inherit",
     shell: isWindows,
     env: {
@@ -6822,10 +7931,18 @@ async function runClaudeCode() {
     process.exit(code || 0);
   });
 }
-function openUI() {
+async function openUI() {
   const port = getPort();
   const url = `http://127.0.0.1:${port}/ui`;
+  const healthy = await waitForService(port, 800);
   console.log(`\u{1F310} Opening UI at ${url}`);
+  if (!healthy) {
+    console.log("\u26A0\uFE0F  \u5F53\u524D UI \u670D\u52A1\u672A\u5C31\u7EEA\uFF1B\u5982\u679C\u9875\u9762\u65E0\u6CD5\u6253\u5F00\uFF0C\u8BF7\u5148\u8FD0\u884C ctr start \u6216 ctr start --daemon\u3002");
+  }
+  if (process.env.CTR_UI_SKIP_OPEN === "1") {
+    console.log("   Browser launch skipped by CTR_UI_SKIP_OPEN=1");
+    return;
+  }
   try {
     (0, import_openurl.default)(url);
   } catch (error) {
@@ -6838,12 +7955,15 @@ async function main() {
     case "setup":
       await runSetupCli();
       break;
+    case "doctor":
+      await runDoctorCli();
+      break;
     case "init":
       initConfig2();
       break;
     case "start":
       if (isDaemonMode()) {
-        startDaemon(getPort());
+        await startDaemon(getPort());
       } else {
         await startForeground(getPort());
       }
@@ -6852,7 +7972,7 @@ async function main() {
       stopService();
       break;
     case "status":
-      showStatus();
+      await showStatus();
       break;
     case "version":
       await printVersion();
@@ -6861,13 +7981,14 @@ async function main() {
       printUpgradeGuidance();
       break;
     case "restart":
-      restartService();
+      printRestartGuidanceHint();
+      await restartService();
       break;
     case "code":
       await runClaudeCode();
       break;
     case "ui":
-      openUI();
+      await openUI();
       break;
     case "help":
     case "--help":
@@ -6882,21 +8003,24 @@ async function main() {
       process.exit(command ? 1 : 0);
   }
 }
-var import_child_process2, import_path7, import_openurl, import_fs7, PACKAGE_JSON_PATH, PACKAGE_PAGE_URL, PACKAGE_REGISTRY_LATEST_URL;
+var import_child_process3, import_path7, import_openurl, import_fs8, PACKAGE_JSON_PATH, PACKAGE_PAGE_URL, PACKAGE_REGISTRY_LATEST_URL, PACKAGE_REGISTRY_URL;
 var init_cli = __esm({
   "src/cli.ts"() {
-    import_child_process2 = require("child_process");
+    import_child_process3 = require("child_process");
     import_path7 = require("path");
     import_openurl = __toESM(require("openurl"));
-    import_fs7 = require("fs");
+    import_fs8 = require("fs");
     init_index();
     init_processCheck();
     init_constants();
     init_service_health();
     init_setup2();
+    init_templates();
+    init_doctor();
     PACKAGE_JSON_PATH = (0, import_path7.join)(__dirname, "..", "package.json");
     PACKAGE_PAGE_URL = "https://www.npmjs.com/package/@peterwangze/claude-trigger-router";
     PACKAGE_REGISTRY_LATEST_URL = "https://registry.npmjs.org/@peterwangze%2Fclaude-trigger-router/latest";
+    PACKAGE_REGISTRY_URL = "https://registry.npmjs.org/";
     if (process.env.CTR_SKIP_MAIN !== "1") {
       main().catch((error) => {
         console.error("Error:", error);