@ljwei-stak/model-router-galgame 0.4.10 → 0.4.14

package/.dsh-plugin/client.js

@@ -59760,7 +59760,7 @@ var OBJECTIVE_WEIGHTS = Object.freeze({
   balanced: Object.freeze({ quality: 0.45, cost: 0.3, latency: 0.1, specialty: 0.1, risk: 0.05 }),
   complex: Object.freeze({ quality: 0.55, cost: 0.16, latency: 0.06, specialty: 0.16, risk: 0.07 })
 });
-var QUALITY_FLOORS = Object.freeze({ simple: 0.64, balanced: 0.72, complex: 0.78 });
+var QUALITY_FLOORS = Object.freeze({ simple: 0.75, balanced: 0.78, complex: 0.82 });
 var MODEL_ROUTER_SETTINGS_NAMESPACE = "model-router";
 var DEFAULT_ROUTER_SETTINGS = Object.freeze({
   pricing: Object.freeze({}),
@@ -59958,48 +59958,176 @@ function taskQualityFloor(band, task) {
 }
 function taskPackages(taskType, text6, band) {
   if (band !== "complex") {
-    const task = { name: "\u76F4\u63A5\u56DE\u7B54\u4E0E\u5FC5\u8981\u6821\u9A8C", type: taskType, purpose: "execution", criticality: 0.65 };
+    const task = { id: "execution", name: "\u76F4\u63A5\u56DE\u7B54\u4E0E\u5FC5\u8981\u6821\u9A8C", type: taskType, purpose: "execution", criticality: 0.65, dependsOn: [] };
     return [{ ...task, qualityFloor: taskQualityFloor(band, task) }];
   }
   const value = String(text6 ?? "");
   const packages = [
-    { name: "\u95EE\u9898\u5EFA\u6A21\u4E0E\u7EA6\u675F\u63D0\u53D6", type: "reasoning", purpose: "analysis", criticality: 0.92 }
+    { id: "analysis", name: "\u95EE\u9898\u5EFA\u6A21\u4E0E\u7EA6\u675F\u63D0\u53D6", type: "reasoning", purpose: "analysis", criticality: 0.92, dependsOn: [] }
   ];
   const domains = [...new Set([...detectTaskTypes(text6), taskType].filter((type) => type !== "general"))];
   for (const type of domains.length > 0 ? domains : [taskType]) {
     packages.push({
+      id: `execution-${type}`,
       name: `${TASK_TYPE_LABELS[type] ?? type}\u65B9\u5411\u5904\u7406`,
       type,
       purpose: "execution",
-      criticality: domains.length > 1 ? 0.8 : 0.78
+      criticality: domains.length > 1 ? 0.8 : 0.78,
+      dependsOn: ["analysis"]
     });
   }
   if (/(测试|验证|评估|对比|benchmark|test|verify|audit)/i.test(value)) {
-    packages.push({ name: "\u9A8C\u8BC1\u3001\u53CD\u4F8B\u4E0E\u98CE\u9669\u5BA1\u67E5", type: "reasoning", purpose: "verification", criticality: 0.88 });
+    packages.push({
+      id: "verification",
+      name: "\u9A8C\u8BC1\u3001\u53CD\u4F8B\u4E0E\u98CE\u9669\u5BA1\u67E5",
+      type: "reasoning",
+      purpose: "verification",
+      criticality: 0.88,
+      dependsOn: packages.filter((task) => task.purpose === "execution").map((task) => task.id)
+    });
   }
-  packages.push({ name: "\u7ED3\u679C\u6821\u9A8C\u4E0E\u6574\u5408", type: "reasoning", purpose: "synthesis", criticality: 1 });
+  packages.push({
+    id: "synthesis",
+    name: "\u7ED3\u679C\u6821\u9A8C\u4E0E\u6574\u5408",
+    type: "reasoning",
+    purpose: "synthesis",
+    criticality: 1,
+    dependsOn: packages.filter((task) => task.purpose !== "analysis").map((task) => task.id)
+  });
   return packages.map((task) => ({ ...task, qualityFloor: taskQualityFloor(band, task) }));
 }
+var SYNTHESIS_WEIGHTS = Object.freeze({ quality: 0.7, cost: 0.1, latency: 0.04, specialty: 0.1, risk: 0.06 });
+var ROUTING_BEAM_WIDTH = 256;
+var ROUTING_CANDIDATE_LIMIT = 12;
+function weightsForTask(weights, task) {
+  return task.purpose === "synthesis" ? SYNTHESIS_WEIGHTS : weights;
+}
+function compareText(left, right) {
+  const a2 = String(left);
+  const b3 = String(right);
+  return a2 < b3 ? -1 : a2 > b3 ? 1 : 0;
+}
+function compareRowsStable(left, right) {
+  return compareText(routeKey(left.provider, left.model), routeKey(right.provider, right.model));
+}
 function candidateUtility(row, task, weights, maxCost, usedRoutes, cacheReadRatio = 0, cacheWriteRatio = 0) {
   const quality = qualityForTask(row, task.type);
   const floor = Number(task.qualityFloor ?? taskQualityFloor("complex", task));
   const qualityGap = Math.max(0, floor - quality);
   const duplicatePenalty = usedRoutes.has(routeKey(row.provider, row.model)) ? 0.08 : 0;
+  const synthesisPreference = task.purpose === "synthesis" && /deepseek[- ]?v4[- ]?pro/i.test(row.model) ? 0.025 : 0;
   const cost = costScore(row.pricing, maxCost, cacheReadRatio, cacheWriteRatio);
-  const score = weights.quality * quality + weights.cost * cost + weights.latency * (1 - clamp(row.latency)) + weights.specialty * specialtyForTask(row, task.type) - weights.risk * row.risk - duplicatePenalty - qualityGap * (task.criticality ?? 0.75);
+  const score = weights.quality * quality + weights.cost * cost + weights.latency * (1 - clamp(row.latency)) + weights.specialty * specialtyForTask(row, task.type) - weights.risk * row.risk - duplicatePenalty - qualityGap * (task.criticality ?? 0.75) + synthesisPreference;
   return { score, floor, qualityGap };
 }
-function chooseAssignment(rows, task, weights, maxCost, usedRoutes, preferred, cacheReadRatio = 0, cacheWriteRatio = 0) {
-  const ordered = rows.map((row) => ({ row, decision: candidateUtility(row, task, weights, maxCost, usedRoutes, cacheReadRatio, cacheWriteRatio) })).sort((left, right) => right.decision.score - left.decision.score);
-  const feasible = ordered.filter((item) => qualityForTask(item.row, task.type) >= item.decision.floor);
-  const chosen = (preferred === true ? feasible : feasible.filter((item) => !usedRoutes.has(routeKey(item.row.provider, item.row.model))))[0] ?? feasible[0] ?? ordered[0];
-  if (chosen === void 0) return { row: null, relaxed: true, floor: 0, qualityGap: 1 };
-  return { row: chosen.row, relaxed: qualityForTask(chosen.row, task.type) < chosen.decision.floor, floor: chosen.decision.floor, qualityGap: chosen.decision.qualityGap };
-}
 function taskCost(row, task, text6, complexity, cacheReadRatio = 0, cacheWriteRatio = 0) {
   const tokens = taskTokenBudget(text6, task, complexity, cacheReadRatio, cacheWriteRatio);
   return row === null ? 0 : ((tokens.inputTokens - tokens.cacheReadTokens - tokens.cacheWriteTokens) * row.pricing.input + tokens.cacheReadTokens * row.pricing.cacheRead + tokens.cacheWriteTokens * row.pricing.cacheWrite + tokens.outputTokens * row.pricing.output) / 1e6;
 }
+function dominates(left, right, task, text6, complexity, cacheReadRatio, cacheWriteRatio) {
+  const leftValues = {
+    quality: qualityForTask(left, task.type),
+    cost: taskCost(left, task, text6, complexity, cacheReadRatio, cacheWriteRatio),
+    latency: clamp(left.latency),
+    specialty: specialtyForTask(left, task.type),
+    risk: clamp(left.risk)
+  };
+  const rightValues = {
+    quality: qualityForTask(right, task.type),
+    cost: taskCost(right, task, text6, complexity, cacheReadRatio, cacheWriteRatio),
+    latency: clamp(right.latency),
+    specialty: specialtyForTask(right, task.type),
+    risk: clamp(right.risk)
+  };
+  const noWorse = leftValues.quality >= rightValues.quality && leftValues.cost <= rightValues.cost && leftValues.latency <= rightValues.latency && leftValues.specialty >= rightValues.specialty && leftValues.risk <= rightValues.risk;
+  const strictlyBetter = leftValues.quality > rightValues.quality || leftValues.cost < rightValues.cost || leftValues.latency < rightValues.latency || leftValues.specialty > rightValues.specialty || leftValues.risk < rightValues.risk;
+  return noWorse && strictlyBetter;
+}
+function candidatePool(rows, task, weights, maxCost, text6, complexity, cacheReadRatio, cacheWriteRatio) {
+  const floor = Number(task.qualityFloor ?? 0);
+  const feasible = rows.filter((row) => qualityForTask(row, task.type) >= floor);
+  const source = feasible.length > 0 ? feasible : rows.slice().sort((left, right) => qualityForTask(right, task.type) - qualityForTask(left, task.type) || compareRowsStable(left, right)).slice(0, 3);
+  const taskWeights = weightsForTask(weights, task);
+  const scored = source.map((row) => ({
+    row,
+    decision: candidateUtility(row, task, taskWeights, maxCost, /* @__PURE__ */ new Set(), cacheReadRatio, cacheWriteRatio),
+    cost: taskCost(row, task, text6, complexity, cacheReadRatio, cacheWriteRatio)
+  }));
+  const frontier = scored.filter((item) => !source.some((other) => other !== item.row && dominates(other, item.row, task, text6, complexity, cacheReadRatio, cacheWriteRatio)));
+  const essential = [
+    scored.slice().sort((left, right) => left.cost - right.cost || compareRowsStable(left.row, right.row))[0],
+    scored.slice().sort((left, right) => right.decision.score - left.decision.score || compareRowsStable(left.row, right.row))[0],
+    scored.slice().sort((left, right) => qualityForTask(right.row, task.type) - qualityForTask(left.row, task.type) || compareRowsStable(left.row, right.row))[0]
+  ].filter(Boolean);
+  const ordered = [...frontier, ...essential].filter((item, index2, all3) => all3.findIndex((candidate) => candidate.row === item.row) === index2).sort((left, right) => right.decision.score - left.decision.score || left.cost - right.cost || compareRowsStable(left.row, right.row)).slice(0, ROUTING_CANDIDATE_LIMIT);
+  return {
+    options: ordered,
+    relaxed: feasible.length === 0,
+    pruned: Math.max(0, rows.length - ordered.length)
+  };
+}
+function stateSignature(state) {
+  return state.assignments.map((assignment) => routeKey(assignment.row?.provider, assignment.row?.model)).join("|");
+}
+function compareUtilityStates(left, right) {
+  return left.relaxedCount - right.relaxedCount || left.qualityShortfall - right.qualityShortfall || right.score - left.score || left.cost - right.cost || left.switches - right.switches || compareText(stateSignature(left), stateSignature(right));
+}
+function compareCostStates(left, right) {
+  return left.relaxedCount - right.relaxedCount || left.qualityShortfall - right.qualityShortfall || left.cost - right.cost || right.score - left.score || left.switches - right.switches || compareText(stateSignature(left), stateSignature(right));
+}
+function solveAssignments({ rows, tasks, weights, maxCost, text: text6, complexity, budget, cacheReadRatio, cacheWriteRatio, minimizeCost = false }) {
+  const pools = tasks.map((task) => candidatePool(rows, task, weights, maxCost, text6, complexity, cacheReadRatio, cacheWriteRatio));
+  if (pools.some((pool) => pool.options.length === 0)) return null;
+  const suffixMinimum = Array(tasks.length + 1).fill(0);
+  for (let index2 = tasks.length - 1; index2 >= 0; index2 -= 1) {
+    suffixMinimum[index2] = suffixMinimum[index2 + 1] + Math.min(...pools[index2].options.map((option2) => option2.cost));
+  }
+  if (Number.isFinite(budget) && suffixMinimum[0] > budget + 1e-12) return null;
+  let states = [{ assignments: [], routesByTask: /* @__PURE__ */ new Map(), usedRoutes: /* @__PURE__ */ new Set(), score: 0, cost: 0, switches: 0, relaxedCount: 0, qualityShortfall: 0 }];
+  for (let index2 = 0; index2 < tasks.length; index2 += 1) {
+    const task = tasks[index2];
+    const pool = pools[index2];
+    const expanded = [];
+    for (const state of states) {
+      for (const option2 of pool.options) {
+        const nextCost = state.cost + option2.cost;
+        if (Number.isFinite(budget) && nextCost + suffixMinimum[index2 + 1] > budget + 1e-12) continue;
+        const taskWeights = weightsForTask(weights, task);
+        const decision = candidateUtility(option2.row, task, taskWeights, maxCost, state.usedRoutes, cacheReadRatio, cacheWriteRatio);
+        const route = routeKey(option2.row.provider, option2.row.model);
+        const dependencySwitches = (task.dependsOn ?? []).reduce((count, dependency) => {
+          const dependencyRoute = state.routesByTask.get(dependency);
+          return count + (dependencyRoute !== void 0 && dependencyRoute !== route ? 1 : 0);
+        }, 0);
+        const handoffPenalty = dependencySwitches * 0.015;
+        const qualityShortfall = Math.max(0, decision.floor - qualityForTask(option2.row, task.type));
+        const usedRoutes = new Set(state.usedRoutes);
+        usedRoutes.add(route);
+        const routesByTask = new Map(state.routesByTask);
+        routesByTask.set(task.id, route);
+        expanded.push({
+          assignments: [...state.assignments, { task, row: option2.row, decision: { ...decision, relaxed: qualityShortfall > 0 }, estimatedCost: option2.cost, handoffPenalty }],
+          routesByTask,
+          usedRoutes,
+          score: state.score + decision.score - handoffPenalty,
+          cost: nextCost,
+          switches: state.switches + dependencySwitches,
+          relaxedCount: state.relaxedCount + (qualityShortfall > 0 ? 1 : 0),
+          qualityShortfall: state.qualityShortfall + qualityShortfall
+        });
+      }
+    }
+    if (expanded.length === 0) return null;
+    expanded.sort(minimizeCost ? compareCostStates : compareUtilityStates);
+    states = expanded.slice(0, ROUTING_BEAM_WIDTH);
+  }
+  states.sort(minimizeCost ? compareCostStates : compareUtilityStates);
+  return {
+    ...states[0],
+    candidatePools: pools,
+    minimumFeasibleCost: suffixMinimum[0]
+  };
+}
 function buildPlan({ text: text6 = "", available = [], mode = "collective", pricing = {}, liveBench = null, liveBenchError = "", budgetUsd = 0, cacheReadRatio = 0, cacheWriteRatio = 0 } = {}) {
   const complexity = assessComplexity(text6);
   const taskType = classifyTask(text6);
@@ -60048,48 +60176,65 @@ function buildPlan({ text: text6 = "", available = [], mode = "collective", pric
     });
   }
   const taskNodes = taskPackages(taskType, text6, complexity.band);
-  const usedRoutes = /* @__PURE__ */ new Set();
-  let constraintRelaxed = false;
-  const assignments = [];
-  for (const task of taskNodes) {
-    const preferred = task.purpose === "synthesis" ? rows.find((row2) => /deepseek[- ]?v4[- ]?pro/i.test(row2.model)) ?? rows.find((row2) => /deepseek/i.test(row2.model)) : null;
-    const selectedAssignment = preferred === null ? chooseAssignment(rows, task, weights, maxCost, usedRoutes, false, cacheReadRatio, cacheWriteRatio) : { row: preferred, relaxed: qualityForTask(preferred, task.type) < task.qualityFloor, floor: task.qualityFloor, qualityGap: Math.max(0, task.qualityFloor - qualityForTask(preferred, task.type)) };
-    const row = selectedAssignment.row;
-    if (row !== null) {
-      row.score = candidateUtility(row, task, weights, maxCost, usedRoutes, cacheReadRatio, cacheWriteRatio).score;
-      usedRoutes.add(routeKey(row.provider, row.model));
-    }
-    constraintRelaxed || (constraintRelaxed = selectedAssignment.relaxed);
-    assignments.push({ task, row, decision: selectedAssignment });
-  }
   const budget = Number(budgetUsd);
-  const totalFor = () => assignments.reduce((sum, assignment) => sum + taskCost(assignment.row, assignment.task, text6, complexity.band, cacheReadRatio, cacheWriteRatio), 0);
-  if (budget > 0 && totalFor() > budget) {
-    const movable = assignments.filter((assignment) => assignment.task.purpose !== "synthesis").sort((left, right) => (left.task.criticality ?? 0) - (right.task.criticality ?? 0));
-    for (const assignment of movable) {
-      if (totalFor() <= budget) break;
-      const alternatives = rows.filter((row) => row !== assignment.row && qualityForTask(row, assignment.task.type) >= assignment.task.qualityFloor).sort((left, right) => taskCost(left, assignment.task, text6, complexity.band, cacheReadRatio, cacheWriteRatio) - taskCost(right, assignment.task, text6, complexity.band, cacheReadRatio, cacheWriteRatio));
-      const replacement = alternatives.find((row) => taskCost(row, assignment.task, text6, complexity.band, cacheReadRatio, cacheWriteRatio) < taskCost(assignment.row, assignment.task, text6, complexity.band, cacheReadRatio, cacheWriteRatio));
-      if (replacement !== void 0) assignment.row = replacement;
-    }
-  }
-  usedRoutes.clear();
-  for (const assignment of assignments) if (assignment.row !== null) usedRoutes.add(routeKey(assignment.row.provider, assignment.row.model));
-  rows.sort((a2, b3) => b3.score - a2.score);
+  const utilityPlan = solveAssignments({
+    rows,
+    tasks: taskNodes,
+    weights,
+    maxCost,
+    text: text6,
+    complexity: complexity.band,
+    budget: Number.POSITIVE_INFINITY,
+    cacheReadRatio,
+    cacheWriteRatio
+  });
+  const budgetPlan = budget > 0 ? solveAssignments({
+    rows,
+    tasks: taskNodes,
+    weights,
+    maxCost,
+    text: text6,
+    complexity: complexity.band,
+    budget,
+    cacheReadRatio,
+    cacheWriteRatio
+  }) : null;
+  const minimumCostPlan = budget > 0 && budgetPlan === null ? solveAssignments({
+    rows,
+    tasks: taskNodes,
+    weights,
+    maxCost,
+    text: text6,
+    complexity: complexity.band,
+    budget: Number.POSITIVE_INFINITY,
+    cacheReadRatio,
+    cacheWriteRatio,
+    minimizeCost: true
+  }) : null;
+  const optimized = budget > 0 ? budgetPlan ?? minimumCostPlan ?? utilityPlan : utilityPlan;
+  const assignments = optimized?.assignments ?? [];
+  const usedRoutes = optimized?.usedRoutes ?? /* @__PURE__ */ new Set();
+  const constraintRelaxed = (optimized?.relaxedCount ?? 0) > 0;
+  for (const row of rows) {
+    row.score = candidateUtility(row, taskNodes[0] ?? { type: taskType, qualityFloor: QUALITY_FLOORS[complexity.band] }, weights, maxCost, /* @__PURE__ */ new Set(), cacheReadRatio, cacheWriteRatio).score;
+  }
+  rows.sort((left, right) => right.score - left.score || compareRowsStable(left, right));
   const selected = assignments[0]?.row ?? rows[0] ?? null;
   const synthesizer = assignments.at(-1)?.row ?? rows.find((row) => /deepseek/i.test(row.model)) ?? rows[0];
   const subtasks = assignments.map(({ task, row }) => ({
+    id: task.id,
     name: task.name,
     type: task.type,
     recommended: row?.model ?? "\u5F85\u53D1\u73B0\u6A21\u578B",
     recommendedProvider: row?.provider ?? "",
     purpose: task.purpose,
     criticality: task.criticality,
-    qualityFloor: Number(task.qualityFloor.toFixed(3))
+    qualityFloor: Number(task.qualityFloor.toFixed(3)),
+    dependsOn: [...task.dependsOn ?? []]
   }));
-  const costBreakdown = assignments.map(({ task, row }, index2) => {
+  const costBreakdown = assignments.map(({ task, row, estimatedCost, handoffPenalty }, index2) => {
     const tokens = taskTokenBudget(text6, task, complexity.band, cacheReadRatio, cacheWriteRatio);
-    const estimatedCost = taskCost(row, task, text6, complexity.band, cacheReadRatio, cacheWriteRatio);
+    const taskEstimate = estimatedCost ?? taskCost(row, task, text6, complexity.band, cacheReadRatio, cacheWriteRatio);
     return {
       stage: index2 + 1,
       purpose: task.purpose,
@@ -60099,8 +60244,9 @@ function buildPlan({ text: text6 = "", available = [], mode = "collective", pric
       cacheReadTokens: tokens.cacheReadTokens,
       cacheWriteTokens: tokens.cacheWriteTokens,
       outputTokens: tokens.outputTokens,
-      estimatedCost: Number(estimatedCost.toFixed(6)),
-      quality: Number((row === null ? 0 : qualityForTask(row, task.type)).toFixed(3))
+      estimatedCost: Number(taskEstimate.toFixed(6)),
+      quality: Number((row === null ? 0 : qualityForTask(row, task.type)).toFixed(3)),
+      handoffPenalty: Number(Number(handoffPenalty ?? 0).toFixed(3))
     };
   });
   const totalEstimate = costBreakdown.reduce((sum, row) => sum + row.estimatedCost, 0);
@@ -60111,7 +60257,9 @@ function buildPlan({ text: text6 = "", available = [], mode = "collective", pric
   }, 0);
   const budgetExceeded = Number(budgetUsd) > 0 && totalEstimate > Number(budgetUsd);
   const savings = baselineCost <= 0 ? 0 : clamp((baselineCost - totalEstimate) / baselineCost);
-  const reason = selected === null ? "\u5C1A\u672A\u53D1\u73B0\u53EF\u7528\u6A21\u578B\uFF0C\u4FDD\u7559 Harness \u539F\u59CB\u6A21\u578B\u9009\u62E9\u3002" : `${complexity.band === "simple" ? "\u4F4E\u590D\u6742\u5EA6\u4F18\u5148\u6210\u672C\u4E0E\u54CD\u5E94\u901F\u5EA6" : complexity.band === "balanced" ? "\u5728\u8D28\u91CF\u3001\u6210\u672C\u3001\u5EF6\u8FDF\u4E0E\u98CE\u9669\u4E4B\u95F4\u5E73\u8861" : "\u9AD8\u590D\u6742\u5EA6\u6309\u5173\u952E\u5EA6\u8BBE\u7F6E\u8D28\u91CF\u4E0B\u9650\uFF0C\u518D\u5728\u53EF\u884C\u5019\u9009\u4E2D\u6700\u5C0F\u5316\u8D39\u7528"}\uFF1B\u4EFB\u52A1\u7C7B\u578B\u4E3A ${taskType}\uFF0C\u5DF2\u5BF9 ${String(subtasks.length)} \u4E2A\u5DE5\u4F5C\u5305\u8FDB\u884C\u7EA6\u675F\u6307\u6D3E\u3002`;
+  const paretoPruned = (optimized?.candidatePools ?? []).reduce((sum, pool) => sum + pool.pruned, 0);
+  const minimumFeasibleCost = optimized?.minimumFeasibleCost ?? minimumCostPlan?.cost ?? 0;
+  const reason = selected === null ? "\u5C1A\u672A\u53D1\u73B0\u53EF\u7528\u6A21\u578B\uFF0C\u4FDD\u7559 Harness \u539F\u59CB\u6A21\u578B\u9009\u62E9\u3002" : `${complexity.band === "simple" ? "\u4F4E\u590D\u6742\u5EA6\u4F18\u5148\u6210\u672C\u4E0E\u54CD\u5E94\u901F\u5EA6" : complexity.band === "balanced" ? "\u5728\u8D28\u91CF\u3001\u6210\u672C\u3001\u5EF6\u8FDF\u4E0E\u98CE\u9669\u4E4B\u95F4\u5E73\u8861" : "\u9AD8\u590D\u6742\u5EA6\u6267\u884C\u4F9D\u8D56\u611F\u77E5\u7684\u5168\u5C40\u7EA6\u675F\u5206\u914D"}\uFF1B\u4EFB\u52A1\u7C7B\u578B\u4E3A ${taskType}\uFF0C\u5DF2\u5BF9 ${String(subtasks.length)} \u4E2A\u5DE5\u4F5C\u5305\u8FDB\u884C Pareto \u526A\u679D\u548C\u6709\u754C\u7EC4\u5408\u641C\u7D22\u3002`;
   return {
     mode,
     complexity: { value: Number(complexity.value.toFixed(3)), band: complexity.band },
@@ -60125,7 +60273,7 @@ function buildPlan({ text: text6 = "", available = [], mode = "collective", pric
     estimatedCost: Number(totalEstimate.toFixed(6)),
     costBreakdown,
     optimization: {
-      solver: "quality-constrained greedy assignment with diversity penalty",
+      solver: "pareto-pruned quality-constrained beam assignment",
       qualityFloor: QUALITY_FLOORS[complexity.band],
       budgetUsd: Number(Number(budgetUsd) > 0 ? Number(budgetUsd) : 0),
       cacheReadRatio: normalizedCacheRatios(cacheReadRatio, cacheWriteRatio).read,
@@ -60135,6 +60283,11 @@ function buildPlan({ text: text6 = "", available = [], mode = "collective", pric
       baselineAllStrongCost: Number(baselineCost.toFixed(6)),
       estimatedSavings: Number(savings.toFixed(4)),
       distinctRoutes: usedRoutes.size,
+      handoffCount: optimized?.switches ?? 0,
+      paretoPruned,
+      beamWidth: ROUTING_BEAM_WIDTH,
+      budgetFeasible: budget <= 0 || budgetPlan !== null,
+      minimumFeasibleCost: Number(Number(minimumFeasibleCost).toFixed(6)),
       liveBench: liveBench?.fetchedAt ? { source: liveBench.source ?? "livebench", fetchedAt: liveBench.fetchedAt, models: Object.keys(liveBench.models ?? {}).length, stale: String(liveBenchError).length > 0, error: String(liveBenchError || "") } : { source: "experimental-baseline", fetchedAt: null, models: 0, stale: false, error: String(liveBenchError || "") }
     },
     reason,
@@ -61587,7 +61740,7 @@ var gal_scene_default = { version: 1, settings: { stageW: 1920, stageH: 1080, sh
 var name = "gal-view";
 var PROJECT_URL = "https://github.com/ljwei-stak/deepseek-harness";
 var RELEASES_URL = `${PROJECT_URL}/releases`;
-var PLUGIN_VERSION = "0.4.10";
+var PLUGIN_VERSION = "0.4.14";
 function createUpdateApi() {
   const bridge = globalThis.deepSeekHarnessDesktop;
   const openExternal = (url) => {

package/.dsh-plugin/index.mjs

@@ -15,6 +15,17 @@ import {
   modLensUpstream,
   routeThroughModLens,
 } from './shared/modlens-routing.mjs'
+import {
+  approvalGateStatus,
+  approvalSafetyContext,
+  decorateApprovalReason,
+  isApprovalGateReason,
+} from './shared/approval-gate.mjs'
+import {
+  webCapabilityForPlan,
+  webCapabilityStatus,
+  webInstruction,
+} from './shared/web-routing.mjs'
 
 let settingsRuntimePromise
 let routerSettings = { ...DEFAULT_ROUTER_SETTINGS }
@@ -213,6 +224,17 @@ function stageMessage(plan, step) {
   }
 }
 
+function webMessage(plan) {
+  const text = webInstruction(plan?.web)
+  if (text === '') return null
+  return {
+    id: newMessageId(),
+    role: 'user',
+    content: [{ type: 'text', text }],
+    source: { kind: 'plugin', plugin: name, form: 'web-capability', summary: '联网与可见浏览器策略' },
+  }
+}
+
 /**
  * Persona is a final-answer context only. It is intentionally a separate
  * message so the collaboration stages and their audit records remain free of
@@ -268,6 +290,7 @@ function analysisMessage(plan) {
     `缓存计费比例：读取 ${Math.round(Number(plan.optimization?.cacheReadRatio ?? 0) * 100)}%，写入 ${Math.round(Number(plan.optimization?.cacheWriteRatio ?? 0) * 100)}%（未填写时按普通输入计费）`,
     Number(plan.optimization?.budgetUsd ?? 0) > 0 ? `预算上限：$${Number(plan.optimization.budgetUsd).toFixed(6)}；${plan.optimization.budgetExceeded ? '仍超预算，已在质量下限内尽量压缩' : '满足预算约束'}` : '',
     `LiveBench：${plan.optimization?.liveBench?.fetchedAt ? `快照于 ${new Date(Number(plan.optimization.liveBench.fetchedAt)).toISOString()}${plan.optimization.liveBench.stale ? '（本次刷新失败，沿用上次快照）' : ''}` : '未完成联网核验，使用实验基线'}`,
+    plan.web?.needsWeb ? `联网策略：${plan.web.directBrowser ? 'Ego Browser 可见窗口优先' : 'ModSearch 搜索/抓取，失败时 Ego Browser 窗口兜底'}；反爬处理：人工接管后继续` : '',
     String(plan.reason ?? ''),
   ].filter(Boolean).join('\n')
   return {
@@ -432,6 +455,27 @@ export function apply(ctx) {
     routerSettingsPromise = registerRouterSettings(ctx)
   }
   const scheduleOpenCodeRepair = createOpenCodeRepairScheduler(ctx)
+
+  // dsh-approval-gate owns the actual decision. The router adds auditable
+  // stage/route context before that waterfall so multi-task escalations are
+  // visible to the gate's Flash classifier and human reviewer. The request
+  // object is borrowed by the Host approval service for this dispatch only.
+  ctx.on('approval/request', (request, next) => {
+    if (!isApprovalGateReason(request?.reason)) return next()
+    const state = request?.agent === undefined ? null : stateFor(request.agent)
+    const context = approvalSafetyContext(state, state?.lastStep)
+    const decorated = decorateApprovalReason(request.reason, context)
+    if (decorated !== request.reason) {
+      try {
+        request.reason = decorated
+      } catch {
+        // Some hosts freeze event payloads. In that case the gate still
+        // receives the original reason and remains fully fail-safe.
+      }
+    }
+    return next()
+  }, { prepend: true })
+
   ctx.commands.register({
     name: 'router',
     description: 'switch Model Router mode or inspect the latest routing plan',
@@ -440,7 +484,7 @@ export function apply(ctx) {
     // the whole composer submission; the GAL client sends this command
     // without image bytes so the attachment remains available for the next
     // user turn.
-    input: { hint: 'mode collective|single | plan', images: true },
+    input: { hint: 'mode collective|single | plan | safety', images: true },
     recordInput: true,
     handler: ({ agent, rawInput }) => {
       const state = stateFor(agent)
@@ -458,7 +502,13 @@ export function apply(ctx) {
       if (value === 'plan' || value === '') {
         return { kind: 'success', text: state.plan === null ? '还没有可展示的路由方案。' : JSON.stringify(state.plan) }
       }
-      return { kind: 'error', text: '用法：/router mode collective、/router mode single 或 /router plan' }
+      if (value === 'safety' || value === 'approval') {
+        return { kind: 'success', text: JSON.stringify({ ...approvalGateStatus(ctx), context: approvalSafetyContext(state, state.lastStep) }) }
+      }
+      if (value === 'web' || value === 'network') {
+        return { kind: 'success', text: JSON.stringify({ ...webCapabilityStatus(ctx), context: webCapabilityForPlan(state.taskText, state.plan) }) }
+      }
+      return { kind: 'error', text: '用法：/router mode collective、/router mode single、/router plan、/router safety 或 /router web' }
     },
   })
 
@@ -515,7 +565,7 @@ export function apply(ctx) {
       await routerSettingsPromise
       state.taskText = inputText(messages)
       const liveBench = await liveBenchFor(ctx, state)
-      state.plan = buildPlan({
+      const plan = buildPlan({
         text: state.taskText,
         available,
         mode: state.mode,
@@ -526,6 +576,16 @@ export function apply(ctx) {
         cacheReadRatio: routerSettings.cacheReadRatio,
         cacheWriteRatio: routerSettings.cacheWriteRatio,
       })
+      state.plan = {
+        ...plan,
+        web: webCapabilityForPlan(state.taskText, plan),
+        safety: {
+          ...approvalGateStatus(ctx),
+          ...approvalSafetyContext({ ...state, plan }, Number(step)),
+          hardCategories: ['deletion', 'credential', 'remote', 'system', 'bulk'],
+          failSafe: true,
+        },
+      }
       state.collaboration = shouldCollaborate(state.plan, available)
         ? { lastStep: 0, queuedStep: null }
         : null
@@ -538,11 +598,13 @@ export function apply(ctx) {
     const currentStep = Number.isFinite(Number(step)) ? Number(step) : state.lastStep + 1
     const stageContext = stageMessage(state.plan, currentStep)
     const analysisContext = currentStep === 1 ? analysisMessage(state.plan) : null
+    const webContext = currentStep === 1 ? webMessage(state.plan) : null
     const hasPersona = proposed.messages.some(message => message?.content?.some(block => isPersonaPrompt(block?.text)))
     if (hasPersona) state.personaInjected = true
     const personaContext = state.personaInjected ? null : personaMessage(state, agent, currentStep)
     const additions = []
     if (analysisContext !== null && !hasStageMarker(proposed.messages, currentStep)) additions.push(analysisContext)
+    if (webContext !== null && !proposed.messages.some(message => message?.content?.some(block => block?.text === webContext.content[0].text))) additions.push(webContext)
     if (personaContext !== null) {
       additions.push(personaContext)
       state.personaInjected = true

package/.dsh-plugin/shared/approval-gate.mjs

@@ -0,0 +1,108 @@
+/**
+ * Compatibility bridge for dsh-approval-gate.
+ *
+ * The approval-gate package owns the approval waterfall, Flash judgement,
+ * learning, audit files, snapshots and UI. This module only produces a small,
+ * deterministic safety context for the current Model Router work package.
+ * Keeping the bridge stateless makes it safe when the gate is installed by
+ * another profile layer as well as when it is bundled by this plugin.
+ */
+
+export const APPROVAL_GATE_PACKAGE = 'dsh-approval-gate'
+export const APPROVAL_GATE_VERSION = '0.5.0'
+
+const ESCALATION_RE = /escalate\s+sandbox\s+to\s+([^\s:]+):?\s*([\s\S]*)/i
+
+function clean(value, max = 240) {
+  return String(value ?? '').replace(/[\r\n]+/g, ' ').trim().slice(0, max)
+}
+
+function stageFor(state, step) {
+  const plan = state?.plan
+  const tasks = Array.isArray(plan?.subtasks) ? plan.subtasks : []
+  if (tasks.length === 0) return null
+  const index = Math.max(0, Number(step || state?.lastStep || 1) - 1)
+  return tasks[index] ?? tasks[tasks.length - 1] ?? null
+}
+
+/**
+ * Return the router safety facts that are relevant to an approval request.
+ * `bulk` is a candidate supplied as context; dsh-approval-gate still performs
+ * the authoritative category decision and fail-safe human handoff.
+ */
+export function approvalSafetyContext(state, step) {
+  const plan = state?.plan
+  const tasks = Array.isArray(plan?.subtasks) ? plan.subtasks : []
+  const stage = stageFor(state, step)
+  const collective = state?.mode === 'collective'
+  const multiTask = collective && plan?.complexity?.band === 'complex' && tasks.length >= 3
+  return {
+    mode: state?.mode ?? 'collective',
+    complexity: plan?.complexity?.band ?? 'unknown',
+    stage: stage?.id ?? null,
+    stagePurpose: stage?.purpose ?? null,
+    stageType: stage?.type ?? null,
+    stageIndex: tasks.length === 0 ? 0 : Math.max(1, Number(step || state?.lastStep || 1)),
+    stageCount: tasks.length,
+    multiTask,
+    candidateCategory: multiTask ? 'bulk' : 'neutral',
+    selectedRoute: plan?.selected?.provider && plan?.selected?.model
+      ? `${plan.selected.provider}/${plan.selected.model}`
+      : null,
+    activeRoute: state?.lastTarget?.provider && state?.lastTarget?.model
+      ? `${state.lastTarget.provider}/${state.lastTarget.model}`
+      : null,
+  }
+}
+
+/**
+ * Decorate the justification consumed by dsh-approval-gate. The original
+ * escalation prefix remains intact, so the target plugin can parse it. The
+ * marker is deliberately plain text because the target plugin's Flash model
+ * judges only the justification string.
+ */
+export function decorateApprovalReason(reason, context) {
+  const raw = String(reason ?? '')
+  const match = raw.match(ESCALATION_RE)
+  if (!match || context === null || context === undefined) return raw
+  const mode = clean(match[1], 64)
+  const justification = clean(match[2], 500)
+  const stage = context.stage ? `${context.stage} ${context.stageIndex}/${context.stageCount}` : 'unknown'
+  const route = context.activeRoute || context.selectedRoute || 'unassigned'
+  const marker = [
+    '[model-router safety context]',
+    `mode=${context.mode}`,
+    `complexity=${context.complexity}`,
+    `stage=${stage}`,
+    `purpose=${context.stagePurpose || 'unknown'}`,
+    `route=${route}`,
+    `task_count=${context.stageCount || 0}`,
+    `risk_candidate=${context.candidateCategory}`,
+    context.multiTask ? 'multi_task_review=required' : 'multi_task_review=not_applicable',
+  ].join('; ')
+  return `escalate sandbox to ${mode}: ${justification || 'router stage requires sandbox escalation'} ${marker}`.trim()
+}
+
+export function isApprovalGateReason(reason) {
+  return ESCALATION_RE.test(String(reason ?? ''))
+}
+
+export function approvalGateStatus(ctx) {
+  let approval = false
+  let permissionPresets = false
+  try {
+    approval = Boolean(ctx?.get?.('approval'))
+    permissionPresets = Boolean(ctx?.get?.('permissionPresets'))
+  } catch {
+    approval = false
+    permissionPresets = false
+  }
+  return {
+    package: APPROVAL_GATE_PACKAGE,
+    version: APPROVAL_GATE_VERSION,
+    bundled: true,
+    approvalServiceDetected: approval,
+    permissionPresetsDetected: permissionPresets,
+    policy: 'hard-risk-human-review',
+  }
+}