@linghun/tui 0.1.0

package/dist/chunk-DNQN74CC.js

@@ -0,0 +1,1186 @@
+import {
+  evaluateUserStateSignal
+} from "./chunk-KQJHVJZB.js";
+import {
+  LINGHUN_AGENT_CHILD_TURNS_AGENT,
+  LINGHUN_AGENT_CHILD_TURNS_BASE,
+  LINGHUN_AGENT_CHILD_TURNS_CODE_FACT,
+  LINGHUN_AGENT_CHILD_TURNS_VERIFICATION,
+  LINGHUN_AGENT_CHILD_TURNS_WORKFLOW,
+  LINGHUN_AGENT_TOOL_ROUNDS_AGENT,
+  LINGHUN_AGENT_TOOL_ROUNDS_BASE,
+  LINGHUN_AGENT_TOOL_ROUNDS_CODE_FACT,
+  LINGHUN_AGENT_TOOL_ROUNDS_VERIFICATION,
+  LINGHUN_AGENT_TOOL_ROUNDS_WORKFLOW,
+  LINGHUN_BACKGROUND_CONCURRENCY_AGENT,
+  LINGHUN_BACKGROUND_CONCURRENCY_BASE,
+  LINGHUN_BACKGROUND_CONCURRENCY_CODE_FACT,
+  LINGHUN_BACKGROUND_CONCURRENCY_VERIFICATION,
+  LINGHUN_BACKGROUND_CONCURRENCY_WORKFLOW,
+  LINGHUN_MAX_TODO_ONLY_AGENT,
+  LINGHUN_MAX_TODO_ONLY_BASE,
+  LINGHUN_MAX_TODO_ONLY_CODE_FACT,
+  LINGHUN_MAX_TODO_ONLY_VERIFICATION,
+  LINGHUN_MAX_TODO_ONLY_WORKFLOW
+} from "./chunk-IWUIOLMF.js";
+import {
+  estimateModelMessageChars
+} from "./chunk-WV6YJGZR.js";
+
+// src/meta-scheduler-runtime.ts
+function evaluateMetaScheduler(input) {
+  const internalEvents = [];
+  const directives = [];
+  const userStateSignal = input.userStateDecision ?? evaluateUserStateSignal({
+    userText: input.userText,
+    repeatedFailureCount: (input.lastToolFailure || input.providerFailure || isRiskyVerificationStatus(input.lastVerificationStatus) ? 1 : 0) + countRecentFailureLearning(input.failureLearning),
+    events: [
+      ...input.lastToolFailure ? [
+        {
+          kind: "tool_failure",
+          summary: `${input.lastToolFailure.toolName}: ${input.lastToolFailure.summary}`
+        }
+      ] : [],
+      ...input.providerFailure ? [
+        {
+          kind: "provider_failure",
+          summary: `${input.providerFailure.provider}/${input.providerFailure.model}: ${input.providerFailure.message}`
+        }
+      ] : [],
+      ...isRiskyVerificationStatus(input.lastVerificationStatus) ? [
+        {
+          kind: "verification_failure",
+          summary: `last verification ${input.lastVerificationStatus}`
+        }
+      ] : []
+    ],
+    loading: input.loading,
+    activePrompt: input.activePrompt,
+    otherPanelOpen: input.otherPanelOpen,
+    dismissedUntilMs: input.userStateDismissedUntilMs,
+    cooldownUntilMs: input.userStateCooldownUntilMs,
+    policyEnabled: input.userStatePolicyEnabled,
+    backgroundTasks: input.backgroundTasks,
+    nowMs: input.nowMs
+  }).decision;
+  const userStateDecision = input.userStateDecision ?? userStateSignal;
+  const highRiskClaim = typeof input.assistantText === "string" && hasHighRiskCompletionClaim(input.assistantText);
+  const toolFailure = Boolean(input.lastToolFailure);
+  const providerFailure = Boolean(input.providerFailure);
+  const blockedRuntime = hasActiveBlockedWorkflow(input.workflow);
+  const pressure = computeContextPressure(
+    input.messages,
+    input.estimatedContextChars,
+    input.contextMaxChars,
+    input.triggerChars
+  );
+  const indexStrategy = classifyIndexStrategy(input.index);
+  const capabilityPlan = createCapabilityPlan(input.userText);
+  const classification = classifyTaskKind(input.userText, capabilityPlan, {
+    consecutiveFailures: input.consecutiveFailures,
+    taskDomainSwitched: input.taskDomainSwitched,
+    lastVerificationStatus: input.lastVerificationStatus,
+    userStatePersistence: input.userStatePersistence,
+    failureLearning: input.failureLearning,
+    hasActiveProviderFailure: input.hasActiveProviderFailure
+  });
+  let taskKind = adjustTaskKindForUserState(classification.primary, userStateDecision);
+  if (classification.intentUnclear) {
+    taskKind = "chat";
+    directives.push("\u7528\u6237\u610F\u56FE\u4E0D\u660E\u786E\uFF0C\u5148\u6F84\u6E05\u518D\u64CD\u4F5C");
+    internalEvents.push("meta_scheduler:intent_unclear_clarify");
+  }
+  if (classification.reason) {
+    internalEvents.push(`meta_scheduler:classifier_reason=${classification.reason}`);
+  }
+  const expectedMutating = userStateDecision.interactionPlan.allowImplementationPush && expectsMutatingAction(input.userText, taskKind, capabilityPlan);
+  const verificationDomain = classifyVerificationDomain(input.userText, taskKind, expectedMutating);
+  const evidenceFreshness = classifyVerificationEvidenceFreshness(input.evidence, input.nowMs);
+  const runtimeSignal = summarizeRuntimeSignal(input, evidenceFreshness);
+  const includeFailureLearning = hasActiveFailureLearning(input.failureLearning);
+  const failureSignal = summarizeFailureSignal(input.failureLearning);
+  let preferSourceFirst = shouldPreferSourceFirst(taskKind, indexStrategy) || userStateDecision.interactionPlan.sourceFactsFirst;
+  let requireVerification = highRiskClaim || taskKind === "verification" || expectedMutating || isRiskyVerificationStatus(input.lastVerificationStatus) || userStateDecision.verificationPlan.strength === "strengthened" || userStateDecision.verificationPlan.strength === "release";
+  if (classification.secondaries.includes("code_fact")) {
+    preferSourceFirst = true;
+  }
+  if (classification.secondaries.includes("verification")) {
+    requireVerification = true;
+  }
+  const surfaceWindowsSafeHint = shouldSurfaceWindowsSafeHint({
+    userText: input.userText,
+    taskKind,
+    expectedMutating,
+    blockedRuntime,
+    toolFailure,
+    providerFailure,
+    providerCooldownBlocked: Boolean(input.providerCooldownBlocked || input.routeProviderCooldown)
+  });
+  const suggestedRole = highRiskClaim ? "verifier" : taskKind === "workflow" || taskKind === "agent" ? "planner" : void 0;
+  const recentDeniedCount = input.recentDeniedCount ?? 0;
+  const providerPlan = input.providerCooldownBlocked ? "cooldownBlocked" : providerFailure ? "fallbackCandidate" : "keepCurrent";
+  const trustScore = input.trustScore ?? 50;
+  const consecutiveFailures = input.consecutiveFailures ?? 0;
+  const consecutiveSuccesses = input.consecutiveSuccesses ?? 0;
+  const taskDomainSwitched = input.taskDomainSwitched ?? false;
+  const userStatePersistence = input.userStatePersistence ?? 1;
+  const totalTurns = input.totalTurns ?? 0;
+  let adjustedUserStateDecision = userStateDecision;
+  let adjustedIncludeFailureLearning = includeFailureLearning;
+  let adjustedShouldCompact = pressure.shouldCompact;
+  let adjustedRequireVerification = requireVerification;
+  let adjustedRequireFinalGate = highRiskClaim || userStateDecision.verificationPlan.forbidEarlyPass;
+  let adjustedShouldUseRetryGuard = toolFailure || providerFailure;
+  let adjustedVerificationStrength = userStateDecision.verificationPlan.strength;
+  if (trustScore < 30 && userStateDecision.kind === "neutral") {
+    adjustedUserStateDecision = {
+      ...userStateDecision,
+      kind: "trust_repair",
+      interactionPlan: { ...userStateDecision.interactionPlan, sourceFactsFirst: true, explainFirst: true }
+    };
+    internalEvents.push("meta_scheduler:continuity_trust_repair_escalation");
+  }
+  if (consecutiveFailures >= 2) {
+    adjustedShouldUseRetryGuard = true;
+    internalEvents.push("meta_scheduler:continuity_retry_guard_escalation");
+  }
+  if (consecutiveSuccesses >= 5 && trustScore > 70) {
+    adjustedVerificationStrength = "focused";
+    adjustedRequireFinalGate = false;
+    internalEvents.push("meta_scheduler:continuity_verification_downgrade");
+  }
+  if (taskDomainSwitched) {
+    adjustedIncludeFailureLearning = false;
+    internalEvents.push("meta_scheduler:continuity_domain_switch_failure_reset");
+  }
+  if (userStatePersistence >= 5) {
+    directives.push(
+      `User state "${userStateDecision.kind}" persisted for ${userStatePersistence} turns; suppressing repeat hints for 5 minutes.`
+    );
+    internalEvents.push("meta_scheduler:continuity_user_state_cooldown");
+  }
+  if (totalTurns > 30) {
+    adjustedShouldCompact = true;
+    internalEvents.push("meta_scheduler:continuity_long_session_compact");
+  }
+  if (highRiskClaim) {
+    directives.push(
+      "High-risk completion or verification claims require existing verification/final-answer-gate evidence before PASS."
+    );
+    internalEvents.push("meta_scheduler:final_answer_gate_required");
+  }
+  if (toolFailure || providerFailure) {
+    directives.push(
+      "Tool/provider failures must be captured as failure learning or an explicit degraded state; do not claim completion from a failed turn."
+    );
+    internalEvents.push("meta_scheduler:failure_learning_required");
+  }
+  if (pressure.shouldCompact) {
+    directives.push(
+      "Context is near provider budget; run compact/tool-result artifact flow before sending provider-visible messages."
+    );
+    internalEvents.push("meta_scheduler:compact_required");
+  }
+  if (blockedRuntime) {
+    directives.push(
+      "Blocked/stale agent or workflow state is a hard stop for PASS; require real recovery, cancellation, or explicit degradation."
+    );
+    internalEvents.push("meta_scheduler:blocked_runtime_stop");
+  }
+  directives.push(formatIndexStrategyDirective(indexStrategy, input.index));
+  const verificationRoute = createVerificationRoute({
+    domain: verificationDomain,
+    evidenceFreshness,
+    lastStatus: input.lastVerificationStatus,
+    blockedRuntime,
+    runtimeSignal,
+    failureSignal,
+    resourceCapPressure: runtimeSignal.resourceCapPressure,
+    userStateDecision: adjustedUserStateDecision
+  });
+  directives.push(formatVerificationRouteDirective(verificationRoute));
+  directives.push(formatUserStateDirective(adjustedUserStateDecision));
+  appendUserStateInternalEvents(internalEvents, adjustedUserStateDecision);
+  const policyDecision = createPolicyDecision({
+    taskKind,
+    riskLevel: classifyRiskLevel({
+      highRiskClaim,
+      blockedRuntime,
+      expectedMutating,
+      providerFailure,
+      toolFailure,
+      pressure: pressure.shouldCompact,
+      userStateDecision: adjustedUserStateDecision
+    }),
+    includeMemory: (input.memoryAcceptedCount ?? 0) > 0,
+    includeFailureLearning: adjustedIncludeFailureLearning,
+    compactBeforeProvider: adjustedShouldCompact,
+    preferSourceFirst,
+    preferWorkflow: taskKind === "workflow" && adjustedUserStateDecision.interactionPlan.allowImplementationPush,
+    preferAgent: taskKind === "agent" && adjustedUserStateDecision.interactionPlan.allowImplementationPush,
+    requireVerification: adjustedRequireVerification,
+    requireFinalGate: adjustedRequireFinalGate,
+    expectedMutating,
+    requireExplicitGate: expectedMutating || blockedRuntime || Boolean(input.pendingApproval),
+    providerPlan,
+    blockedRuntime,
+    toolFailure,
+    providerFailure,
+    surfaceWindowsSafeHint,
+    userState: adjustedUserStateDecision,
+    capabilityPlan,
+    userStatePersistence,
+    permissionSignal: {
+      permissionMode: input.permissionMode ?? "default",
+      recentDenied: recentDeniedCount > 0,
+      recentDeniedCount,
+      expectedMutating,
+      requireExplicitGate: expectedMutating || blockedRuntime || recentDeniedCount > 0 || Boolean(input.pendingApproval),
+      pendingApproval: Boolean(input.pendingApproval)
+    },
+    modelRouteSignal: {
+      role: input.currentRole ?? "executor",
+      provider: input.currentProvider ?? "unknown",
+      model: input.currentModel ?? "unknown",
+      fallback: Boolean(input.routeFallbackUsed || providerPlan === "fallbackCandidate"),
+      providerCooldown: Boolean(input.routeProviderCooldown || input.providerCooldownBlocked),
+      providerFailure: Boolean(input.routeProviderFailure || providerFailure),
+      suggestedRole
+    },
+    verificationSignal: {
+      required: adjustedRequireVerification,
+      recommendedLevel: adjustedVerificationStrength === "focused" ? "focused" : classifyVerificationLevel({
+        highRiskClaim,
+        expectedMutating,
+        taskKind,
+        blockedRuntime,
+        lastStatus: input.lastVerificationStatus,
+        userStateDecision: adjustedUserStateDecision
+      }),
+      route: verificationRoute,
+      reason: highRiskClaim ? "high_risk_claim" : taskKind === "verification" ? "requested" : expectedMutating ? "mutating" : "normal",
+      ...input.lastVerificationStatus ? { lastStatus: input.lastVerificationStatus } : {}
+    },
+    runtimeSignal,
+    memorySignal: {
+      accepted: (input.memoryAcceptedCount ?? 0) > 0,
+      acceptedCount: input.memoryAcceptedCount ?? 0,
+      candidateCount: input.memoryCandidateCount ?? 0,
+      autoLearningActive: Boolean(input.memoryAutoLearningActive)
+    },
+    failureSignal,
+    architectureSignal: {
+      cardPresent: Boolean(input.currentArchitectureCard),
+      guardReminder: Boolean(input.currentArchitectureCard && (expectedMutating || blockedRuntime)),
+      driftPending: Boolean(input.architectureDriftPending)
+    },
+    platformSignal: {
+      platform: input.platform ?? "unknown",
+      shellFamily: input.shellFamily ?? "unknown",
+      terminalTier: input.terminalCapability?.tier ?? "unknown",
+      windowsSafeHint: (input.platform ?? "unknown") === "win32"
+    },
+    budgetSignal: {
+      contextPressure: adjustedShouldCompact,
+      usageNearLimit: Boolean(input.roleBudgetStop),
+      toolResultBudgetPressure: (input.toolResultBudgetPersistedCount ?? 0) > 0
+    }
+  });
+  return {
+    directives,
+    policyDecision,
+    shouldRunFinalAnswerGate: adjustedRequireFinalGate,
+    shouldPreferVerifier: (highRiskClaim || adjustedUserStateDecision.verificationPlan.strength === "release") && evidenceFreshness !== "fresh",
+    shouldCaptureFailureLearning: toolFailure || providerFailure,
+    shouldUseRetryGuard: adjustedShouldUseRetryGuard,
+    shouldCompactBeforeProvider: adjustedShouldCompact,
+    shouldStopForBlockedRuntime: blockedRuntime,
+    indexStrategy,
+    suggestedMaxTodoRounds: computeSuggestedMaxTodoRounds(taskKind),
+    suggestedMaxAgentChildTurns: computeSuggestedAgentChildTurns(taskKind),
+    suggestedMaxAgentToolRounds: computeSuggestedAgentToolRounds(taskKind),
+    suggestedBackgroundConcurrency: computeSuggestedBackgroundConcurrency(taskKind),
+    internalEvents
+  };
+}
+function computeSuggestedMaxTodoRounds(taskKind) {
+  switch (taskKind) {
+    case "agent":
+      return LINGHUN_MAX_TODO_ONLY_AGENT;
+    case "workflow":
+      return LINGHUN_MAX_TODO_ONLY_WORKFLOW;
+    case "verification":
+      return LINGHUN_MAX_TODO_ONLY_VERIFICATION;
+    case "code_fact":
+      return LINGHUN_MAX_TODO_ONLY_CODE_FACT;
+    default:
+      return LINGHUN_MAX_TODO_ONLY_BASE;
+  }
+}
+function computeSuggestedAgentChildTurns(taskKind) {
+  switch (taskKind) {
+    case "agent":
+      return LINGHUN_AGENT_CHILD_TURNS_AGENT;
+    case "workflow":
+      return LINGHUN_AGENT_CHILD_TURNS_WORKFLOW;
+    case "verification":
+      return LINGHUN_AGENT_CHILD_TURNS_VERIFICATION;
+    case "code_fact":
+      return LINGHUN_AGENT_CHILD_TURNS_CODE_FACT;
+    default:
+      return LINGHUN_AGENT_CHILD_TURNS_BASE;
+  }
+}
+function computeSuggestedAgentToolRounds(taskKind) {
+  switch (taskKind) {
+    case "agent":
+      return LINGHUN_AGENT_TOOL_ROUNDS_AGENT;
+    case "workflow":
+      return LINGHUN_AGENT_TOOL_ROUNDS_WORKFLOW;
+    case "verification":
+      return LINGHUN_AGENT_TOOL_ROUNDS_VERIFICATION;
+    case "code_fact":
+      return LINGHUN_AGENT_TOOL_ROUNDS_CODE_FACT;
+    default:
+      return LINGHUN_AGENT_TOOL_ROUNDS_BASE;
+  }
+}
+function computeSuggestedBackgroundConcurrency(taskKind) {
+  switch (taskKind) {
+    case "agent":
+      return LINGHUN_BACKGROUND_CONCURRENCY_AGENT;
+    case "workflow":
+      return LINGHUN_BACKGROUND_CONCURRENCY_WORKFLOW;
+    case "verification":
+      return LINGHUN_BACKGROUND_CONCURRENCY_VERIFICATION;
+    case "code_fact":
+      return LINGHUN_BACKGROUND_CONCURRENCY_CODE_FACT;
+    default:
+      return LINGHUN_BACKGROUND_CONCURRENCY_BASE;
+  }
+}
+function formatMetaSchedulerDirective(decision) {
+  return [
+    "MetaSchedulerForModel:",
+    ...decision.directives.map((item) => `- ${item}`),
+    `- Typed policy route: task ${decision.policyDecision.taskKind}; risk ${decision.policyDecision.riskLevel}; budget ${decision.suggestedMaxTodoRounds} rounds; agent-max-turns ${decision.suggestedMaxAgentChildTurns}; agent-tool-rounds ${decision.suggestedMaxAgentToolRounds}; bg-concurrency ${decision.suggestedBackgroundConcurrency}; provider ${decision.policyDecision.providerPlan}; source-first ${decision.policyDecision.executionPlan.preferSourceFirst ? "yes" : "no"}; verification ${decision.policyDecision.executionPlan.requireVerification ? "required" : "normal"}; explicit-gate ${decision.policyDecision.permissionPlan.requireExplicitGate ? "required" : "normal"}; user-state ${decision.policyDecision.userState.kind}; capability ${decision.policyDecision.capabilitySignal.active ? "candidate" : "none"}.`,
+    ...decision.policyDecision.executionPlan.preferAgent || decision.policyDecision.executionPlan.preferWorkflow ? ["- Action: this is an agent/workflow-classified task. Delegate execution via StartAgent or RunWorkflow tools. Do not serial-Todo-plan every step yourself; use the extended planning budget to set up delegation, then call the tool."] : [],
+    "- Keep RuntimeStatusForModel, UserStateDecision, capabilitySignal, capabilityPlan, CapabilityExecutionRequest, CapabilityExecutionResult, raw capability payload, interactionPlan, verificationPlan, notificationPlan, confidence, gateId, raw evidence, raw tool_result, and internal scheduler labels out of the user-visible final answer."
+  ].join("\n");
+}
+function formatPolicyDecisionSummary(decision, language) {
+  const parts = [];
+  if (decision.executionPlan.preferSourceFirst) {
+    parts.push(language === "en-US" ? "source-first" : "\u6E90\u7801\u4F18\u5148");
+  }
+  if (decision.executionPlan.requireVerification) {
+    parts.push(language === "en-US" ? "verification required" : "\u9700\u8981\u9A8C\u8BC1");
+  }
+  if (decision.userState.interactionPlan.explainFirst) {
+    parts.push(language === "en-US" ? "explain-first" : "\u5148\u89E3\u91CA");
+  }
+  if (decision.userState.interactionPlan.discussionOnly) {
+    parts.push(language === "en-US" ? "discussion-only" : "\u4EC5\u8BA8\u8BBA\u5224\u65AD");
+  }
+  if (decision.userState.interactionPlan.commandFirst) {
+    parts.push(language === "en-US" ? "command-first" : "\u547D\u4EE4\u4F18\u5148");
+  }
+  if (decision.userState.verificationPlan.strength === "release") {
+    parts.push(language === "en-US" ? "release gate" : "\u53D1\u5E03\u95F8\u95E8");
+  }
+  if (decision.contextPlan.compactBeforeProvider) {
+    parts.push(language === "en-US" ? "compact before provider" : "\u5148\u538B\u7F29\u4E0A\u4E0B\u6587");
+  }
+  if (decision.providerPlan === "fallbackCandidate") {
+    parts.push(language === "en-US" ? "fallback candidate ready" : "\u51C6\u5907 fallback \u5019\u9009");
+  }
+  if (decision.providerPlan === "cooldownBlocked") {
+    parts.push(language === "en-US" ? "provider cooldown blocked" : "provider \u51B7\u5374\u963B\u585E");
+  }
+  if (decision.executionPlan.preferWorkflow) {
+    parts.push(language === "en-US" ? "workflow route" : "workflow \u8DEF\u7EBF");
+  }
+  if (decision.executionPlan.preferAgent) {
+    parts.push(language === "en-US" ? "agent route" : "agent \u8DEF\u7EBF");
+  }
+  if (decision.capabilitySignal.active) {
+    parts.push(language === "en-US" ? "capability route" : "capability \u8DEF\u7EBF");
+  }
+  if (decision.platformSignal.windowsSafeHint) {
+    parts.push(language === "en-US" ? "Windows-safe shell" : "Windows \u517C\u5BB9\u547D\u4EE4");
+  }
+  if (decision.modelRouteSignal.suggestedRole) {
+    parts.push(
+      language === "en-US" ? `suggest ${decision.modelRouteSignal.suggestedRole}` : `\u5EFA\u8BAE ${decision.modelRouteSignal.suggestedRole}`
+    );
+  }
+  const summary = parts.length > 0 ? parts.join("; ") : language === "en-US" ? "keep current route" : "\u4FDD\u6301\u5F53\u524D\u8DEF\u7EBF";
+  return language === "en-US" ? `strategy: ${summary}; task ${decision.taskKind}; risk ${decision.riskLevel}` : `\u7B56\u7565\uFF1A${summary}\uFF1B\u4EFB\u52A1 ${decision.taskKind}\uFF1B\u98CE\u9669 ${decision.riskLevel}`;
+}
+function verifyFailureLearningContract(input) {
+  if (!input.decision.shouldCaptureFailureLearning) {
+    return { satisfied: true };
+  }
+  if (input.postTurnRecordCount > input.preTurnRecordCount) {
+    return { satisfied: true };
+  }
+  return {
+    satisfied: false,
+    reason: `meta-scheduler required failure learning capture for ${input.failureKind} failure but no new record was added; degraded state recorded`
+  };
+}
+function hasHighRiskCompletionClaim(text) {
+  return /(?:\bPASS\b|\bpassed\b|\bverified\b|\btests?\s+pass(?:ed)?\b|\bfixed\b|\bcompleted\b|已完成|已修复|已验证|验证通过|测试通过|可以进入下一阶段|ready\s+for|可进入)/iu.test(
+    text
+  );
+}
+function countRecentFailureLearning(state) {
+  return state.records.filter(
+    (record) => record.status === "active" && record.projectScope === state.projectScope
+  ).length;
+}
+function adjustTaskKindForUserState(taskKind, decision) {
+  if (decision.kind === "confused" || decision.kind === "strategic_exploration") {
+    return "chat";
+  }
+  return taskKind;
+}
+var DOMAIN_KEYWORD_WEIGHTS = {
+  code_fact: [
+    ["\u8BFB", 10],
+    ["\u5B9A\u4F4D", 10],
+    ["\u6E90\u7801", 10],
+    ["read", 10],
+    ["source", 10],
+    ["\u770B", 8],
+    ["\u627E", 8],
+    ["grep", 8],
+    ["search", 8],
+    ["\u8C03\u7528\u94FE", 8],
+    ["code", 8],
+    ["\u5BA1\u8BA1", 8],
+    ["review", 8],
+    ["\u5206\u6790", 6],
+    ["audit", 8],
+    ["\u68B3\u7406", 6],
+    ["\u67E5\u770B", 6],
+    ["inspect", 6],
+    ["trace", 6],
+    ["\u6587\u4EF6", 6],
+    ["file", 4]
+  ],
+  edit: [
+    ["\u4FEE\u6539", 10],
+    ["\u4FEE", 10],
+    ["\u6539", 10],
+    ["fix", 10],
+    ["modify", 10],
+    ["\u5B9E\u73B0", 8],
+    ["\u5199\u5165", 8],
+    ["write", 8],
+    ["implement", 8],
+    ["update", 8],
+    ["\u65B0\u589E", 6],
+    ["\u521B\u5EFA", 6],
+    ["\u5220\u9664", 6],
+    ["create", 6],
+    ["delete", 6]
+  ],
+  verification: [
+    ["\u6D4B\u8BD5", 10],
+    ["\u9A8C\u8BC1", 10],
+    ["test", 10],
+    ["verify", 10],
+    ["typecheck", 8],
+    ["lint", 8],
+    ["check", 8],
+    ["build", 6],
+    ["\u68C0\u67E5", 4]
+  ],
+  agent: [
+    ["agent", 10],
+    ["\u667A\u80FD\u4F53", 10],
+    ["multi-agent", 10],
+    ["fork", 8],
+    ["\u591A\u5F00", 6],
+    ["\u5E76\u884C", 6]
+  ],
+  workflow: [
+    ["workflow", 10],
+    ["job", 10],
+    ["\u5DE5\u4F5C\u6D41", 10],
+    ["\u6D41\u6C34\u7EBF", 6],
+    ["\u540E\u53F0", 4],
+    ["\u6258\u7BA1", 4]
+  ]
+};
+var LATIN_KEYWORD_PATTERNS = /* @__PURE__ */ new Map();
+for (const keywords of Object.values(DOMAIN_KEYWORD_WEIGHTS)) {
+  for (const [keyword] of keywords) {
+    if (/^[a-zA-Z0-9_-]+$/.test(keyword) && !LATIN_KEYWORD_PATTERNS.has(keyword)) {
+      LATIN_KEYWORD_PATTERNS.set(
+        keyword,
+        new RegExp(
+          `\\b${keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`,
+          "iu"
+        )
+      );
+    }
+  }
+}
+function matchKeyword(text, keyword) {
+  const pattern = LATIN_KEYWORD_PATTERNS.get(keyword);
+  if (pattern) return pattern.test(text);
+  return text.includes(keyword);
+}
+function scoreDomain(text, keywords) {
+  let maxScore = 0;
+  for (const [keyword, weight] of keywords) {
+    if (matchKeyword(text, keyword)) {
+      maxScore = Math.max(maxScore, weight);
+    }
+  }
+  return maxScore;
+}
+function classifyTaskKind(userText, capabilityPlan = createEmptyCapabilityPlan(), input) {
+  const scores = [];
+  for (const [domain, keywords] of Object.entries(DOMAIN_KEYWORD_WEIGHTS)) {
+    scores.push({
+      kind: domain,
+      score: scoreDomain(userText, keywords)
+    });
+  }
+  scores.push({
+    kind: "capability",
+    score: capabilityPlan.route === "capability" ? 15 : 0
+  });
+  scores.push({ kind: "chat", score: 5 });
+  scores.sort((a, b) => b.score - a.score);
+  const dominant = scores[0];
+  const secondaries = [];
+  const reasons = [];
+  const consecutiveFailures = input?.consecutiveFailures ?? 0;
+  const lastVerificationStatus = input?.lastVerificationStatus;
+  const failureLearning = input?.failureLearning;
+  if (consecutiveFailures >= 2 && dominant.kind === "edit") {
+    reasons.push("\u8FDE\u7EED\u5931\u8D25\u540E\u5F3A\u5236\u6E90\u7801\u4F18\u5148");
+  }
+  if (lastVerificationStatus === "fail") {
+    if (!secondaries.includes("verification")) {
+      secondaries.push("verification");
+    }
+    reasons.push("\u4E0A\u8F6E\u9A8C\u8BC1\u5931\u8D25");
+  }
+  if (input?.hasActiveProviderFailure) {
+    reasons.push("provider \u5386\u53F2\u5931\u8D25\uFF0C\u907F\u514D\u91CD\u538B\u529B\u64CD\u4F5C");
+  }
+  let primary;
+  if (consecutiveFailures >= 2 && dominant.kind === "edit") {
+    primary = "code_fact";
+  } else {
+    primary = dominant.kind;
+  }
+  const intentUnclear = scores.every((s) => s.score < 10);
+  if (intentUnclear && reasons.length === 0) {
+    reasons.push("\u610F\u56FE\u6A21\u7CCA\uFF0C\u5EFA\u8BAE\u6A21\u578B\u5148\u6F84\u6E05");
+  }
+  const primaryScore = primary === "code_fact" && dominant.kind === "edit" ? dominant.score : scores.find((s) => s.kind === primary)?.score ?? 0;
+  for (const s of scores) {
+    if (s.kind === primary) continue;
+    if (s.score >= primaryScore * 0.6 && s.score > 0) {
+      if (!secondaries.includes(s.kind)) {
+        secondaries.push(s.kind);
+      }
+    }
+  }
+  return {
+    primary: intentUnclear ? "chat" : primary,
+    secondaries,
+    intentUnclear,
+    reason: reasons.join("; ")
+  };
+}
+function expectsMutatingAction(userText, taskKind, capabilityPlan = createEmptyCapabilityPlan()) {
+  return taskKind === "edit" || taskKind === "capability" && capabilityPlan.permission !== "read" || /(?:写入|修改|更新|新增|删除|创建|实现|修复|提交|commit|write|edit|modify|update|delete|create|implement|fix)/iu.test(
+    userText
+  );
+}
+function createCapabilityPlan(userText) {
+  const text = userText.trim();
+  if (!text) return createEmptyCapabilityPlan();
+  const mentionsWorkflowAgentOrJob = /(?:智能体|子智能体|\bagent\b|\bfork\b|multi-agent|多开|工作流|\bworkflow\b|\bjob\b|流水线|后台|background|scheduler|调度)/iu.test(
+    text
+  );
+  if (mentionsWorkflowAgentOrJob) return createEmptyCapabilityPlan();
+  const explicitCapability = /(?:\bcapabilit(?:y|ies)\b|能力运行时|外部能力|app bridge|应用桥|应用连接|connector|插件能力|plugin capability)/iu.test(
+    text
+  );
+  const externalApp = /(?:外部软件|外部应用|连接应用|连接软件|第三方软件|第三方应用|desktop bridge|本地应用|画布|画图|表格|spreadsheet|canvas|external app|connect app|app connector|plugin|插件|mcp|http connector|websocket)/iu.test(
+    text
+  );
+  if (!explicitCapability && !externalApp) return createEmptyCapabilityPlan();
+  const readOnly = /(?:列表|查看|读取|查询|list|doctor|status|read|inspect|show)/iu.test(text);
+  const artifact = /(?:导出|export|artifact|文件|保存|save|生成|create|创建|画图|画布|canvas)/iu.test(text);
+  const permission = readOnly && !artifact ? "read" : externalApp ? "external_app" : "write";
+  return {
+    route: "capability",
+    reason: explicitCapability ? "explicit_capability" : "external_app",
+    candidateIds: externalApp ? ["mock.canvas.create", "mock.canvas.export"] : ["mock.echo.read"],
+    permission,
+    riskLevel: permission === "read" ? "low" : "medium"
+  };
+}
+function createEmptyCapabilityPlan() {
+  return {
+    route: "none",
+    reason: "none",
+    candidateIds: [],
+    permission: "read",
+    riskLevel: "low"
+  };
+}
+function classifyVerificationDomain(userText, taskKind, expectedMutating) {
+  if (taskKind === "capability") {
+    return "agent_job_workflow";
+  }
+  if (/(?:provider|model|模型|供应商|baseUrl|api[_-]?key|\bkey\b|env|环境变量|config|配置|doctor|route|路由)/iu.test(
+    userText
+  )) {
+    return "provider_model_config";
+  }
+  if (/(?:文档|markdown|frontmatter|link|链接|README|docs?\/|\.md\b|交付文档|delivery)/iu.test(
+    userText
+  )) {
+    return "documentation";
+  }
+  if (/(?:\btui\b.*(?:交互|ui|render|renderer|keyboard|hotkey|面板)|terminal|终端|交互|\bink\b|render|renderer|keyboard|hotkey|快捷键|面板)/iu.test(
+    userText
+  )) {
+    return "tui_interactive";
+  }
+  if (/(?:智能体|子智能体|\bagent\b|\bfork\b|\bjob\b|workflow|工作流|后台|background|scheduler|调度)/iu.test(
+    userText
+  )) {
+    return "agent_job_workflow";
+  }
+  if (taskKind === "edit" || expectedMutating || /(?:代码|源码|ts|tsx|js|jsx|test|typecheck|lint|build|diff|实现|修复)/iu.test(userText)) {
+    return "code_change";
+  }
+  return "general";
+}
+function shouldSurfaceWindowsSafeHint(input) {
+  if (input.expectedMutating || input.taskKind === "verification") return true;
+  if (input.taskKind === "workflow" || input.taskKind === "agent") return true;
+  if (input.blockedRuntime || input.toolFailure || input.providerFailure) return true;
+  if (input.providerCooldownBlocked) return true;
+  return /(?:\bbash\b|\bshell\b|\bcmd\b|powershell|pwsh|terminal|命令行|终端|命令|路径|执行(?:命令|脚本|测试|验证)|运行(?:命令|脚本|测试|验证)|\bpath\b|\bcommand\b|\bexecute\b|\bpnpm\b|\bnpm\b|\bnpx\b|\bnode\b|\bpython\b|\bgit\b|\brun\b\s+(?:test|build|lint|script|command|shell|bash|pnpm|npm|npx|node|python|git))/iu.test(
+    input.userText
+  );
+}
+function hasActiveFailureLearning(state) {
+  return state.records.some(
+    (record) => record.status === "active" && record.projectScope === state.projectScope
+  );
+}
+function hasActiveProviderFailure(state) {
+  return state.records.some(
+    (record) => record.status === "active" && record.category === "provider_failure" && record.projectScope === state.projectScope
+  );
+}
+function shouldPreferSourceFirst(taskKind, indexStrategy) {
+  if (taskKind === "code_fact" || taskKind === "edit" || taskKind === "verification") return true;
+  if (taskKind === "capability") return false;
+  return indexStrategy !== "ready" && taskKind !== "chat";
+}
+function classifyRiskLevel(input) {
+  if (input.highRiskClaim || input.blockedRuntime || input.userStateDecision.kind === "high_stakes_release") {
+    return "high";
+  }
+  if (input.expectedMutating || input.providerFailure || input.toolFailure || input.pressure) {
+    return "medium";
+  }
+  if (input.userStateDecision.kind === "frustrated" || input.userStateDecision.kind === "trust_repair") {
+    return "medium";
+  }
+  return "low";
+}
+function summarizeFailureSignal(state) {
+  const active = state.records.filter(
+    (record) => record.status === "active" && record.projectScope === state.projectScope
+  );
+  const categories = [...new Set(active.map((record) => record.category))].sort();
+  return {
+    activeCount: active.length,
+    highSeverityCount: active.filter((record) => record.severity === "high").length,
+    mediumSeverityCount: active.filter((record) => record.severity === "medium").length,
+    categories
+  };
+}
+function createVerificationRoute(input) {
+  const commands = applyUserStateVerificationCommands(
+    verificationCommandsForDomain(input.domain),
+    input.userStateDecision
+  );
+  const noPassReasons = collectNoPassReasons(input);
+  return {
+    domain: input.domain,
+    commands,
+    evidenceFreshness: input.evidenceFreshness,
+    conservativeNoPass: noPassReasons.length > 0,
+    noPassReasons
+  };
+}
+function verificationCommandsForDomain(domain) {
+  if (domain === "documentation") {
+    return ["markdown", "link", "frontmatter", "sensitive-path", "consistency"];
+  }
+  if (domain === "tui_interactive") {
+    return ["focused-tui-tests", "build", "cli-smoke"];
+  }
+  if (domain === "provider_model_config") {
+    return ["doctor", "provider-smoke", "config-isolation"];
+  }
+  if (domain === "agent_job_workflow") {
+    return [
+      "background-state",
+      "job-state",
+      "agent-state",
+      "workflow-state",
+      "no-pass-without-verification"
+    ];
+  }
+  if (domain === "code_change") {
+    return ["typecheck", "test", "lint", "build", "diff"];
+  }
+  return ["focused-verification"];
+}
+function applyUserStateVerificationCommands(commands, decision) {
+  const next = [...commands];
+  if (decision.verificationPlan.requireSourceFacts) {
+    next.unshift("source-facts");
+  }
+  if (decision.verificationPlan.requireDirtyTreeCheck) {
+    next.push("dirty-tree");
+    next.push("untracked-files");
+  }
+  if (decision.verificationPlan.requireFocusedTests) {
+    next.push("focused-test");
+  }
+  if (decision.verificationPlan.requireBuild) {
+    next.push("build");
+  }
+  if (decision.verificationPlan.requireStabilityBoundary) {
+    next.push("stability-boundary");
+  }
+  return [...new Set(next)];
+}
+function collectNoPassReasons(input) {
+  const reasons = [];
+  if (input.domain !== "general" && input.evidenceFreshness !== "fresh") {
+    reasons.push(`evidence:${input.evidenceFreshness}`);
+  }
+  if (input.userStateDecision.verificationPlan.forbidEarlyPass) {
+    reasons.push(`user_state:${input.userStateDecision.kind}`);
+  }
+  if (input.lastStatus && input.lastStatus !== "pass") {
+    reasons.push(`verification:${input.lastStatus}`);
+  }
+  if (input.blockedRuntime || input.runtimeSignal.noPassStates.length > 0) {
+    reasons.push(...input.runtimeSignal.noPassStates);
+  }
+  if (input.runtimeSignal.completedWithoutFreshVerification) {
+    reasons.push("completed_without_fresh_verification");
+  }
+  if (input.failureSignal.activeCount > 0) {
+    reasons.push("active_failure_learning");
+  }
+  if (input.resourceCapPressure) {
+    reasons.push("resource_guard_pressure");
+  }
+  return [...new Set(reasons)];
+}
+function formatVerificationRouteDirective(route) {
+  const noPass = route.conservativeNoPass ? ` conservative-no-pass=${route.noPassReasons.join(",")}` : " conservative-no-pass=no";
+  return `Verification route: domain=${route.domain}; commands=${route.commands.join("+")}; evidence=${route.evidenceFreshness};${noPass}.`;
+}
+function formatUserStateDirective(decision) {
+  return `UserStateDecision: kind=${decision.kind}; confidence=${decision.confidence.toFixed(2)}; interaction=${decision.interactionPlan.route}; verification=${decision.verificationPlan.strength}; detail=${decision.detailPlan.style}; notification=${decision.notificationPlan.quiet ? "quiet" : "normal"}; memoryCandidate=${decision.memoryCandidate.shouldCreate ? "candidate_only" : "none"}.`;
+}
+function appendUserStateInternalEvents(events, decision) {
+  if (decision.kind === "neutral") return;
+  events.push(`user_state_decision:${decision.kind}`);
+  if (decision.verificationPlan.forbidEarlyPass) {
+    events.push("user_state:forbid_early_pass");
+  }
+  if (!decision.interactionPlan.allowImplementationPush) {
+    events.push("user_state:no_implementation_push");
+  }
+}
+function classifyVerificationLevel(input) {
+  if (input.userStateDecision.verificationPlan.strength === "release") return "full";
+  if (input.userStateDecision.verificationPlan.strength === "strengthened") return "full";
+  if (input.highRiskClaim || input.blockedRuntime) return "full";
+  if (input.lastStatus === "fail" || input.lastStatus === "timeout" || input.lastStatus === "stale") {
+    return "full";
+  }
+  if (input.lastStatus === "partial" || input.lastStatus === "cancelled" || input.lastStatus === "skipped") {
+    return "focused";
+  }
+  if (input.expectedMutating || input.taskKind === "verification") return "focused";
+  return "basic";
+}
+function isRiskyVerificationStatus(status) {
+  return status === "fail" || status === "partial" || status === "stale" || status === "cancelled" || status === "timeout";
+}
+function summarizeRuntimeSignal(input, evidenceFreshness) {
+  let runningAgents = 0;
+  let runningJobs = 0;
+  const agentStates = {
+    running: 0,
+    completed: 0,
+    blocked: 0,
+    stale: 0,
+    cancelled: 0,
+    timeout: 0
+  };
+  const jobStates = {
+    running: 0,
+    completed: 0,
+    blocked: 0,
+    stale: 0,
+    cancelled: 0,
+    timeout: 0
+  };
+  const noPassReasonSet = /* @__PURE__ */ new Set();
+  for (const task of input.backgroundTasks) {
+    const isAgent = task.kind === "agent";
+    const isJob = task.kind === "job";
+    if (!isAgent && !isJob) continue;
+    if (isAgent && task.status === "running") runningAgents++;
+    if (isJob && task.status === "running") runningJobs++;
+    if (isAgent && task.status in agentStates) {
+      agentStates[task.status] += 1;
+    }
+    if (isJob && task.status in jobStates) {
+      jobStates[task.status] += 1;
+    }
+    if (task.status === "blocked" || task.status === "stale" || task.status === "cancelled" || task.status === "timeout") {
+      noPassReasonSet.add(`${task.kind}:${task.status}`);
+    }
+    if (task.result === "stale" || task.result === "cancelled" || task.result === "timeout") {
+      noPassReasonSet.add(`${task.kind}:${task.result}`);
+    }
+    if (task.status === "completed" && task.result !== "pass") {
+      noPassReasonSet.add(`${task.kind}:completed_not_pass`);
+    }
+  }
+  if (input.workflow?.status === "blocked" || input.workflow?.status === "stale" || input.workflow?.status === "cancelled") {
+    noPassReasonSet.add(`workflow:${input.workflow.status}`);
+  }
+  if (input.workflow?.status === "completed") {
+    noPassReasonSet.add("workflow:completed_not_pass");
+  }
+  for (const step of input.workflow?.steps ?? []) {
+    if (step.status === "blocked" || step.status === "stale" || step.status === "cancelled") {
+      noPassReasonSet.add(`workflow_step:${step.status}`);
+    }
+  }
+  runningAgents = input.activeAgentCount ?? runningAgents;
+  runningJobs = input.activeJobCount ?? runningJobs;
+  const workflowStatus = input.activeWorkflowStatus ?? normalizeWorkflowRuntimeStatus(input.workflow?.status, input.workflow?.steps);
+  const completedWithoutFreshVerification = evidenceFreshness !== "fresh" && (agentStates.completed > 0 || jobStates.completed > 0 || input.workflow?.status === "completed");
+  return {
+    runningAgents,
+    runningJobs,
+    ...workflowStatus ? { workflowStatus } : {},
+    agentStates,
+    jobStates,
+    completedWithoutFreshVerification,
+    noPassStates: [...noPassReasonSet],
+    resourceCapPressure: runningAgents > 0 || runningJobs > 0
+  };
+}
+function normalizeWorkflowRuntimeStatus(status, steps) {
+  if (status === "blocked") return "blocked";
+  if (status === "running") return "running";
+  if (steps?.some((step) => step.status === "stale")) return "stale";
+  if (steps?.some((step) => step.status === "blocked")) return "blocked";
+  return void 0;
+}
+function createPolicyDecision(input) {
+  const hints = [];
+  if (input.userState.kind === "frustrated" || input.userState.kind === "trust_repair" || input.userState.kind === "high_stakes_release") {
+    hints.push({
+      id: `user-state-${input.userState.kind}`,
+      severity: input.userState.kind === "high_stakes_release" ? "warning" : "info",
+      text: {
+        "zh-CN": input.userState.kind === "high_stakes_release" ? "\u7B56\u7565\uFF1A\u53D1\u5E03\u98CE\u9669\u8F83\u9AD8\uFF0C\u5148\u505A\u5DE5\u4F5C\u6811\u3001\u6784\u5EFA\u548C\u9A8C\u8BC1\u8FB9\u754C\u68C0\u67E5\u3002" : "\u7B56\u7565\uFF1A\u5148\u6838\u5BF9\u6E90\u7801\u4E8B\u5B9E\uFF0C\u518D\u7ED9\u7ED3\u8BBA\u3002",
+        "en-US": input.userState.kind === "high_stakes_release" ? "Strategy: release risk is high; checking worktree, build, and verification boundaries first." : "Strategy: checking source facts before conclusions."
+      }
+    });
+  }
+  if (input.userState.kind === "decisive_command") {
+    hints.push({
+      id: "user-state-command-first",
+      severity: "info",
+      text: {
+        "zh-CN": "\u7B56\u7565\uFF1A\u547D\u4EE4\u4F18\u5148\uFF0C\u51CF\u5C11\u80CC\u666F\u89E3\u91CA\u3002",
+        "en-US": "Strategy: command-first; reducing background explanation."
+      }
+    });
+  }
+  if (input.userState.kind === "confused") {
+    hints.push({
+      id: "user-state-explain-first",
+      severity: "info",
+      text: {
+        "zh-CN": "\u7B56\u7565\uFF1A\u5148\u89E3\u91CA\uFF0C\u4E0D\u76F4\u63A5\u63A8\u8FDB\u5B9E\u73B0\u3002",
+        "en-US": "Strategy: explain-first; not pushing implementation yet."
+      }
+    });
+  }
+  if (input.userState.kind === "strategic_exploration") {
+    hints.push({
+      id: "user-state-discussion-only",
+      severity: "info",
+      text: {
+        "zh-CN": "\u7B56\u7565\uFF1A\u4FDD\u6301\u8BA8\u8BBA\u548C\u67B6\u6784\u5224\u65AD\uFF0C\u4E0D\u542F\u52A8\u4EE3\u7801\u6267\u884C\u3002",
+        "en-US": "Strategy: staying in discussion/architecture judgment; no code execution route."
+      }
+    });
+  }
+  if (input.permissionSignal.requireExplicitGate) {
+    hints.push({
+      id: "permission-risk",
+      severity: "warning",
+      text: {
+        "zh-CN": "\u7B56\u7565\uFF1A\u68C0\u6D4B\u5230\u6743\u9650\u98CE\u9669\uFF0C\u5199\u5165\u524D\u4F1A\u8BF7\u6C42\u786E\u8BA4\u3002",
+        "en-US": "Strategy: permission risk detected; write actions will ask before running."
+      }
+    });
+  }
+  if (input.platformSignal.windowsSafeHint && input.surfaceWindowsSafeHint) {
+    hints.push({
+      id: "windows-safe",
+      severity: "info",
+      text: {
+        "zh-CN": "\u7B56\u7565\uFF1AWindows \u73AF\u5883\uFF0C\u4F18\u5148\u4F7F\u7528\u517C\u5BB9\u547D\u4EE4\u3002",
+        "en-US": "Strategy: Windows environment; using compatible commands first."
+      }
+    });
+  }
+  if (input.preferSourceFirst) {
+    hints.push({
+      id: "source-first",
+      severity: "info",
+      text: {
+        "zh-CN": "\u7B56\u7565\uFF1A\u6E90\u7801\u4F18\u5148\uFF0C\u5148\u8BFB\u53D6\u5173\u952E\u6587\u4EF6\u3002",
+        "en-US": "Strategy: source-first; reading key files before answering."
+      }
+    });
+  }
+  if (input.requireVerification) {
+    hints.push({
+      id: "verification-required",
+      severity: input.riskLevel === "high" ? "warning" : "info",
+      text: {
+        "zh-CN": input.verificationSignal.recommendedLevel === "focused" ? "\u7B56\u7565\uFF1A\u5EFA\u8BAE\u5148\u505A focused verification\u3002" : "\u7B56\u7565\uFF1A\u9AD8\u98CE\u9669\u7ED3\u8BBA\u9700\u8981\u9A8C\u8BC1\u540E\u518D\u8BF4\u901A\u8FC7\u3002",
+        "en-US": input.verificationSignal.recommendedLevel === "focused" ? "Strategy: focused verification is recommended before completion." : "Strategy: high-risk claims need verification before PASS."
+      }
+    });
+  }
+  if (input.architectureSignal.guardReminder) {
+    hints.push({
+      id: "architecture-guard",
+      severity: "warning",
+      text: {
+        "zh-CN": "\u7B56\u7565\uFF1A\u5DF2\u6709\u67B6\u6784\u5361\u7247\uFF0C\u5199\u5165\u4F1A\u7EE7\u7EED\u8D70\u67B6\u6784\u8FB9\u754C\u68C0\u67E5\u3002",
+        "en-US": "Strategy: architecture card is active; edits keep architecture guard checks."
+      }
+    });
+  }
+  if (input.compactBeforeProvider) {
+    hints.push({
+      id: "compact-before-provider",
+      severity: "warning",
+      text: {
+        "zh-CN": "\u7B56\u7565\uFF1A\u4E0A\u4E0B\u6587\u63A5\u8FD1\u4E0A\u9650\uFF0C\u5148\u538B\u7F29\u518D\u8BF7\u6C42\u6A21\u578B\u3002",
+        "en-US": "Strategy: context is near limit; compacting before provider request."
+      }
+    });
+  }
+  if (input.blockedRuntime) {
+    hints.push({
+      id: "blocked-runtime",
+      severity: "warning",
+      text: {
+        "zh-CN": "\u7B56\u7565\uFF1A\u5DF2\u6709\u4EFB\u52A1\u963B\u585E\uFF0C\u5148\u68C0\u67E5 workflow/agent \u72B6\u6001\u3002",
+        "en-US": "Strategy: blocked runtime detected; checking workflow/agent state first."
+      }
+    });
+  }
+  if (input.runtimeSignal.resourceCapPressure) {
+    hints.push({
+      id: "background-occupancy",
+      severity: "info",
+      text: {
+        "zh-CN": "\u7B56\u7565\uFF1A\u5DF2\u6709\u540E\u53F0 agent/job \u5360\u7528\uFF0C\u5148\u907F\u514D\u91CD\u590D\u542F\u52A8\u3002",
+        "en-US": "Strategy: background agent/job is already running; avoiding duplicate starts."
+      }
+    });
+  }
+  if (input.capabilityPlan.route === "capability") {
+    hints.push({
+      id: "capability-route",
+      severity: input.capabilityPlan.riskLevel === "high" ? "warning" : "info",
+      text: {
+        "zh-CN": "\u7B56\u7565\uFF1A\u8BC6\u522B\u4E3A capability \u5019\u9009\uFF1B\u6267\u884C\u4ECD\u8D70\u663E\u5F0F\u547D\u4EE4\u548C\u6743\u9650\u8FB9\u754C\u3002",
+        "en-US": "Strategy: capability candidate detected; execution still uses explicit commands and permission gates."
+      }
+    });
+  }
+  if (input.providerPlan === "fallbackCandidate") {
+    hints.push({
+      id: "provider-fallback",
+      severity: "warning",
+      text: {
+        "zh-CN": "\u7B56\u7565\uFF1AProvider \u6700\u8FD1\u5931\u8D25\uFF0C\u51C6\u5907 fallback \u5019\u9009\u3002",
+        "en-US": "Strategy: provider failure detected; keeping fallback candidate ready."
+      }
+    });
+  }
+  if (input.providerPlan === "cooldownBlocked") {
+    hints.push({
+      id: "provider-cooldown",
+      severity: "warning",
+      text: {
+        "zh-CN": "\u7B56\u7565\uFF1AProvider \u51B7\u5374\u4E2D\uFF0C\u6682\u505C\u672C\u8F6E\u8BF7\u6C42\u3002",
+        "en-US": "Strategy: provider cooldown is active; pausing this request."
+      }
+    });
+  }
+  if (input.includeFailureLearning || input.toolFailure || input.providerFailure) {
+    hints.push({
+      id: "failure-learning",
+      severity: input.riskLevel === "high" ? "warning" : "info",
+      text: {
+        "zh-CN": "\u7B56\u7565\uFF1A\u53C2\u8003\u5386\u53F2\u5931\u8D25\uFF0C\u53EA\u4F5C\u4E3A\u98CE\u9669\u63D0\u793A\u3002",
+        "en-US": "Strategy: using failure lessons as risk hints only."
+      }
+    });
+  }
+  if (input.includeMemory) {
+    hints.push({
+      id: "memory",
+      severity: "info",
+      text: {
+        "zh-CN": "\u7B56\u7565\uFF1A\u5E26\u5165\u5DF2\u63A5\u53D7\u8BB0\u5FC6\u4F5C\u4E3A\u7EA6\u675F\u3002",
+        "en-US": "Strategy: using accepted memory as constraints."
+      }
+    });
+  }
+  return {
+    taskKind: input.taskKind,
+    riskLevel: input.riskLevel,
+    permissionSignal: input.permissionSignal,
+    modelRouteSignal: input.modelRouteSignal,
+    verificationSignal: input.verificationSignal,
+    memorySignal: input.memorySignal,
+    failureSignal: input.failureSignal,
+    architectureSignal: input.architectureSignal,
+    platformSignal: input.platformSignal,
+    budgetSignal: input.budgetSignal,
+    capabilitySignal: {
+      active: input.capabilityPlan.route === "capability",
+      reason: input.capabilityPlan.reason,
+      candidateIds: input.capabilityPlan.candidateIds,
+      permission: input.capabilityPlan.permission,
+      riskLevel: input.capabilityPlan.riskLevel
+    },
+    capabilityPlan: input.capabilityPlan,
+    runtimeSignal: input.runtimeSignal,
+    userState: input.userState,
+    contextPlan: {
+      includeMemory: input.includeMemory,
+      includeFailureLearning: input.includeFailureLearning,
+      compactBeforeProvider: input.compactBeforeProvider
+    },
+    executionPlan: {
+      preferSourceFirst: input.preferSourceFirst,
+      preferWorkflow: input.preferWorkflow,
+      preferAgent: input.preferAgent,
+      requireVerification: input.requireVerification,
+      requireFinalGate: input.requireFinalGate
+    },
+    permissionPlan: {
+      expectedMutating: input.expectedMutating,
+      requireExplicitGate: input.requireExplicitGate
+    },
+    providerPlan: input.providerPlan,
+    hints,
+    userStatePersistence: input.userStatePersistence
+  };
+}
+function classifyVerificationEvidenceFreshness(evidence, nowMs = Date.now()) {
+  const passEvidence = evidence.filter(
+    (item) => item.supportsClaims.some(
+      (claim) => /^(?:verification_passed|test_passed|typecheck_passed|build_passed|lint_passed|diff_check_passed|smoke_passed)$/u.test(
+        claim
+      )
+    )
+  );
+  if (passEvidence.length === 0) return "missing";
+  const freshWindowMs = 30 * 60 * 1e3;
+  return passEvidence.some((item) => {
+    const createdAt = Date.parse(item.createdAt);
+    return Number.isFinite(createdAt) && nowMs - createdAt <= freshWindowMs;
+  }) ? "fresh" : "stale";
+}
+function computeContextPressure(messages, estimatedContextChars, contextMaxChars, triggerChars) {
+  if (!contextMaxChars || !triggerChars) return { shouldCompact: false };
+  const chars = estimatedContextChars ?? (messages ? estimateModelMessageChars(messages) : 0);
+  return { shouldCompact: chars > Math.min(contextMaxChars, triggerChars) };
+}
+function classifyIndexStrategy(index) {
+  if (!index.enabled || index.status === "disabled") return "disabled";
+  if (index.status === "ready" || index.status === "indexing") return "ready";
+  if (index.status === "stale") return "stale";
+  if (index.status === "unknown-project") return "unknown-project";
+  if (index.status === "missing") return "missing";
+  if (index.status === "error") return "error";
+  return index.projectName ? "stale" : "unknown-project";
+}
+function formatIndexStrategyDirective(strategy, index) {
+  const project = index.projectName ? ` project=${index.projectName}` : "";
+  if (strategy === "ready") {
+    return `Index strategy:${project} ready/indexing; use index as a locator, then confirm with source before editing or claiming facts.`;
+  }
+  if (strategy === "stale") {
+    return `Index strategy:${project} stale/unknown; prefer refresh or source confirmation before relying on index facts.`;
+  }
+  if (strategy === "unknown-project") {
+    return "Index strategy: unknown project; do not treat index facts as ready, use direct source reads or ask for index repair.";
+  }
+  if (strategy === "disabled") {
+    return "Index strategy: disabled; rely on direct source reads and local search.";
+  }
+  if (strategy === "missing") {
+    return "Index strategy: missing; use direct source reads/local search and suggest /index init fast only when useful.";
+  }
+  return "Index strategy: error; use direct source reads/local search and surface a short degraded index action.";
+}
+function hasActiveBlockedWorkflow(workflow) {
+  if (workflow?.status === "blocked") return !workflow.endedAt;
+  if (workflow?.status === "running" && workflow.steps.some((step) => step.status === "blocked" || step.status === "stale")) {
+    return true;
+  }
+  return false;
+}
+
+export {
+  evaluateMetaScheduler,
+  formatMetaSchedulerDirective,
+  formatPolicyDecisionSummary,
+  verifyFailureLearningContract,
+  hasActiveProviderFailure
+};