@ljwei-stak/dsh-model-router 0.21.1 → 0.22.0

package/.dsh-plugin/shared/assignment-solver.mjs

@@ -1,12 +1,20 @@
 /**
- * Deterministic budget-constrained DAG assignment, independent of model names.
- * Exact enumeration is bounded by the retained Cartesian candidate space;
- * larger spaces use a beam with a protected least-cost feasible prefix.
- * Optimality concerns this surrogate objective, never actual answer quality.
+ * Deterministic assignment over retained candidate actions, not actual answer quality.
+ * Small spaces enumerate exactly; larger spaces use safe boundary-state dominance
+ * and future-aware bounded frontier retention without a global optimality claim.
  */
 const EPSILON = 1e-12
 const compareText = (a, b) => a < b ? -1 : a > b ? 1 : 0
-const signature = state => JSON.stringify(state.choices.map(option => option.route))
+
+const choiceSignature = option => {
+  if (option.actionId === undefined && option.effort === undefined && option.reasoningEffort === undefined) return option.route
+  return JSON.stringify([option.actionId ?? option.route, option.effort ?? option.reasoningEffort ?? null])
+}
+
+const signature = state => JSON.stringify(state.choices.map(choiceSignature))
+
+const compareQuality = (left, right) =>
+  left.relaxedCount - right.relaxedCount || left.qualityShortfall - right.qualityShortfall
 
 function compareStates(left, right, minimizeCost = false) {
   return left.relaxedCount - right.relaxedCount
@@ -17,69 +25,261 @@ function compareStates(left, right, minimizeCost = false) {
     || compareText(signature(left), signature(right))
 }
 
+// Safe DP dominance for states with the same future dependency boundary.
+// Quality is lexicographic and always precedes cost/score in compareStates.
+// Cost/score are Pareto compared, then switches and the deterministic signature
+// break exact ties. Comparisons are strict; no epsilon is used here.
+const dominates = (left, right) => {
+  if (left.cost > right.cost) return false
+  const quality = compareQuality(left, right)
+  if (quality < 0) return true
+  if (quality > 0) return false
+  if (left.score > right.score) return true
+  if (left.score < right.score) return false
+  if (left.cost < right.cost) return true
+  if (left.cost > right.cost) return false
+  if (left.switches !== right.switches) return left.switches < right.switches
+  return compareText(signature(left), signature(right)) < 0
+}
+
+const dominanceOrder = (left, right) =>
+  left.cost - right.cost
+  || compareQuality(left, right)
+  || right.score - left.score
+  || left.switches - right.switches
+  || compareText(signature(left), signature(right))
+
 export function solveCandidateAssignments({ tasks = [], pools = [], budget = Infinity, beamWidth = 256, exactLimit = 4096, handoffPenalty = 0.015, minimizeCost = false } = {}) {
   if (!tasks.length || tasks.length !== pools.length) return null
+  const taskCount = tasks.length
+  const taskIndexById = new Map()
   const preceding = new Set()
-  for (const task of tasks) {
-    if (!task.id || preceding.has(task.id) || (task.dependsOn ?? []).some(id => !preceding.has(id))) {
+  for (let index = 0; index < taskCount; index++) {
+    const task = tasks[index]
+    if (!task || !task.id || preceding.has(task.id) || (task.dependsOn ?? []).some(id => !preceding.has(id))) {
       throw new RangeError('Assignment tasks must have unique ids and known dependencies in topological order')
     }
     preceding.add(task.id)
+    taskIndexById.set(task.id, index)
   }
+
   const constrained = Number.isFinite(budget)
   const options = pools.map(pool => (Array.isArray(pool) ? pool : []).filter(option =>
-    Number.isFinite(option.cost) && option.cost >= 0 && Number.isFinite(option.score)
+    option && Number.isFinite(option.cost) && option.cost >= 0 && Number.isFinite(option.score)
     && (!constrained || option.pricingKnown === true)))
   if (options.some(pool => pool.length === 0)) return null
-  const suffixMinimum = Array(tasks.length + 1).fill(0)
+
+  const handoffRoutes = options.map(pool => pool.map(option => option.handoffRoute ?? option.route))
+  const maximumScores = options.map(pool => pool.reduce((best, option) => Math.max(best, option.score), -Infinity))
+  const dependencyIndexes = tasks.map(task => (task.dependsOn ?? []).map(id => taskIndexById.get(id)))
+  const lastUse = new Array(taskCount).fill(-1)
+  for (let index = 0; index < taskCount; index++) {
+    for (const depIndex of dependencyIndexes[index]) {
+      if (index > lastUse[depIndex]) lastUse[depIndex] = index
+    }
+  }
+
+  const suffixMinimum = new Array(taskCount + 1).fill(0)
+  const futureRelaxedLower = new Array(taskCount + 1).fill(0)
+  const futureShortfallLower = new Array(taskCount + 1).fill(0)
   let searchSpace = 1
   let searchSpaceCapped = false
-  for (let index = tasks.length - 1; index >= 0; index--) {
-    suffixMinimum[index] = suffixMinimum[index + 1] + Math.min(...options[index].map(option => option.cost))
+  for (let index = taskCount - 1; index >= 0; index--) {
+    let minCost = Infinity
+    let minRelaxedFlag = 1
+    let minShortfallAtFlag = Infinity
+    for (const option of options[index]) {
+      if (option.cost < minCost) minCost = option.cost
+      const shortfall = Math.max(0, Number(option.qualityShortfall) || 0)
+      const relaxedFlag = shortfall > 0 ? 1 : 0
+      if (relaxedFlag < minRelaxedFlag || (relaxedFlag === minRelaxedFlag && shortfall < minShortfallAtFlag)) {
+        minRelaxedFlag = relaxedFlag
+        minShortfallAtFlag = shortfall
+      }
+    }
+    suffixMinimum[index] = suffixMinimum[index + 1] + minCost
+    futureRelaxedLower[index] = futureRelaxedLower[index + 1] + minRelaxedFlag
+    futureShortfallLower[index] = futureShortfallLower[index + 1] + minShortfallAtFlag
     const product = searchSpace * options[index].length
     if (product > Number.MAX_SAFE_INTEGER) searchSpaceCapped = true
     searchSpace = Math.min(Number.MAX_SAFE_INTEGER, product)
   }
+
   if (constrained && suffixMinimum[0] > budget + EPSILON) return null
-  const exact = !searchSpaceCapped && searchSpace <= Math.max(1, exactLimit)
-  const width = Math.max(1, Math.floor(beamWidth) || 256)
-  const search = { method: exact ? 'exact' : 'beam', exact, searchSpace, searchSpaceCapped, expandedStates: 0, beamPruned: 0 }
+  const parsedExactLimit = Number(exactLimit)
+  const exactThreshold = Number.isFinite(parsedExactLimit)
+    ? Math.max(1, parsedExactLimit)
+    : exactLimit === Infinity ? Number.MAX_SAFE_INTEGER : 4096
+  const parsedBeamWidth = Number(beamWidth)
+  const width = Number.isFinite(parsedBeamWidth) ? Math.max(1, Math.floor(parsedBeamWidth) || 256) : 256
+  const exact = !searchSpaceCapped && searchSpace <= exactThreshold
+
+  const search = {
+    method: exact ? 'exact' : 'beam',
+    exact,
+    strategy: exact ? 'exact-enumeration' : 'boundary-frontier-lookahead',
+    searchSpace,
+    searchSpaceCapped,
+    expandedStates: 0,
+    beamPruned: 0,
+    dominancePruned: 0,
+    peakFrontier: 0,
+    retainedStates: 0,
+    beamWidth: width,
+    approximate: !exact,
+    optimalityScope: 'retained input candidate Cartesian space',
+    boundCertified: exact
+  }
+
+  // Negative handoff penalties historically increase score for mismatches, so an
+  // optimistic lookahead must include the maximum possible unassigned reward.
+  const unassignedReward = handoffPenalty < 0 ? -handoffPenalty : 0
   let states = [{ choices: [], routesByTask: new Map(), score: 0, cost: 0, switches: 0, relaxedCount: 0, qualityShortfall: 0 }]
-  for (let index = 0; index < tasks.length; index++) {
-    const task = tasks[index]
+
+  for (let index = 0; index < taskCount; index++) {
     const expanded = []
     for (const state of states) {
-      for (const option of options[index]) {
+      for (let optionIndex = 0; optionIndex < options[index].length; optionIndex++) {
+        const option = options[index][optionIndex]
         const cost = state.cost + option.cost
         if (constrained && cost + suffixMinimum[index + 1] > budget + EPSILON) continue
-        const switches = (task.dependsOn ?? []).reduce((count, dependency) => {
-          const route = state.routesByTask.get(dependency)
-          return count + (route !== undefined && route !== option.route ? 1 : 0)
-        }, 0)
+        let switches = 0
+        for (const depIndex of dependencyIndexes[index]) {
+          const route = state.routesByTask.get(tasks[depIndex].id)
+          if (route !== undefined && route !== handoffRoutes[index][optionIndex]) switches++
+        }
         const penalty = switches * handoffPenalty
         const shortfall = Math.max(0, Number(option.qualityShortfall) || 0)
         const routesByTask = new Map(state.routesByTask)
-        routesByTask.set(task.id, option.route)
-        expanded.push({ choices: [...state.choices, { ...option, handoffPenalty: penalty }], routesByTask,
-          score: state.score + option.score - penalty, cost, switches: state.switches + switches,
-          relaxedCount: state.relaxedCount + (shortfall > 0 ? 1 : 0), qualityShortfall: state.qualityShortfall + shortfall })
+        routesByTask.set(tasks[index].id, handoffRoutes[index][optionIndex])
+        expanded.push({
+          choices: [...state.choices, { ...option, handoffPenalty: penalty }],
+          routesByTask,
+          score: state.score + option.score - penalty,
+          cost,
+          switches: state.switches + switches,
+          relaxedCount: state.relaxedCount + (shortfall > 0 ? 1 : 0),
+          qualityShortfall: state.qualityShortfall + shortfall
+        })
         search.expandedStates++
       }
     }
     if (!expanded.length) return null
-    expanded.sort((left, right) => compareStates(left, right, minimizeCost))
-    if (!exact && expanded.length > width) {
-      // A high-utility prefix must not crowd out every affordable completion.
-      // This also works at width=1; quality relaxation remains lexicographic.
-      states = expanded.slice(0, width)
-      if (constrained && index < tasks.length - 1) {
-        const cheapest = expanded.reduce((best, state) => compareStates(state, best, true) < 0 ? state : best)
-        if (!states.includes(cheapest)) states[width - 1] = cheapest
+
+    if (exact) {
+      expanded.sort((left, right) => compareStates(left, right, minimizeCost))
+      states = expanded
+    } else {
+      // Group by the only information future transitions can observe: handoff
+      // routes of already assigned tasks that still have a future dependent.
+      const groups = new Map()
+      for (const state of expanded) {
+        const boundary = []
+        for (let prev = 0; prev <= index; prev++) {
+          if (lastUse[prev] > index) boundary.push([tasks[prev].id, state.routesByTask.get(tasks[prev].id)])
+        }
+        const key = JSON.stringify(boundary)
+        const group = groups.get(key)
+        if (group) group.push(state)
+        else groups.set(key, [state])
+      }
+
+      const compressed = []
+      for (const group of groups.values()) {
+        group.sort(dominanceOrder)
+        const retained = []
+        for (const candidate of group) {
+          let dominated = false
+          for (const keeper of retained) {
+            if (dominates(keeper, candidate)) {
+              dominated = true
+              break
+            }
+          }
+          if (dominated) search.dominancePruned++
+          else retained.push(candidate)
+        }
+        for (const state of retained) compressed.push(state)
       }
-      search.beamPruned += expanded.length - states.length
-    } else states = expanded
+
+      const scoreUpperCache = new Map()
+      const optimisticScore = state => {
+        if (scoreUpperCache.has(state)) return scoreUpperCache.get(state)
+        let total = state.score
+        for (let future = index + 1; future < taskCount; future++) {
+          const deps = dependencyIndexes[future]
+          let unassignedDeps = 0
+          let assignedCount = 0
+          const assignedRoutes = new Map()
+          for (const depIndex of deps) {
+            if (depIndex > index) unassignedDeps++
+            else {
+              const route = state.routesByTask.get(tasks[depIndex].id)
+              if (route !== undefined) {
+                assignedCount++
+                assignedRoutes.set(route, (assignedRoutes.get(route) ?? 0) + 1)
+              }
+            }
+          }
+          // Count predecessor routes once, rather than rescanning every edge
+          // for every future action. Independent future tasks need no scan.
+          if (!assignedCount || handoffPenalty === 0) {
+            total += maximumScores[future] + unassignedReward * unassignedDeps
+            continue
+          }
+          let best = -Infinity
+          for (let optionIndex = 0; optionIndex < options[future].length; optionIndex++) {
+            const option = options[future][optionIndex]
+            const matches = assignedRoutes.get(handoffRoutes[future][optionIndex]) ?? 0
+            let value = option.score - handoffPenalty * (assignedCount - matches)
+            if (unassignedDeps && unassignedReward) value += unassignedReward * unassignedDeps
+            if (value > best) best = value
+          }
+          total += best
+        }
+        scoreUpperCache.set(state, total)
+        return total
+      }
+
+      // Lookahead is a sorting heuristic only. Future quality is a per-task lower
+      // bound and ignores future handoff interactions, so it cannot certify optimality.
+      compressed.sort((left, right) => {
+        const leftRelaxed = left.relaxedCount + futureRelaxedLower[index + 1]
+        const rightRelaxed = right.relaxedCount + futureRelaxedLower[index + 1]
+        if (leftRelaxed !== rightRelaxed) return leftRelaxed - rightRelaxed
+        const leftShortfall = left.qualityShortfall + futureShortfallLower[index + 1]
+        const rightShortfall = right.qualityShortfall + futureShortfallLower[index + 1]
+        if (leftShortfall !== rightShortfall) return leftShortfall - rightShortfall
+        const leftScore = optimisticScore(left)
+        const rightScore = optimisticScore(right)
+        const leftCost = left.cost + suffixMinimum[index + 1]
+        const rightCost = right.cost + suffixMinimum[index + 1]
+        if (minimizeCost) {
+          if (leftCost !== rightCost) return leftCost - rightCost
+          if (leftScore !== rightScore) return rightScore - leftScore
+        } else {
+          if (leftScore !== rightScore) return rightScore - leftScore
+          if (leftCost !== rightCost) return leftCost - rightCost
+        }
+        return compareStates(left, right, minimizeCost)
+      })
+
+      if (compressed.length > width) {
+        states = compressed.slice(0, width)
+        search.beamPruned += compressed.length - states.length
+        if (constrained && index < taskCount - 1) {
+          let cheapest = compressed[0]
+          for (const state of compressed) if (compareStates(state, cheapest, true) < 0) cheapest = state
+          if (!states.includes(cheapest)) states[width - 1] = cheapest
+        }
+      } else states = compressed
+    }
+
+    if (states.length > search.peakFrontier) search.peakFrontier = states.length
   }
+
   states.sort((left, right) => compareStates(left, right, minimizeCost))
+  search.retainedStates = states.length
   const best = states[0]
   const { routesByTask, ...result } = best
   return { ...result, minimumCostLowerBound: suffixMinimum[0], search }

package/.dsh-plugin/shared/harness-plan.mjs

@@ -73,8 +73,8 @@ function annotate(channel) {
  */
 export function createPlanFromRoutes(task, availableRoutes, {
   mode = 'single', budgetUsd = 0, installedToolIds = [], runnableToolIds = [],
-  pricing = {}, liveBench = null, liveBenchError = '', dataVersions = null, learning = null, cacheReadRatio = 0, cacheWriteRatio = 0,
-  directProvider = '', directModel = '', preset = 'balanced', loggedOutToolIds = [],
+  pricing = {}, liveBench = null, liveBenchError = '', dataVersions = null, learning = null, routingEvidence = null, cacheReadRatio = 0, cacheWriteRatio = 0,
+  directProvider = '', directModel = '', preset = 'balanced', loggedOutToolIds = [], forceOfficialCli = false,
 } = {}) {
   const taskText = clean(task)
   if (!taskText) throw new Error('task must contain text')
@@ -96,13 +96,23 @@ export function createPlanFromRoutes(task, availableRoutes, {
   const channelOf = (provider, model) => {
     const route = routes.find(item => item.provider === provider && item.model === model)
     const key = `${String(provider ?? '')}\0${String(model ?? '')}\0${route?.execution ?? ''}`
-    if (!channelCache.has(key)) channelCache.set(key, channelForProvider(provider, installedIds, runnableToolIds, route, loggedOutToolIds))
+    if (!channelCache.has(key)) {
+      const tool = forceOfficialCli ? toolForProvider(provider) : null
+      channelCache.set(key, tool ? {
+        kind: 'official-cli', tool: tool.id, label: tool.label,
+        detail: '官方 CLI 团队计划仅通过已核验的官方 CLI 执行；使用厂商默认推理档位。',
+      } : channelForProvider(provider, installedIds, runnableToolIds, route, loggedOutToolIds))
+    }
     return channelCache.get(key)
   }
   const needsImage = detectTaskTypes(taskText).includes('vision')
   const plan = buildPlan({
     text: taskText,
-    available: routes,
+    available: routes.map(route => {
+      const channel = channelOf(route.provider, route.model)
+      return { ...route, executionChannel: channel.kind,
+        reasoningExecution: directRoute ? 'default' : channel.kind === 'harness-llm' ? 'api' : 'unsupported-cli' }
+    }),
     mode: directRoute ? 'single' : selectedMode,
     budgetUsd: Math.max(0, Number.isFinite(budgetUsd) ? budgetUsd : 0),
     pricing,
@@ -110,6 +120,7 @@ export function createPlanFromRoutes(task, availableRoutes, {
     liveBenchError,
     dataVersions,
     learning,
+    routingEvidence,
     cacheReadRatio,
     cacheWriteRatio,
     preset,
@@ -157,6 +168,7 @@ export function createPlanFromRoutes(task, availableRoutes, {
         recommendedModel: item.recommended,
         estimatedCost: plan.costBreakdown[index]?.estimatedCost ?? null,
         ...item.recommendedReasoningEffort ? { recommendedReasoningEffort: item.recommendedReasoningEffort } : {},
+        ...item.reasoningExecutionNotice ? { reasoningExecutionNotice: item.reasoningExecutionNotice } : {},
         ...annotate(channelOf(item.recommendedProvider, item.recommended)),
         verificationChecklist: item.purpose === 'synthesis'
           ? ['核对各工作包交付物与依赖', '记录冲突、未解决事项和最终验收结果']

package/.dsh-plugin/shared/manual-plan.mjs

@@ -0,0 +1,143 @@
+import { estimateAssignedPackage } from './router.mjs'
+import { getOfficialTool } from './official-tool-registry.mjs'
+import { billingPlan } from './subscription-billing.mjs'
+import { parsePackageAssignments, packagePlanKey } from './package-assignments.mjs'
+
+const allocatedFields = [
+  'recommendedReasoningEffort', 'preferredReasoningEffort', 'reasoningEffort',
+  'plannedReasoningEffort', 'requestedReasoningEffort', 'reasoningFit',
+  'reasoningOutputMultiplier', 'reasoningExecutionNotice', 'channelTool',
+  'channelLabel', 'channelDetail', 'loginRequired', 'executionPreference',
+  'executionChannel', 'estimatedCost', 'quality', 'qualitySource', 'pricingSource',
+]
+
+function withoutAllocation(value) {
+  const result = { ...value }
+  for (const key of allocatedFields) delete result[key]
+  if (Array.isArray(result.dependsOn)) result.dependsOn = [...result.dependsOn]
+  return result
+}
+
+function annotation(target, tool) {
+  return target.kind === 'api' ? {
+    executionChannel: 'harness-llm',
+    channelDetail: '用户指定该模型目录 API；使用适配器默认推理档位。',
+    reasoningExecutionNotice: '手动分配使用适配器默认推理档位。',
+  } : {
+    executionChannel: 'official-cli', channelTool: tool.id, channelLabel: tool.label,
+    channelDetail: `${tool.label} 使用厂商工具自身配置的默认模型，不代表模型目录中的特定模型。`,
+    reasoningExecutionNotice: '使用厂商官方工具默认模型与默认推理档位。',
+  }
+}
+
+/** Apply explicit targets to the existing decomposition; never search or substitute targets. */
+export function applyManualPackagePlan(plan, {
+  task, packageAssignments, packagePlanKey: expectedKey,
+} = {}, routes, dataOptions = {}) {
+  const assignments = parsePackageAssignments(packageAssignments)
+  if (!assignments) throw new TypeError('手动分配需要提供全部工作包目标。')
+  const packages = plan?.team?.workPackages
+  if (plan?.routingBypassed || plan?.mode === 'direct' || !Array.isArray(packages)
+    || !packages.length || packages.length > 32) {
+    throw new Error('手动分配需要当前任务的工作包计划，不能用于全局指定模型。')
+  }
+  const key = packagePlanKey(plan, task)
+  if (!key || expectedKey !== key) throw new Error('工作包计划已变化，请重新确认分配。')
+  const ids = packages.map(item => item?.id)
+  if (new Set(ids).size !== ids.length || ids.some(id => typeof id !== 'string' || !id)) {
+    throw new Error('工作包计划包含无效或重复标识。')
+  }
+  const chosenIds = Object.keys(assignments)
+  if (chosenIds.length !== ids.length || chosenIds.some(id => !ids.includes(id))) {
+    throw new Error('请为全部工作包分配目标，且不能添加其他工作包。')
+  }
+  const catalog = Array.isArray(routes) ? routes : []
+  const choices = packages.map(item => {
+    const target = assignments[item.id]
+    if (!target) throw new Error(`工作包 ${item.id} 缺少目标。`)
+    if (target.kind === 'tool') {
+      const tool = getOfficialTool(target.toolId)
+      if (!tool) throw new Error(`未知的官方工具：${target.toolId}`)
+      return { target, tool, provider: 'official-tool', model: target.toolId }
+    }
+    const matches = catalog.filter(route => route.provider === target.provider && route.model === target.model)
+    if (matches.length !== 1) throw new Error(`指定模型 ${target.provider}/${target.model} 不在唯一可用目录中。`)
+    const route = matches[0]
+    const billing = billingPlan(route, catalog)
+    if (billing.mode === 'subscription-only' || billing.subscription?.kind === 'plan-key') {
+      throw new Error(`模型 ${target.provider}/${target.model} 使用订阅路线，不能作为手动 API 目标。`)
+    }
+    if (item.type === 'vision' && Array.isArray(route.inputModalities)
+      && route.inputModalities.length && !route.inputModalities.some(value => String(value).toLowerCase() === 'image')) {
+      throw new Error(`工作包 ${item.id} 需要图像模型，所选模型仅声明其他输入能力。`)
+    }
+    return { target, route, provider: target.provider, model: target.model }
+  })
+
+  const costBreakdown = packages.map((item, index) => {
+    const choice = choices[index]
+    const estimate = choice.route
+      ? estimateAssignedPackage(choice.route, item, task, plan.complexity?.band ?? 'balanced', dataOptions)
+      : { estimatedCost: null, quality: null, qualitySource: 'unknown', pricingSource: 'unknown',
+        estimateSource: 'official-tool-unknown', handoffPenalty: 0 }
+    return { ...withoutAllocation(estimate), stage: index + 1, purpose: item.purpose,
+      difficulty: item.difficulty, provider: choice.provider, model: choice.model,
+      estimatedCost: Number.isFinite(estimate.estimatedCost) && estimate.estimatedCost >= 0 ? estimate.estimatedCost : null,
+      quality: estimate.quality ?? null, qualitySource: estimate.qualitySource ?? 'unknown',
+      pricingSource: estimate.pricingSource ?? 'unknown', selectionSource: 'manual',
+      manualAssignment: { ...choice.target }, ...annotation(choice.target, choice.tool) }
+  })
+  const workPackages = packages.map((item, index) => {
+    const choice = choices[index], cost = costBreakdown[index]
+    return { ...withoutAllocation(item), recommendedProvider: choice.provider,
+      recommendedModel: choice.model, estimatedCost: cost.estimatedCost,
+      qualitySource: cost.qualitySource, pricingSource: cost.pricingSource,
+      manualAssignment: { ...choice.target }, selectionSource: 'manual',
+      algorithmRecommendation: { provider: item.recommendedProvider, model: item.recommendedModel,
+        channel: item.executionChannel }, ...annotation(choice.target, choice.tool) }
+  })
+  const originalSubtasks = new Map((plan.subtasks ?? []).map(item => [item.id, item]))
+  const subtasks = workPackages.map(item => ({ ...withoutAllocation(originalSubtasks.get(item.id) ?? item),
+    id: item.id, name: item.name, ...(item.objective !== undefined ? { objective: item.objective } : {}),
+    type: item.type, purpose: item.purpose, dependsOn: [...(item.dependsOn ?? [])],
+    recommendedProvider: item.recommendedProvider, recommended: item.recommendedModel,
+    estimatedCost: item.estimatedCost, qualitySource: item.qualitySource, pricingSource: item.pricingSource,
+    manualAssignment: { ...item.manualAssignment }, selectionSource: 'manual',
+    algorithmRecommendation: { ...item.algorithmRecommendation },
+    ...annotation(item.manualAssignment, choices[ids.indexOf(item.id)].tool) }))
+  // The public total stays unknown when any official-tool or API price is unknown.
+  const pricingComplete = costBreakdown.every(item => item.estimatedCost !== null)
+  const estimatedCost = pricingComplete ? costBreakdown.reduce((sum, item) => sum + item.estimatedCost, 0) : null
+  const budget = Number(plan.optimization?.budgetUsd)
+  const budgetUsd = Number.isFinite(budget) && budget > 0 ? budget : 0
+  const budgetExceeded = estimatedCost === null ? null : budgetUsd > 0 ? estimatedCost > budgetUsd : false
+  const selection = index => ({ provider: choices[index].provider, model: choices[index].model,
+    estimatedCost: costBreakdown[index].estimatedCost, qualitySource: costBreakdown[index].qualitySource,
+    pricingSource: costBreakdown[index].pricingSource, selectionSource: 'manual',
+    ...annotation(choices[index].target, choices[index].tool) })
+  const synthesisIndex = packages.findLastIndex(item => item.purpose === 'synthesis')
+  const originalOptimization = plan.optimization ?? {}
+  const clearedPlan = withoutAllocation(plan)
+  return { ...clearedPlan, assignmentMode: 'manual', manualAssignments: assignments, packagePlanKey: key,
+    selected: selection(0), synthesizer: plan.synthesizer ? selection(synthesisIndex >= 0 ? synthesisIndex : packages.length - 1) : null,
+    subtasks, team: { ...plan.team, workPackages }, costBreakdown, estimatedCost,
+    originalAlgorithmEstimate: plan.originalAlgorithmEstimate ?? plan.estimatedCost ?? null,
+    unassignableTasks: [], ...annotation(choices[0].target, choices[0].tool),
+    reason: '已按用户选择逐包分配模型与官方工具；执行目标不会因算法评分或预算而自动替换。',
+    pricingNotice: estimatedCost === null
+      ? '手动目标中有费用未知的模型或官方工具，无法确认总费用；工具费用不按原推荐模型计价。'
+      : '费用按手动选择的 API、默认推理档位和估计资源重算，不是供应商账单或硬性支出上限。',
+    qualityNotice: '手动分配由用户决定目标，尚未验证所选目标的任务质量；算法质量门槛不代表手动方案已经通过验证。',
+    toolNotice: '官方工具使用厂商自身配置的默认模型与推理档位，执行前由 Host 核验工具是否可用。',
+    optimization: { ...originalOptimization, manualAssignment: true, solver: 'manual-package-assignment',
+      search: null, optimalityScope: null, budgetUsd, budgetExceeded,
+      budgetFeasible: estimatedCost === null ? null : !budgetExceeded,
+      pricingComplete, qualityEvidenceComplete: false, constraintRelaxed: null,
+      baselineAllStrongCost: null, estimatedSavings: null, minimumFeasibleCost: null,
+      jointEffortCandidates: 0, qualityEvidenceCount: 0,
+      resourceEvidenceCount: costBreakdown.filter(item => item.estimateSource === 'recorded-resource-evidence').length,
+      distinctRoutes: new Set(choices.map(item => JSON.stringify(item.target))).size,
+      handoffCount: null, paretoPruned: 0, candidateTruncated: 0, qualityFiltered: 0,
+      qualityConstraintsEnforced: false },
+  }
+}

package/.dsh-plugin/shared/official-team-runtime.mjs

@@ -12,6 +12,7 @@ import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'nod
 import { runOfficialTool, officialToolExecutionCapabilities, officialToolReadiness } from './official-tool-executor.mjs'
 import { toolForProvider } from './official-tool-registry.mjs'
 import { redactDiagnostic, verifiedDiagnostic } from './task-executors.mjs'
+import { unsupportedCliReasoning } from './reasoning-execution.mjs'
 
 const MAX_GIT_OUTPUT = 64_000_000
 const GIT_TIMEOUT_MS = 120_000
@@ -455,12 +456,14 @@ export async function runOfficialTeam({ plan, task, workspace, allowedRoot, mode
     if (signal?.aborted) return { status: 'cancelled', workspace: runWorkspace, results: completed,
       ...(isolated ? { baseCommit: isolated.baseCommit } : {}), ...(seeded ? { seeded } : {}) }
     const cliModel = teamCliModel(item, configuredCliModels)
+    const prompt = packagePrompt(task, item, [...context, ...completed])
+    const startedAt = Date.now()
     let result
     try {
       result = await runTool({
         toolId: item.toolId,
         modelId: cliModel,
-        task: packagePrompt(task, item, [...context, ...completed]),
+        task: prompt,
         workspace: runWorkspace,
         mode,
         isolatedRoot: isolated?.isolatedRoot,
@@ -474,6 +477,7 @@ export async function runOfficialTeam({ plan, task, workspace, allowedRoot, mode
       // ledger and retry even when a later adapter rejects before returning.
       result = executionException(error, signal)
     }
+    const durationMs = Date.now() - startedAt
     const reportedModel = reportedCliModel(item.toolId, result.reportedModel)
     const modelMismatch = result.status === 'succeeded' && cliModel && reportedModel
       && cliModel !== reportedModel
@@ -481,6 +485,9 @@ export async function runOfficialTeam({ plan, task, workspace, allowedRoot, mode
     completed.push({ id: item.id, name: item.name,
       ...(item.objective ? { objective: item.objective } : {}), provider: item.recommendedProvider,
       recommendedModel: item.recommendedModel, toolId: item.toolId,
+      ...unsupportedCliReasoning({ reasoningEffort: item.recommendedReasoningEffort }),
+      ...(Number.isFinite(durationMs) && durationMs >= 0 ? { durationMs } : {}),
+      inputChars: prompt.length,
       requestedCliModel: Object.hasOwn(result, 'requestedModel') ? result.requestedModel : cliModel,
       actualModel: reportedModel,
       ...(result.reportedModel !== undefined ? { reportedModel: result.reportedModel } : {}),

package/.dsh-plugin/shared/official-tools-remote.mjs

@@ -6,6 +6,7 @@
  * accepts a command, package name, URL, argument vector, or executable path.
  */
 import { getOfficialTool, installMethodsFor } from './official-tool-registry.mjs'
+import { parsePackageAssignments } from './package-assignments.mjs'
 import {
   parseTerminalRead,
   parseTerminalResize,
@@ -157,6 +158,14 @@ export function parseRunRequest(value) {
   if (request.executionMode !== undefined && !['read-only', 'workspace-write'].includes(request.executionMode)) throw new TypeError('executionMode is invalid')
   if (request.executionEnvironment !== undefined && !['harness', 'cli-native'].includes(request.executionEnvironment)) throw new TypeError('executionEnvironment is invalid')
   const officialTeam = request.executor === 'official-team'
+  if (request.assignmentMode !== undefined && !['algorithm', 'manual'].includes(request.assignmentMode)) throw new TypeError('assignmentMode is invalid')
+  const manual = request.assignmentMode === 'manual'
+  if (manual && (officialTeam || provider || model)) throw new TypeError('manual assignments require routed work packages without an explicit global route')
+  if (!manual && (request.packageAssignments !== undefined || request.packagePlanKey !== undefined)) throw new TypeError('package assignments require manual assignmentMode')
+  const packageAssignments = manual ? parsePackageAssignments(request.packageAssignments) : undefined
+  if (manual && (!packageAssignments || typeof request.packagePlanKey !== 'string' || request.packagePlanKey.length > 200 || !request.packagePlanKey)) {
+    throw new TypeError('manual assignments require packageAssignments and a current packagePlanKey')
+  }
   if (officialTeam && (request.planMode !== 'team' || provider || model)) throw new TypeError('official-team requires a team plan without an explicit route')
   if (!officialTeam && request.executionMode === 'workspace-write') throw new TypeError('workspace-write requires official-team')
   if (request.executionEnvironment === 'cli-native' && (!officialTeam || request.executionMode !== 'workspace-write')) {
@@ -170,6 +179,7 @@ export function parseRunRequest(value) {
     ...(officialTeam ? { executor: 'official-team', executionMode: request.executionMode ?? 'read-only',
       ...(request.executionEnvironment === undefined ? {} : { executionEnvironment: request.executionEnvironment }) } : {}),
     ...(provider ? { provider, model } : {}),
+    ...(manual ? { assignmentMode: 'manual', packageAssignments, packagePlanKey: request.packagePlanKey } : {}),
     ...(['single', 'team'].includes(request.planMode) ? { planMode: request.planMode } : {}),
     ...(['economy', 'balanced', 'quality'].includes(request.preset) ? { preset: request.preset } : {}),
     ...(request.budgetUsd !== undefined ? { budgetUsd: request.budgetUsd } : {}),