@linghun/tui 0.1.0

package/dist/chunk-3GCIXKCI.js

@@ -0,0 +1,221 @@
+import {
+  hasRepeatedPermissionDenial
+} from "./chunk-J7ZE2JKP.js";
+import {
+  createModelCapabilitySummary
+} from "./chunk-PGNALDEH.js";
+import {
+  formatDeferredToolsSystemReminder,
+  snapshotDeferredTools
+} from "./chunk-I3NTAIMF.js";
+import {
+  formatControlledMemoryForModel
+} from "./chunk-LQTVYUT3.js";
+import {
+  createSolutionCompletenessStatus,
+  projectRuntimeStatusForPrompt
+} from "./chunk-K56D3X7S.js";
+import {
+  truncateDisplay
+} from "./chunk-OMZYPQVA.js";
+
+// src/model-prompt-runtime.ts
+var MEMORY_PROMPT_TOP_K = 3;
+function createModelSystemPrompt(text, context, runtimeStatus, architectureDirective, worktreeContextSummary, failureLearningSummary, metaSchedulerDirective, gitStatusSummary) {
+  const solutionCompletenessWarning = updateSolutionCompletenessGate(text, context);
+  const deferredReminder = formatDeferredToolsSystemReminder(
+    context.language,
+    snapshotDeferredTools(context)
+  );
+  const worktreeContextLine = worktreeContextSummary && worktreeContextSummary.isWorktree === true ? `
+WorktreeContext=${JSON.stringify(worktreeContextSummary)}` : "";
+  const failureLearningLine = failureLearningSummary && failureLearningSummary.count > 0 ? `
+FailureLearningSummary=${failureLearningSummary.text}
+FailureLearningRule=These are lessons from PAST real failures in this project, surfaced as risk hints only. They do NOT mean the current task has failed, is fixed, or is verified. Use them to double-check risky steps; never cite them as evidence that something is already done/fixed/verified. Say "history shows / may be related", not present-tense facts.` : "";
+  const metaSchedulerLine = metaSchedulerDirective ? `
+${metaSchedulerDirective}` : "";
+  const gitStatusLine = gitStatusSummary ? `
+GitStatus=${gitStatusSummary}` : "";
+  let memorySummary;
+  if (context.lastMetaSchedulerDecision?.policyDecision.contextPlan?.includeMemory === false) {
+    memorySummary = "(memory skipped per scheduler policy)";
+  } else {
+    const _t0 = Date.now();
+    memorySummary = formatControlledMemoryForModel(context);
+    context.lastMetaSchedulerDecision?.internalEvents.push(`perf:memory_format_ms=${Date.now() - _t0}`);
+  }
+  return `${context.language === "en-US" ? "You are Linghun, an engineering AI coding assistant with tool-use capabilities. Answer in English by default unless the user explicitly requests another language. Use evidence before code claims; avoid unverified claims. Natural command execution is decided by local RuntimeStatus and Command Capability Catalog, not by guessing. Use real tool_use events when file/search/edit/bash/todo facts or actions are needed; never describe a tool call as text instead of using a tool event." : "\u4F60\u662F Linghun \u5DE5\u7A0B\u578B AI \u7F16\u7A0B\u52A9\u624B\uFF0C\u5177\u5907\u5DE5\u5177\u8C03\u7528\u80FD\u529B\u3002\u9ED8\u8BA4\u7528\u4E2D\u6587\u56DE\u7B54\uFF0C\u9664\u975E\u7528\u6237\u660E\u786E\u6307\u5B9A\u5176\u4ED6\u8BED\u8A00\u3002\u6D89\u53CA\u4EE3\u7801\u4E8B\u5B9E\u5FC5\u987B\u5148\u6709\u8BC1\u636E\uFF0C\u907F\u514D\u672A\u9A8C\u8BC1\u65AD\u8A00\u3002\u81EA\u7136\u8BED\u8A00\u547D\u4EE4\u662F\u5426\u53EF\u6267\u884C\u7531\u672C\u5730 RuntimeStatus \u4E0E Command Capability Catalog \u88C1\u51B3\uFF0C\u4E0D\u80FD\u9760\u6A21\u578B\u731C\u3002\u9700\u8981\u6587\u4EF6\u3001\u641C\u7D22\u3001\u7F16\u8F91\u3001Bash \u6216 Todo \u4E8B\u5B9E/\u52A8\u4F5C\u65F6\u5FC5\u987B\u4F7F\u7528\u771F\u5B9E tool_use \u4E8B\u4EF6\uFF0C\u4E0D\u8981\u7528\u6587\u672C\u5192\u5145\u5DE5\u5177\u8C03\u7528\u3002"}
+${context.language === "en-US" ? "OutputStyle=summary-first; use plain language on main screen, minimize internal jargon; error messages should suggest next steps; details/debug reserved for advanced info. In long or multi-tool tasks, use 1-2 natural lines at key points to say what you are inspecting, what you found, and what comes next; do not output raw tool protocol. For simple no-tool chat, stay concise. Default mature engineering for frontend/UI: clear information architecture, responsive layout, complete states (empty/error/loading), readability first." : "OutputStyle=summary-first; \u4E3B\u5C4F\u7528\u4EBA\u8BDD\u3001\u5C11\u5185\u90E8\u672F\u8BED\uFF1B\u9519\u8BEF\u63D0\u793A\u7ED9\u4E0B\u4E00\u6B65\uFF1Bdetails/debug \u4FDD\u7559\u9AD8\u7EA7\u4FE1\u606F\u3002\u957F\u4EFB\u52A1\u6216\u591A\u5DE5\u5177\u4EFB\u52A1\u4E2D\uFF0C\u5173\u952E\u8282\u70B9\u7528 1-2 \u884C\u81EA\u7136\u8BF4\u660E\u5F53\u524D\u67E5\u770B\u5BF9\u8C61\u3001\u521D\u6B65\u53D1\u73B0\u548C\u4E0B\u4E00\u6B65\uFF1B\u4E0D\u8981\u8F93\u51FA raw tool protocol\u3002\u7B80\u5355\u65E0\u5DE5\u5177\u95F2\u804A\u4FDD\u6301\u7B80\u6D01\u3002\u6D89\u53CA\u524D\u7AEF/UI \u5F00\u53D1\u65F6\u9ED8\u8BA4\u8981\u6C42\u6210\u719F\u65B9\u6848\uFF1A\u4FE1\u606F\u67B6\u6784\u6E05\u6670\u3001\u54CD\u5E94\u5F0F\u3001\u72B6\u6001\u5B8C\u6574\uFF08\u7A7A\u6001/\u9519\u8BEF\u6001/\u52A0\u8F7D\u6001\uFF09\u3001\u53EF\u8BFB\u6027\u4F18\u5148\uFF0C\u4E0D\u9700\u8981\u7528\u6237\u989D\u5916\u8BF4\u201C\u6210\u719F\u201D\u3002"}
+${context.language === "en-US" ? "EngineeringStructure=Do not pile logic into existing large files by default. Avoid god files, code blobs, overly long functions (>200 lines), deep nesting (>3 levels), and unbounded global state. Keep responsibility boundaries clear: UI/state/IO/provider/runner/permission/cache/verification. Prefer reusing existing project modules, helpers, presenters, and runtimes over creating a second system. Do not add zero-benefit abstractions for elegance. Each change must have a verifiable boundary (focused tests, typecheck, check). This is not authorization for large refactors." : "EngineeringStructure=\u9ED8\u8BA4\u4E0D\u628A\u903B\u8F91\u5806\u8FDB\u5DF2\u6709\u5927\u6587\u4EF6\u3002\u907F\u514D god file\u3001code blob\u3001\u8D85\u957F\u51FD\u6570\uFF08>200\u884C\uFF09\u3001\u6DF1\u5C42\u5D4C\u5957\uFF08>3\u5C42\uFF09\u3001\u65E0\u8FB9\u754C\u5168\u5C40\u72B6\u6001\u3002\u804C\u8D23\u8FB9\u754C\u4FDD\u6301\u6E05\u6670\uFF1AUI/\u72B6\u6001/IO/provider/runner/permission/cache/verification\u3002\u4F18\u5148\u590D\u7528\u9879\u76EE\u5DF2\u6709\u6A21\u5757\u3001helper\u3001presenter\u3001runtime\uFF0C\u4E0D\u65B0\u5EFA\u7B2C\u4E8C\u5957\u7CFB\u7EDF\u3002\u4E0D\u4E3A\u4E86\u4F18\u96C5\u65B0\u589E\u65E0\u6536\u76CA\u62BD\u8C61\u3002\u6BCF\u4E2A\u6539\u52A8\u8981\u6709\u53EF\u9A8C\u8BC1\u8FB9\u754C\uFF08focused tests\u3001typecheck\u3001check\uFF09\u3002\u8FD9\u4E0D\u662F\u6388\u6743\u5927\u91CD\u6784\u3002"}
+${context.language === "en-US" ? "ShellEnvironment=Respect the actual local OS and shell before proposing or running Bash commands. On Windows/PowerShell, prefer PowerShell cmdlets or Node one-liners for file discovery/transforms; do not use Unix-only pipelines such as find|sed|head unless those tools were verified in this environment." : "ShellEnvironment=\u6267\u884C\u6216\u5EFA\u8BAE Bash \u547D\u4EE4\u524D\u5FC5\u987B\u5C0A\u91CD\u5F53\u524D\u672C\u5730 OS \u548C shell\u3002Windows/PowerShell \u4E0B\u4F18\u5148\u4F7F\u7528 PowerShell cmdlet \u6216 Node one-liner \u505A\u6587\u4EF6\u53D1\u73B0/\u8F6C\u6362\uFF1B\u9664\u975E\u5DF2\u9A8C\u8BC1\u5F53\u524D\u73AF\u5883\u5B58\u5728\u8FD9\u4E9B\u5DE5\u5177\uFF0C\u4E0D\u8981\u4F7F\u7528 find|sed|head \u8FD9\u7C7B Unix-only \u7BA1\u7EBF\u3002"}
+RuntimeIdentityRule=When the user asks in natural language about the current model (e.g. "what model are you", "current model"), answer with the model name only (for example "claude-opus-4-7"). Do not include provider, endpointProfile, route role, baseUrl, or any internal route field in the user-facing answer; do not write "(provider: ...)" or "openai-compatible" in parentheses. Only reveal provider/route/endpointProfile when the user explicitly asks about provider/route/endpoint, or runs /model doctor or /model route doctor. RuntimeStatusForModel does not contain provider/baseUrl/endpointProfile by default; they live in /model doctor.
+PromptHygieneRule=The labelled context fields below (RuntimeStatusForModel, ControlledMemorySummary, MemoryBoundary, EvidenceSummary, CommandCapabilitySummary, SolutionCompleteness, FreshnessRule, FinalAnswerClaimSchema, FailureLearningSummary, MetaSchedulerForModel, GitStatus, etc.) are internal runtime context for your reasoning only. Never quote, paste, or restate these field labels or their raw contents to the user \u2014 not even when asked to "explain in plain words" or "translate". Answer in natural human language; if the user wants raw runtime/diagnostic detail, point them to /model doctor, /status, or /details.
+RuntimeStatusForModel=${JSON.stringify(projectRuntimeStatusForPrompt(runtimeStatus) ?? runtimeStatus)}
+ControlledMemorySummary=${memorySummary}
+MemoryBoundary=acceptedOnly; topK=${MEMORY_PROMPT_TOP_K}; autoExtractionRuntime; dedicatedMemoryDir; manualLearnCandidateOnly; noSecretsOrFullDumps
+EvidenceSummary=${createEvidenceSummaryForModel(context)}
+FreshnessRule=When stating external/current facts (latest API version, prices, news, official site state) without web_source evidence in EvidenceSummary, mark them as unverified or call WebSearch/WebFetch first; do not present them as confirmed.
+FinalAnswerClaimSchema=If your final answer contains high-risk claims, append one internal-only line at the end: LinghunFinalAnswerClaims: {"claims":[{"kind":"completion_pass","phrase":"tests passed"}]}. Allowed kind values: completion_claim, test_claim, file_change_claim, verification_claim, workflow_status_claim, agent_status_claim, completion_pass, code_fact, external_current_fact, ccb_parity, beta_readiness, git_operation, action_executed, architecture_boundary, completeness. Omit the line only when there are no high-risk claims. This line is for the local verifier and will be hidden from the main screen.
+SolutionCompleteness=${JSON.stringify(context.solutionCompleteness)}${solutionCompletenessWarning ? `
+${solutionCompletenessWarning}` : ""}${architectureDirective ? `
+${architectureDirective}` : ""}${deferredReminder ? `
+DeferredToolsReminder=${deferredReminder}` : ""}${worktreeContextLine}${gitStatusLine}${failureLearningLine}${metaSchedulerLine}
+CommandCapabilitySummary=
+${createModelCapabilitySummary(24)}`;
+}
+function createEvidenceSummaryForModel(context) {
+  return JSON.stringify(
+    context.evidence.slice(0, 5).map((item) => ({
+      id: item.id,
+      kind: item.kind,
+      source: item.source,
+      summary: truncateDisplay(item.summary.replace(/\s+/g, " "), 180),
+      supportsClaims: item.supportsClaims.slice(0, 5)
+    }))
+  );
+}
+function updateSolutionCompletenessGate(text, context) {
+  void text;
+  const repeatedDenial = hasRepeatedPermissionDenial(context.permissions.recentDenied);
+  if (repeatedDenial) {
+    context.solutionCompleteness = {
+      ...createSolutionCompletenessStatus(),
+      triggerReason: "repeated_denial",
+      evidenceRefs: collectSolutionCompletenessEvidenceRefs(context),
+      nextRequiredOutput: "\u6700\u8FD1\u540C\u7C7B\u6743\u9650\u62D2\u7EDD\u5DF2\u8BB0\u5F55\uFF1B\u666E\u901A\u4EFB\u52A1\u7EE7\u7EED\u8D70 model/tool loop\uFF0C\u5FC5\u8981\u65F6\u7ED9\u77ED hint \u6216\u8BA9\u7528\u6237\u67E5\u770B /permissions recent\u3002"
+    };
+  }
+  if (!repeatedDenial) {
+    context.solutionCompleteness = createSolutionCompletenessStatus();
+  }
+  return "";
+}
+function collectSolutionCompletenessEvidenceRefs(context) {
+  const evidence = context.evidence.slice(0, 3).map((item) => item.id);
+  const denied = context.permissions.recentDenied.slice(0, 3).map((item) => `permission_denial:${item.toolName}:${item.mode}`);
+  return [...evidence, ...denied];
+}
+var INTERNAL_PROMPT_TOKENS = [
+  "RuntimeStatusForModel",
+  "RuntimeIdentityRule",
+  "ControlledMemorySummary",
+  "MemoryBoundary",
+  "EvidenceSummary",
+  "CommandCapabilitySummary",
+  "SolutionCompleteness",
+  "SYSTEMIC_GAP_WARNING",
+  "FreshnessRule",
+  "FinalAnswerClaimSchema",
+  "LinghunFinalAnswerClaims",
+  "FailureLearningSummary",
+  "FailureLearningRule",
+  "GitStatus",
+  "MetaSchedulerForModel",
+  "PolicyDecision",
+  "PolicyHint",
+  "CapabilitySignal",
+  "capabilitySignal",
+  "CapabilityPlan",
+  "capabilityPlan",
+  "CapabilityExecutionRequest",
+  "CapabilityExecutionResult",
+  "CapabilityRequest",
+  "CapabilityResult",
+  "AppConnectorManifest",
+  "AppConnectorState",
+  "AppConnectorAuthConfig",
+  "AppConnectorConnectionResult",
+  "AppConnectorDoctorResult",
+  "raw connector response",
+  "raw connector payload",
+  "raw connector request",
+  "raw app connector response",
+  "rawPayload",
+  "raw capability payload",
+  "raw capability request",
+  "raw capability result",
+  "UserStateDecision",
+  "userState",
+  "user_state",
+  "interactionPlan",
+  "verificationPlan",
+  "detailPlan",
+  "notificationPlan",
+  "memoryCandidate",
+  "permissionSignal",
+  "modelRouteSignal",
+  "verificationSignal",
+  "memorySignal",
+  "failureSignal",
+  "architectureSignal",
+  "platformSignal",
+  "budgetSignal",
+  "runtimeSignal",
+  "Typed policy route",
+  "Verification route",
+  "policy_decision",
+  "RuntimeStatus",
+  "RuntimeStatusForModel",
+  "gateId",
+  "raw evidence",
+  "raw tool_result",
+  "internal scheduler labels",
+  "meta_scheduler",
+  "WorktreeContext",
+  "DeferredToolsReminder",
+  "OutputStyle",
+  "EngineeringStructure",
+  "ShellEnvironment",
+  "autoExtractionRuntime",
+  "dedicatedMemoryDir",
+  "manualLearnCandidateOnly",
+  "noSecretsOrFullDumps",
+  "doNotWriteLongTermMemoryWithoutExplicitMemoryAccept"
+];
+var INTERNAL_ASSIGNMENT_ONLY_TOKENS = ["confidence"];
+var INTERNAL_TOOL_LABEL_REPLACEMENTS = [
+  ["RunVerification", { "zh-CN": "\u9A8C\u8BC1\u547D\u4EE4", "en-US": "verification command" }]
+];
+function sanitizeMainScreenLeakage(text, language = "zh-CN") {
+  if (!text) return text;
+  const tokenAlternation = INTERNAL_PROMPT_TOKENS.join("|");
+  const assignmentOnlyAlternation = INTERNAL_ASSIGNMENT_ONLY_TOKENS.join("|");
+  const lineRe = new RegExp(
+    `^\\s*(?:${tokenAlternation}|${assignmentOnlyAlternation})\\s*[=:].*$`,
+    "u"
+  );
+  const naturalLanguageLeakRe = new RegExp(`\\b(?:${tokenAlternation})\\b`, "u");
+  const lines = text.split("\n");
+  let redacted = false;
+  const cleaned = lines.filter((line) => {
+    if (lineRe.test(line) || naturalLanguageLeakRe.test(line)) {
+      redacted = true;
+      return false;
+    }
+    return true;
+  });
+  let result = cleaned.join("\n");
+  for (const token of INTERNAL_PROMPT_TOKENS) {
+    if (result.includes(token)) {
+      result = result.split(token).join("");
+      redacted = true;
+    }
+  }
+  for (const [label, replacement] of INTERNAL_TOOL_LABEL_REPLACEMENTS) {
+    if (result.includes(label)) {
+      result = result.split(label).join(replacement[language]);
+      redacted = true;
+    }
+  }
+  result = result.replace(/\n{3,}/gu, "\n\n").trim();
+  if (!redacted) return text;
+  return result;
+}
+
+export {
+  createModelSystemPrompt,
+  createEvidenceSummaryForModel,
+  updateSolutionCompletenessGate,
+  collectSolutionCompletenessEvidenceRefs,
+  sanitizeMainScreenLeakage
+};

package/dist/chunk-3LT6OWQ2.js

@@ -0,0 +1,258 @@
+import {
+  diagnoseConcreteRoute,
+  getRoleRoute,
+  getRouteBlockingProblems,
+  hasOpenAiCompatibleProviderSetupProblem,
+  inferProviderForRouteModel,
+  isDefaultExecutorRoute
+} from "./chunk-2YL5VKJ5.js";
+
+// src/tui-model-runtime.ts
+import { randomUUID } from "crypto";
+import { readFile } from "fs/promises";
+import {
+  getProjectSettingsPath
+} from "@linghun/config";
+import {
+  DeepSeekProvider,
+  ModelGateway,
+  OpenAiCompatibleProvider,
+  resolveEffectiveEndpointProfile
+} from "@linghun/providers";
+import { normalizeDeepSeekModelName } from "@linghun/shared";
+var MAX_ROUTE_DECISIONS = 50;
+function shouldOfferUserScopedModelSetup(context) {
+  return !getProjectModelRouteProblem(context) && hasSelectedProviderConfigProblem(context);
+}
+async function getStartupProjectRouteProblem(context) {
+  const projectRoute = await readProjectExecutorRouteOverride(context.projectPath);
+  if (projectRoute) {
+    return getProjectModelRouteProblemForRoute(projectRoute, context);
+  }
+  return getProjectModelRouteProblem(context);
+}
+async function readProjectExecutorRouteOverride(projectPath) {
+  try {
+    const parsed = JSON.parse(await readFile(getProjectSettingsPath(projectPath), "utf8"));
+    return parsed.modelRoutes?.routes?.find((route) => route.role === "executor");
+  } catch {
+    return void 0;
+  }
+}
+function getProjectModelRouteProblem(context) {
+  const route = getRoleRoute(context.config, "executor");
+  if (isDefaultExecutorRoute(route, context.config)) return void 0;
+  return getProjectModelRouteProblemForRoute(route, context);
+}
+function getProjectModelRouteProblemForRoute(route, context) {
+  const providerId = route.provider || resolveProviderForModel(context.config, route.primaryModel);
+  const provider = context.config.providers[providerId];
+  if (!provider) {
+    return `executor route points to provider=${providerId || "unknown"}, but that provider is not configured`;
+  }
+  if (provider.type === "openai-compatible" && hasOpenAiCompatibleProviderSetupProblem(provider)) {
+    return void 0;
+  }
+  if (!route.primaryModel || route.primaryModel === "openai-compatible-model") {
+    return `executor route primaryModel=${route.primaryModel || "missing"} is not a concrete model`;
+  }
+  return void 0;
+}
+function hasSelectedProviderConfigProblem(context) {
+  const runtime = getSelectedModelRuntime(context);
+  const provider = context.config.providers[runtime.provider];
+  if (!provider) return true;
+  if (provider.type !== "openai-compatible") return !provider.apiKey || !provider.model;
+  return hasOpenAiCompatibleProviderSetupProblem(provider);
+}
+function getRuntimeStatusProvider(context) {
+  const runtime = getSelectedModelRuntime(context);
+  return runtime.provider;
+}
+function getActiveEndpointProfileLabel(context) {
+  const runtime = getSelectedModelRuntime(context);
+  const provider = context.config.providers[runtime.provider];
+  const decision = resolveEffectiveEndpointProfile({
+    requestEndpointProfile: void 0,
+    configEndpointProfile: provider?.endpointProfile,
+    configBaseUrl: provider?.baseUrl,
+    configModel: provider?.model,
+    requestModel: runtime.model
+  });
+  return decision.endpointProfile;
+}
+function resolveInitialModel(config) {
+  const executor = config.modelRoutes.routes.find((route) => route.role === "executor");
+  if (executor && !isDefaultExecutorRoute(executor, config) && executor.primaryModel) {
+    return executor.primaryModel;
+  }
+  const providerModel = executor?.provider ? config.providers[executor.provider]?.model : void 0;
+  return config.defaultModel || executor?.primaryModel || providerModel || resolveFirstProviderModel(config);
+}
+function getSelectedModelRuntime(context, role = "executor") {
+  const route = getRoleRoute(context.config, role);
+  const providerModel = route.provider ? context.config.providers[route.provider]?.model : void 0;
+  const effectivePrimaryModel = route.primaryModel || providerModel || "";
+  const useContextModel = role === "executor" && isDefaultExecutorRoute(route, context.config) && context.model && context.model !== effectivePrimaryModel;
+  const model = useContextModel ? context.model : effectivePrimaryModel || context.model;
+  const provider = useContextModel ? resolveProviderForModel(context.config, model) : route.provider || resolveProviderForModel(context.config, model);
+  const providerConfig = context.config.providers[provider];
+  const rawEndpointProfile = providerConfig?.endpointProfile ?? "chat_completions";
+  const endpointProfile = resolveEffectiveEndpointProfile({
+    requestEndpointProfile: void 0,
+    configEndpointProfile: rawEndpointProfile,
+    configBaseUrl: providerConfig?.baseUrl,
+    configModel: providerConfig?.model,
+    requestModel: model
+  }).endpointProfile;
+  const compatibilityProfile = providerConfig?.compatibilityProfile ?? (providerConfig?.type === "deepseek" ? "deepseek" : "strict_openai_compatible");
+  const reasoningLevel = providerConfig?.reasoningLevel;
+  const reasoningSent = Boolean(
+    reasoningLevel && (endpointProfile === "responses" || compatibilityProfile === "permissive_openai_compatible" || endpointProfile === "anthropic_messages")
+  );
+  return {
+    role,
+    provider,
+    model,
+    endpointProfile,
+    reasoningLevel,
+    reasoningStatus: formatReasoningEffectiveState(reasoningLevel, reasoningSent),
+    reasoningSent
+  };
+}
+function formatReasoningEffectiveState(reasoningLevel, reasoningSent) {
+  if (!reasoningLevel) {
+    return "\u672A\u751F\u6548";
+  }
+  return reasoningSent ? `effective/sent ${reasoningLevel}` : "ignored/unsupported/\u672A\u751F\u6548";
+}
+function resolveProviderForModel(config, model) {
+  const normalized = normalizeDeepSeekModelName(model);
+  const executor = config.modelRoutes.routes.find((route) => route.role === "executor");
+  if ((executor?.primaryModel === model || executor?.primaryModel === normalized) && executor.provider) {
+    return executor.provider;
+  }
+  if (config.defaultModel === model || config.defaultModel === normalized) {
+    for (const [providerId, provider] of Object.entries(config.providers)) {
+      if (provider.model === model || provider.model === normalized) return providerId;
+    }
+  }
+  for (const [providerId, provider] of Object.entries(config.providers)) {
+    if (provider.model === model || provider.model === normalized) {
+      return providerId;
+    }
+  }
+  return "unknown";
+}
+function resolveFirstProviderModel(config) {
+  for (const provider of Object.values(config.providers)) {
+    if (provider.model) return provider.model;
+  }
+  return "unknown";
+}
+function createModelGateway(config) {
+  return new ModelGateway(
+    Object.entries(config.providers).map(([id, provider]) => {
+      if (provider.type === "deepseek") {
+        return new DeepSeekProvider({ ...provider, id, displayName: "DeepSeek" });
+      }
+      return new OpenAiCompatibleProvider({ ...provider, id, displayName: "OpenAI compatible" });
+    })
+  );
+}
+function resolveRoleRoute(context, role, triggerReason) {
+  const baseRoute = getRoleRoute(context.config, role);
+  const effectivePrimaryModel = baseRoute.primaryModel || (baseRoute.provider ? context.config.providers[baseRoute.provider]?.model : void 0) || "";
+  const primaryProblems = diagnoseConcreteRoute(
+    baseRoute,
+    effectivePrimaryModel,
+    baseRoute.provider,
+    context.config
+  );
+  const primaryBlocking = getRouteBlockingProblems(primaryProblems);
+  let selectedProvider = baseRoute.provider;
+  let selectedModel = effectivePrimaryModel;
+  let stopConditions = primaryBlocking;
+  let fallbackUsed = false;
+  if (primaryBlocking.length > 0) {
+    for (const fallbackModel of baseRoute.fallbackModels) {
+      const fallbackProvider = inferProviderForRouteModel(fallbackModel, context.config);
+      const fallbackProblems = diagnoseConcreteRoute(
+        baseRoute,
+        fallbackModel,
+        fallbackProvider,
+        context.config
+      );
+      const fallbackBlocking = getRouteBlockingProblems(fallbackProblems);
+      if (fallbackBlocking.length === 0) {
+        selectedProvider = fallbackProvider;
+        selectedModel = fallbackModel;
+        stopConditions = [];
+        fallbackUsed = true;
+        break;
+      }
+    }
+  } else {
+    stopConditions = [];
+  }
+  const resolvedRoute = { ...baseRoute, provider: selectedProvider, primaryModel: selectedModel };
+  const repairSuggestions = createRouteRepairSuggestions(role, stopConditions, baseRoute);
+  const decision = {
+    id: `route-${randomUUID().slice(0, 8)}`,
+    triggerReason,
+    role,
+    selectedProvider: stopConditions.length > 0 ? "" : selectedProvider,
+    selectedModel: stopConditions.length > 0 ? "" : selectedModel,
+    fallbackCandidates: baseRoute.fallbackModels,
+    requiredCapabilities: baseRoute.requiredCapabilities,
+    maxCostCny: baseRoute.maxCostCny,
+    stopConditions,
+    repairSuggestions,
+    fallbackUsed,
+    budgetStop: false,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  context.routeDecisions.unshift(decision);
+  context.routeDecisions = context.routeDecisions.slice(0, MAX_ROUTE_DECISIONS);
+  return { route: resolvedRoute, decision, usable: stopConditions.length === 0 };
+}
+function createRouteRepairSuggestions(role, stopConditions, route) {
+  if (stopConditions.length === 0) {
+    return [];
+  }
+  const suggestions = [`\u8FD0\u884C /model route set ${role} <model> \u8BBE\u7F6E\u53EF\u7528\u6A21\u578B`];
+  if (stopConditions.some((item) => item.includes("openai-compatible"))) {
+    suggestions.push(
+      "\u5728 .linghun/settings.json \u914D\u7F6E openai-compatible \u7684 baseUrl\u3001apiKey \u548C model"
+    );
+  }
+  if (stopConditions.some((item) => item.startsWith("\u80FD\u529B\u4E0D\u8DB3"))) {
+    suggestions.push(`\u9009\u62E9\u6EE1\u8DB3 ${route.requiredCapabilities.join("+")} capability \u7684\u6A21\u578B`);
+  }
+  if (route.fallbackModels.length === 0) {
+    suggestions.push("\u4E3A\u8BE5 role \u914D\u7F6E fallbackModels\uFF0C\u907F\u514D primary \u4E0D\u53EF\u7528\u65F6\u76F4\u63A5\u6682\u505C");
+  }
+  return suggestions;
+}
+function formatRoutePauseMessage(role, decision) {
+  return `${role} role \u8DEF\u7531\u6682\u505C\uFF1A${decision.stopConditions.join("\uFF1B")}\u3002\u4FEE\u590D\u5EFA\u8BAE\uFF1A${decision.repairSuggestions.join("\uFF1B")}\u3002\u4E0D\u4F1A\u5047\u88C5\u53EF\u7528\u3002`;
+}
+
+export {
+  shouldOfferUserScopedModelSetup,
+  getStartupProjectRouteProblem,
+  readProjectExecutorRouteOverride,
+  getProjectModelRouteProblem,
+  getProjectModelRouteProblemForRoute,
+  hasSelectedProviderConfigProblem,
+  getRuntimeStatusProvider,
+  getActiveEndpointProfileLabel,
+  resolveInitialModel,
+  getSelectedModelRuntime,
+  formatReasoningEffectiveState,
+  resolveProviderForModel,
+  createModelGateway,
+  resolveRoleRoute,
+  createRouteRepairSuggestions,
+  formatRoutePauseMessage
+};

package/dist/chunk-3XNUDLOM.js

@@ -0,0 +1,91 @@
+// src/turn-continuity-runtime.ts
+var INITIAL_TRUST_SCORE = 50;
+var MAX_TRUST_SCORE = 100;
+var MIN_TRUST_SCORE = 0;
+var RECENT_TASK_KIND_WINDOW = 5;
+var RECENT_MESSAGE_LENGTH_WINDOW = 5;
+function createInitialContinuityState() {
+  return {
+    consecutiveFailures: 0,
+    consecutiveSuccesses: 0,
+    dominantTaskKind: null,
+    taskDomainSwitched: false,
+    lastUserStateKind: "neutral",
+    userStatePersistence: 1,
+    totalTurns: 0,
+    messageLengthTrend: "stable",
+    trustScore: INITIAL_TRUST_SCORE
+  };
+}
+function updateTurnContinuity(prev, currentInput, recentTaskKinds, recentMessageLengths) {
+  const hadAnyFailure = currentInput.hadToolFailure || currentInput.hadProviderFailure || currentInput.hadVerificationFailure;
+  const consecutiveFailures = hadAnyFailure ? prev.consecutiveFailures + 1 : 0;
+  const hadSuccess = !hadAnyFailure && currentInput.lastVerificationStatus !== "fail" && currentInput.lastVerificationStatus !== "partial";
+  const consecutiveSuccesses = hadSuccess ? prev.consecutiveSuccesses + 1 : hadAnyFailure ? 0 : prev.consecutiveSuccesses;
+  const nextRecentTaskKinds = [...recentTaskKinds, currentInput.taskKind].slice(-RECENT_TASK_KIND_WINDOW);
+  const dominantTaskKind = computeDominant(nextRecentTaskKinds);
+  const taskDomainSwitched = prev.dominantTaskKind !== null && currentInput.taskKind !== prev.dominantTaskKind;
+  const userStatePersistence = currentInput.userStateKind === prev.lastUserStateKind ? prev.userStatePersistence + 1 : 1;
+  const nextRecentMessageLengths = [...recentMessageLengths, currentInput.userText.length].slice(
+    -RECENT_MESSAGE_LENGTH_WINDOW
+  );
+  const messageLengthTrend = computeMessageLengthTrend(nextRecentMessageLengths);
+  let trustScore = prev.trustScore;
+  if (currentInput.userCorrectedAssistant) {
+    trustScore = Math.max(MIN_TRUST_SCORE, trustScore - 8);
+  } else if (currentInput.hadProviderFailure) {
+    trustScore = Math.max(MIN_TRUST_SCORE, trustScore - 5);
+  } else if (currentInput.hadToolFailure) {
+    trustScore = Math.max(MIN_TRUST_SCORE, trustScore - 3);
+  } else if (hadSuccess && currentInput.lastVerificationStatus === "pass") {
+    trustScore = Math.min(MAX_TRUST_SCORE, trustScore + 2);
+  } else if (hadSuccess) {
+    trustScore = Math.min(MAX_TRUST_SCORE, trustScore + 1);
+  }
+  return {
+    state: {
+      consecutiveFailures,
+      consecutiveSuccesses,
+      dominantTaskKind,
+      taskDomainSwitched,
+      lastUserStateKind: currentInput.userStateKind,
+      userStatePersistence,
+      totalTurns: prev.totalTurns + 1,
+      messageLengthTrend,
+      trustScore
+    },
+    recentTaskKinds: nextRecentTaskKinds,
+    recentMessageLengths: nextRecentMessageLengths
+  };
+}
+function computeDominant(kinds) {
+  if (kinds.length === 0) return null;
+  const counts = /* @__PURE__ */ new Map();
+  let best = kinds[0];
+  let bestCount = 0;
+  for (const k of kinds) {
+    const c = (counts.get(k) ?? 0) + 1;
+    counts.set(k, c);
+    if (c > bestCount) {
+      bestCount = c;
+      best = k;
+    }
+  }
+  return best;
+}
+function computeMessageLengthTrend(lengths) {
+  if (lengths.length < 3) return "stable";
+  const firstHalf = lengths.slice(0, Math.floor(lengths.length / 2));
+  const secondHalf = lengths.slice(Math.floor(lengths.length / 2));
+  const firstAvg = firstHalf.reduce((a, b) => a + b, 0) / firstHalf.length;
+  const secondAvg = secondHalf.reduce((a, b) => a + b, 0) / secondHalf.length;
+  const ratio = firstAvg > 0 ? secondAvg / firstAvg : 1;
+  if (ratio < 0.7) return "shortening";
+  if (ratio > 1.3) return "lengthening";
+  return "stable";
+}
+
+export {
+  createInitialContinuityState,
+  updateTurnContinuity
+};