@ljwei-stak/dsh-model-router 0.23.1 → 0.25.0

package/.dsh-plugin/index.mjs

@@ -13,6 +13,10 @@ import {
 } from './shared/subscription-billing.mjs'
 import { createRouterState } from './shared/router-state.mjs'
 import { createRunJobs } from './shared/run-jobs.mjs'
+import { createBudgetReservations, reservationSpending } from './shared/budget-reservations.mjs'
+import { beginExecutionLifecycle } from './shared/execution-lifecycle.mjs'
+import { attachPlanAccounting, accountingEstimates, initialFunding, planningFundingPrices } from './shared/execution-accounting.mjs'
+import { subscriptionUsage } from './shared/subscription-usage.mjs'
 import { applyFeedbackProfile, buildFeedbackProfile } from './shared/adaptive-feedback.mjs'
 import { buildRoutingEvidence, parseRoutingEvidenceJson } from './shared/routing-evidence.mjs'
 import { apiReasoningRequest } from './shared/reasoning-execution.mjs'
@@ -21,10 +25,10 @@ import { applyPricingSnapshot, createDynamicDataRefresher, dynamicDataSummary, r
 import { projectDynamicData } from './shared/dynamic-data-view.mjs'
 import {
   budgetCheck, buildRunRecord, formatUsd, buildTeamRunRecord, buildToolRunRecord, billingOf, mergeRerun,
-  spending, storedResults, actualCost, hasStartedQualityAttempts, teamExecutionResults,
+  spending, storedResults, actualCost, hasStartedQualityAttempts, teamExecutionResults, plannedPackages,
 } from './shared/run-ledger.mjs'
 import { routeBoundaries } from './shared/security-boundaries.mjs'
-import { createPlanFromRoutes } from './shared/harness-plan.mjs'
+import { createPlanFromRoutes, channelForProvider } from './shared/harness-plan.mjs'
 import { applyManualPackagePlan } from './shared/manual-plan.mjs'
 import { parsePackageAssignments, packagePlanKey } from './shared/package-assignments.mjs'
 import { applyModelProfiles, parseModelProfilesJson } from './shared/model-profiles.mjs'
@@ -377,13 +381,111 @@ function budgetSettings(config) {
   }
 }
 
-function budgetFor(config, saved, estimateUsd) {
+function budgetFor(config, saved, estimateUsd, { checkEstimate = true, apiExposure = true } = {}) {
   const settings = budgetSettings(config)
-  if ((saved.storageAvailable === false || saved.historyVerified === false) && (settings.dailyLimitUsd > 0 || settings.monthlyLimitUsd > 0)) {
+  if (apiExposure && (saved.storageAvailable === false || saved.historyVerified === false) && (settings.dailyLimitUsd > 0 || settings.monthlyLimitUsd > 0)) {
     throw new Error('无法读取费用历史，不能核验日/月预算；请恢复存储连接后再执行。')
   }
-  const spent = spending(saved.runs, undefined, saved.archivedSpending)
-  return { ...budgetCheck({ estimateUsd, spent, ...settings }), spent, ...settings }
+  const recorded = spending(saved.runs, undefined, saved.archivedSpending)
+  const reserved = reservationSpending(saved)
+  const spent = { ...recorded, today: recorded.today + reserved.today, month: recorded.month + reserved.month,
+    unknownToday: recorded.unknownToday + reserved.unknownToday, unknownMonth: recorded.unknownMonth + reserved.unknownMonth }
+  const check = budgetCheck({ estimateUsd, spent, ...settings })
+  if (!apiExposure) { check.exceeded = null; check.message = '订阅按用量单独统计，不占用 API 金额预算。' }
+  if (apiExposure && check.limited && (checkEstimate && !check.estimateKnown || settings.dailyLimitUsd > 0 && spent.unknownToday > 0
+    || settings.monthlyLimitUsd > 0 && spent.unknownMonth > 0) && !check.exceeded) {
+    check.exceeded = 'unknown'
+    check.message = '存在未核对费用或缺少单价，无法核验预算；请先核对账单或明确确认继续。'
+  }
+  return { ...check, spent, reserved, ...settings, apiExposure }
+}
+
+function pausedExecutionBudget(lifecycle) {
+  if (['history-incomplete', 'active-run', 'reservation-capacity'].includes(lifecycle.reason)) {
+    throw new Error(lifecycle.reason === 'active-run' ? '该运行仍在执行或费用待核对，不能重复启动。'
+      : lifecycle.reason === 'history-incomplete' ? '费用历史不完整，不能核验执行预算。' : '待核对运行过多，请先核对执行记录和费用。')
+  }
+  return { ...lifecycle.budget, paused: true, exceeded: lifecycle.budget?.exceeded ?? 'unknown' }
+}
+
+function accountingContext(billing = null, routes = [], officialCli = false) {
+  return { billing: billing ? { ...billing, routes } : null, officialCli,
+    loginBillingFor: id => subscriptionLoginOf(healthCache.loginState(id)), apiKeyFor: id => apiKeyEnvPresent(id) }
+}
+
+function packageEstimates(plan, task) {
+  if (plan.accounting) return accountingEstimates(plan)
+  return plannedPackages(plan, task).map(item => ({ id: item.id, estimatedCostUsd: item.estimatedCost ?? null }))
+}
+
+/** Activate API money accounting only at the actual API dispatch boundary. */
+async function reserveChangedApiRoute(lifecycle, expected, route, task, config, confirmOverBudget) {
+  const id = lifecycle.activePackageId()
+  if (!id) throw new Error('缺少执行检查点，不能启动 API 路线。')
+  const previous = lifecycle.results().find(item => item.id === id)
+  const held = lifecycle.reservationFor(id)
+  const unchanged = expected?.provider === route.provider && expected?.model === route.model
+  const saved = await routingSavedState(config)
+  const estimate = held?.billing === 'api' && unchanged ? held.estimatedCostUsd
+    : createPlanFromRoutes(task, [route], { ...planDataOptions(saved, config),
+      mode: 'direct', directProvider: route.provider, directModel: route.model }).estimatedCost
+  const reserved = await lifecycle.reserveExtra(id, estimate, { confirmOverBudget: confirmOverBudget === true })
+  if (!reserved.accepted) return { ok: false, notStarted: true,
+    subscriptionAttempts: previous?.subscriptionAttempts ?? [],
+    error: `实际 API 路线预算未确认，已停止调用。${reserved.budget.message}` }
+  if (held?.billing === 'subscription' || previous?.billing === 'subscription') {
+    await lifecycle.partialResult({ id, provider: route.provider, model: route.model, billing: 'api',
+      channel: 'harness-llm', ok: false, notStarted: true, answer: '', usage: null,
+      subscriptionAttempts: previous?.subscriptionAttempts ?? [] }, { checkBudget: true })
+  }
+  return null
+}
+
+async function checkpointSubscription(lifecycle, event) {
+  await lifecycle.partialResult({ ...event, billing: 'subscription', channel: event.channel ?? 'harness-llm',
+    ok: false, answer: '', subscriptionAttempts: event.subscriptionAttempts ?? [event] })
+}
+
+/** A changed budget stops before dispatch; storage failures retain their hold. */
+async function stopExecutionLifecycle(lifecycle, error, run = lifecycle.current('interrupted')) {
+  if (error?.code === 'ROUTER_BUDGET_CHANGED') {
+    run.status = 'paused-budget'
+    run.error = error.message
+    run.finishedAt = Date.now()
+    try { await lifecycle.finish(run); error.runId = run.id; return true }
+    catch { await lifecycle.interrupt(run); return false }
+  }
+  await lifecycle.interrupt(run)
+  return false
+}
+
+/** The independent-opinion tool uses the same durable API budget boundary. */
+export async function executeBudgetedConsult(ctx, route, task, config = {}, { signal, limit = 12_000, confirmOverBudget = false, routes = [] } = {}) {
+  const problem = taskTextProblem(text(task))
+  if (problem) throw new Error(problem)
+  const catalog = [route, ...routes.filter(item => item.provider !== route.provider || item.model !== route.model)]
+  const funding = initialFunding(route, { billing: { routes: catalog }, executionChannel: 'harness-llm' })
+  route = catalog.find(item => item.provider === funding.route?.provider && item.model === funding.route?.model) ?? funding.route
+  const plan = createPlanFromRoutes(task, [route], { mode: 'direct', directProvider: route.provider, directModel: route.model })
+  plan.accounting = { apiExposure: funding.billing === 'api', apiEstimatedCostUsd: funding.billing === 'subscription' ? 0 : plan.estimatedCost,
+    packages: [{ id: 'direct', billing: funding.billing, apiEstimatedCostUsd: funding.billing === 'subscription' ? 0 : plan.estimatedCost }] }
+  const id = randomUUID(), at = Date.now()
+  const record = (status, results) => buildRunRecord({ id, createdAt: at, finishedAt: Date.now(), task, plan,
+    execution: { status, packages: results }, workspace: process.cwd(), pricingFor: () => route.pricing ?? null, billingFor: () => funding.billing })
+  const lifecycle = await beginExecutionLifecycle({ state: routerStateStore(), buildRun: ({ status, results }) => record(status, results),
+    packageEstimates: packageEstimates(plan, task), settings: budgetSettings(config), confirmOverBudget })
+  if (!lifecycle.accepted) return { status: 'paused-budget', paused: true, budget: pausedExecutionBudget(lifecycle), ok: false }
+  let result
+  try {
+    await lifecycle.onCheckpointStart({ id: 'direct', provider: route.provider, model: route.model, channel: 'harness-llm' })
+    result = await consultConfiguredModel(ctx, route, task, limit, signal)
+    const receipt = { ...result, id: 'direct', provider: route.provider, model: route.model, channel: 'harness-llm', billing: funding.billing, finishedAt: Date.now() }
+    if (funding.billing === 'subscription') receipt.subscriptionAttempts = [{ provider: route.provider, model: route.model,
+      usage: result.usage ?? null, usageIncomplete: result.usageIncomplete === true, notStarted: result.notStarted === true, finishedAt: receipt.finishedAt }]
+    await lifecycle.onCheckpointResult(receipt)
+    await lifecycle.finish(record(result.cancelled ? 'cancelled' : result.ok ? 'completed' : 'failed', lifecycle.results()))
+  } catch (error) { await stopExecutionLifecycle(lifecycle, error); throw error }
+  return { ...result, billing: funding.billing, accounting: plan.accounting, runId: id }
 }
 
 /**
@@ -392,6 +494,11 @@ function budgetFor(config, saved, estimateUsd) {
  */
 export function billingForResult(result) {
   const toolId = result?.toolId ?? null
+  if (result?.billing === 'unknown') return 'unknown'
+  const login = toolId ? subscriptionLoginOf(healthCache.loginState(toolId)) : 'unknown'
+  if (result?.channel === 'official-cli' && !result.billing
+    && !['configured-api-key', 'process-environment'].includes(result.credentialSource)
+    && !apiKeyEnvPresent(toolId) && !['api-key', 'subscription'].includes(login)) return 'unknown'
   return billingOf(result, {
     loginBilling: toolId ? healthCache.loginState(toolId)?.billing ?? null : null,
     apiKeyPresent: toolId ? apiKeyEnvPresent(toolId) : false,
@@ -496,14 +603,19 @@ export async function createRoutePlan(ctx, task, config = {}, options = {}) {
   const loggedOut = options.skipToolProbe === true
     ? (Array.isArray(options.loggedOutToolIds) ? options.loggedOutToolIds : [])
     : loggedOutIds(await currentHealth())
+  const planningBilling = await billingContext(config, options)
+  const context = accountingContext(planningBilling, availableRoutes)
+  const fundingPrices = planningFundingPrices(availableRoutes, context, route => channelForProvider(route.provider, installed, [...executable], route, loggedOut).kind)
   const plan = createPlanFromRoutes(taskText, availableRoutes, {
-    ...planDataOptions(saved, config),
+    ...planDataOptions(saved, config), pricing: fundingPrices.pricing,
     mode, budgetUsd, installedToolIds: installed,
     runnableToolIds: installed.filter(id => executable.has(id)),
     preset: routingPresetOf(config, options.preset),
     loggedOutToolIds: loggedOut,
   })
-  return { ...plan, packagePlanKey: packagePlanKey(plan, taskText), budgetStatus: budgetFor(config, saved, plan.estimatedCost) }
+  plan.subscriptionPricedRoutes = fundingPrices.subscriptionPricedRoutes
+  attachPlanAccounting(plan, taskText, availableRoutes, context)
+  return { ...plan, packagePlanKey: packagePlanKey(plan, taskText), budgetStatus: budgetFor(config, saved, plan.accounting.apiEstimatedCostUsd, { apiExposure: plan.accounting.apiExposure }) }
 }
 
 /** One bounded, independent call through the same official LLM service. */
@@ -674,7 +786,7 @@ function reviewScore(answer) {
  * 质量回路: a stronger configured model spot-checks answers from cheaper
  * routes. `sample` reviews a random share; `always` reviews every cheaper answer.
  */
-export async function reviewRunPackages(ctx, run, routes, config, { signal, random = Math.random } = {}) {
+export async function reviewRunPackages(ctx, run, routes, config, { signal, random = Math.random, lifecycle } = {}) {
   const mode = valueOf(config, 'reviewMode', 'off')
   if (mode !== 'sample' && mode !== 'always') return []
   const rate = Math.min(1, Math.max(0, finiteNumber(valueOf(config, 'reviewSampleRate', 0.2), 0.2)))
@@ -696,6 +808,24 @@ export async function reviewRunPackages(ctx, run, routes, config, { signal, rand
       `工作包：${item.name}\n${item.objective.slice(0, 1_500)}`,
       `待审结果：\n${item.answer.slice(0, 3_500)}`,
     ].join('\n\n')
+    const reviewId = `review:${item.id}`
+    let pendingReview = null
+    if (lifecycle) {
+      const estimate = createPlanFromRoutes(prompt, [reviewer], { mode: 'direct', directProvider: reviewer.provider,
+        directModel: reviewer.model }).estimatedCost
+      const reserved = await lifecycle.reserveExtra(reviewId, estimate)
+      if (!reserved.accepted) { item.review = { score: null, summary: '预算未确认，已跳过额外审阅。', at: Date.now() }; continue }
+      pendingReview = { id: reviewId, packageId: item.id, provider: reviewer.provider, model: reviewer.model,
+        status: 'running', inFlight: true, ran: false, costUsd: null, billing: 'api', finishedAt: Date.now() }
+      run.reviews.push(pendingReview)
+      try { await lifecycle.saveRun(run, { startedIds: [reviewId] }) }
+      catch (error) {
+        if (error.code !== 'ROUTER_BUDGET_CHANGED') throw error
+        run.reviews = run.reviews.filter(entry => entry !== pendingReview)
+        item.review = { score: null, summary: '预算已变化，已跳过额外审阅。', at: Date.now() }
+        break
+      }
+    }
     try {
       const result = await consultConfiguredModel(ctx, reviewer, prompt, 1_200, signal)
       const score = result.ok ? reviewScore(result.answer) : null
@@ -707,9 +837,16 @@ export async function reviewRunPackages(ctx, run, routes, config, { signal, rand
       }
       const cost = actualCost(result, reviewer.pricing ?? null)
       const entry = { packageId: item.id, provider: reviewer.provider, model: reviewer.model, ran: true, finishedAt: Date.now(), usage: result.usage ?? null, ...cost, billing: 'api', referenceCostUsd: null }
-      run.reviews.push(entry)
+      if (pendingReview) Object.assign(pendingReview, entry, { status: 'completed', inFlight: false })
+      else run.reviews.push(entry)
       reviews.push({ ...entry, score })
+      if (lifecycle) await lifecycle.saveRun(run, { completedIds: [reviewId] })
     } catch (error) {
+      if (error.code === 'ROUTER_CHECKPOINT_FAILED') throw error
+      if (pendingReview) {
+        Object.assign(pendingReview, { status: 'failed', inFlight: false, ran: true, costUsd: null, finishedAt: Date.now() })
+        await lifecycle.saveRun(run, { completedIds: [reviewId] })
+      }
       if (signal?.aborted) break
       item.review = { provider: reviewer.provider, model: reviewer.model, score: null, summary: `审阅失败：${errorText(error).slice(0, 200)}`, at: Date.now() }
     }
@@ -724,6 +861,9 @@ async function reportRunProgress(options, event) {
 
 function executionHooks(ctx, options) {
   return {
+    onCheckpointStart: options.onCheckpointStart,
+    onCheckpointResult: options.onCheckpointResult,
+    onSubscriptionResult: options.onSubscriptionResult,
     skipOfficial: options.skipOfficial ?? (request => healthCache.skipReason(request)),
     onStage: stage => reportRunProgress(options, { type: 'stage', stage }),
     onPackageStart: async item => {
@@ -785,32 +925,38 @@ export async function planAssignment(ctx, task, config = {}, options = {}) {
     ? (Array.isArray(options.loggedOutToolIds) ? options.loggedOutToolIds : [])
     : loggedOutIds(await currentHealth())
   const preset = routingPresetOf(config, options.preset)
-  const planWith = (presetId, budgetUsd) => direct
+  const planningBilling = await billingContext(config, options)
+  const fundingPrices = planningFundingPrices(routes, accountingContext(planningBilling, routes),
+    route => channelForProvider(route.provider, installed, runnableToolIds, route, loggedOut).kind)
+  const buildWith = (presetId, budgetUsd) => direct
     ? createPlanFromRoutes(taskText, routes, {
-      ...planDataOptions(saved, config),
+      ...planDataOptions(saved, config), pricing: fundingPrices.pricing,
       mode: 'direct', directProvider: options.provider, directModel: options.model,
       installedToolIds: installed, runnableToolIds, preset: presetId, loggedOutToolIds: loggedOut,
     })
     : createPlanFromRoutes(taskText, routes, {
-      ...planDataOptions(saved, config),
+      ...planDataOptions(saved, config), pricing: fundingPrices.pricing,
       mode: options.planMode === 'team' ? 'team' : 'single',
       budgetUsd, installedToolIds: installed, runnableToolIds, preset: presetId, loggedOutToolIds: loggedOut,
     })
+  const planWith = (...args) => { const result = buildWith(...args); result.subscriptionPricedRoutes = fundingPrices.subscriptionPricedRoutes; return result }
   let plan = planWith(preset, options.budgetUsd)
   if (manual) {
     plan = applyManualPackagePlan(plan, { task: taskText, packageAssignments: options.packageAssignments,
       packagePlanKey: options.packagePlanKey }, routes, planDataOptions(saved, config))
     await validateManualTools(ctx, plan.manualAssignments, { ...options, installedToolIds: installed, readiness })
   }
-  let budget = budgetFor(config, saved, plan.estimatedCost)
+  attachPlanAccounting(plan, taskText, routes, accountingContext(planningBilling, routes))
+  let budget = budgetFor(config, saved, plan.accounting.apiEstimatedCostUsd, { apiExposure: plan.accounting.apiExposure })
   const perRunLimit = Number(options.budgetUsd) || 0
-  if (manual && perRunLimit > 0 && (plan.estimatedCost === null || plan.estimatedCost > perRunLimit)) {
-    budget = { ...budget, exceeded: budget.exceeded || 'run', estimateUsd: plan.estimatedCost,
-      message: plan.estimatedCost === null ? '手动分配包含费用未知的目标，无法确认满足本次预算。' : '手动分配的预估费用超出本次预算。' }
+  if (manual && perRunLimit > 0 && (plan.accounting.apiEstimatedCostUsd === null || plan.accounting.apiEstimatedCostUsd > perRunLimit)) {
+    budget = { ...budget, exceeded: budget.exceeded || 'run', estimateUsd: plan.accounting.apiEstimatedCostUsd,
+      message: plan.accounting.apiEstimatedCostUsd === null ? '手动分配包含费用未知的目标，无法确认满足本次预算。' : '手动分配的预估费用超出本次预算。' }
   }
   if (budget.exceeded && budget.action === 'downgrade' && !direct && !manual) {
     const cheaper = planWith('economy', budget.remainingUsd > 0 ? budget.remainingUsd : options.budgetUsd)
-    const recheck = budgetFor(config, saved, cheaper.estimatedCost)
+    attachPlanAccounting(cheaper, taskText, routes, accountingContext(planningBilling, routes))
+    const recheck = budgetFor(config, saved, cheaper.accounting.apiEstimatedCostUsd, { apiExposure: cheaper.accounting.apiExposure })
     if (!recheck.exceeded) {
       budget = { ...recheck, downgraded: true, downgradedFrom: preset,
         message: `原方案${budget.message} 已自动降级为“省钱优先”方案（预估 ${cheaper.estimatedCost === null ? '价格待配置' : formatUsd(cheaper.estimatedCost)}）。` }
@@ -861,7 +1007,11 @@ function apiUpgradeEligible(route, routes) {
 
 /** Route, or honor one explicit model, then run each package through its adapter. */
 export async function executeConfiguredAssignment(ctx, task, config = {}, options = {}) {
-  const { taskText, direct, plan, budget, routes, preset } = options.preparedAssignment ?? await planAssignment(ctx, task, config, options)
+  const { taskText, direct, plan, budget: previewBudget, routes, preset } = options.preparedAssignment ?? await planAssignment(ctx, task, config, options)
+  const billing = await billingContext(config, options)
+  attachPlanAccounting(plan, taskText, routes, accountingContext(billing, routes))
+  const budget = { ...previewBudget, ...budgetFor(config, await savedState(), plan.accounting.apiEstimatedCostUsd, { apiExposure: plan.accounting.apiExposure }) }
+  if (plan.accounting.apiExposure && previewBudget.exceeded === 'run') Object.assign(budget, { exceeded: 'run', message: previewBudget.message })
   if (budget.exceeded && options.confirmOverBudget !== true) {
     return {
       plan, execution: null, paused: true,
@@ -874,12 +1024,26 @@ export async function executeConfiguredAssignment(ctx, task, config = {}, option
     finished.push(result)
     if (typeof options.onPackage === 'function') await options.onPackage(result)
   } })
-  const billing = await billingContext(config, options)
   const limit = boundedInteger(valueOf(config, 'maxConsultOutputChars', 12_000), 12_000, 500, 50_000)
   const startedAt = Date.now()
+  const runId = randomUUID()
+  const makeRecord = execution => buildRunRecord({ id: runId, createdAt: startedAt, finishedAt: Date.now(),
+    task: taskText, plan, execution, preset: plan.preset ?? preset, workspace: options.workspace ?? '',
+    pricingFor: item => routePricing(routes, item), billingFor: billingForResult,
+    budget: { estimateUsd: budget.estimateUsd, exceeded: budget.exceeded, downgraded: budget.downgraded === true,
+      confirmed: options.confirmOverBudget === true } })
+  const lifecycle = await beginExecutionLifecycle({ state: routerStateStore(),
+    packageEstimates: packageEstimates(plan, taskText), settings: budgetSettings(config),
+    confirmOverBudget: options.confirmOverBudget === true,
+    buildRun: ({ status, results }) => makeRecord({ status, packages: results }) })
+  if (!lifecycle.accepted) return { plan, execution: null, paused: true, budget: pausedExecutionBudget(lifecycle) }
   const gate = parseQualityGateJson(valueOf(config, 'qualityGateJson', ''))
   const gatedApi = async ({ route, task: packageTask, signal, subscription }) => {
     if (subscription) return consultConfiguredModel(ctx, route, packageTask, limit, signal)
+    const plannedPackage = plannedPackages(plan, taskText).find(item => item.id === lifecycle.activePackageId())
+    const denied = await reserveChangedApiRoute(lifecycle, { provider: plannedPackage?.recommendedProvider,
+      model: plannedPackage?.recommendedModel }, route, packageTask, config, options.confirmOverBudget)
+    if (denied) return denied
     const quality = routeQuality(route)
     const alternatives = gate && !direct && route.manualPinned !== true && apiUpgradeEligible(route, routes)
       && valueOf(config, 'qualityEscalationEnabled', false) === true && quality !== null
@@ -906,10 +1070,23 @@ export async function executeConfiguredAssignment(ctx, task, config = {}, option
           && (result.blocked || result.notStarted || billingForResult(result) === 'subscription') ? { costUsd: 0 }
           : actualCost(result, routePricing(routes, result))), ...attempts.map(result => actualCost(result, result.pricingSnapshot))]
         const pending = plan.costBreakdown.slice(finished.length + 1).map(item => item.estimatedCost)
-        if (costs.some(item => item.costUsd === null) || pending.some(value => !Number.isFinite(value))) return !constrained
-        const projected = costs.reduce((sum, item) => sum + item.costUsd, estimate) + pending.reduce((sum, value) => sum + value, 0)
-        if (!Number.isFinite(projected) || perRunLimit > 0 && projected > perRunLimit) return false
-        return !budgetFor(config, saved, projected).exceeded
+        const unknownProjection = costs.some(item => item.costUsd === null) || pending.some(value => !Number.isFinite(value))
+        if (unknownProjection && constrained) return false
+        const projected = unknownProjection ? null
+          : costs.reduce((sum, item) => sum + item.costUsd, estimate) + pending.reduce((sum, value) => sum + value, 0)
+        if (!unknownProjection && (!Number.isFinite(projected) || perRunLimit > 0 && projected > perRunLimit)) return false
+        const id = lifecycle.activePackageId()
+        if (!id) return false
+        const subscriptionAttempts = lifecycle.results().find(item => item.id === id)?.subscriptionAttempts ?? []
+        await lifecycle.partialResult({ ...attempts.at(-1), id, ok: false, subscriptionAttempts, qualityAttempts: attempts })
+        if (!(await lifecycle.reserveExtra(id, estimate)).accepted) return false
+        // The extra request can be charged before its receipt arrives. Persist
+        // both the first receipt and the unknown second attempt before dispatch.
+        await lifecycle.partialResult({ ...attempts.at(-1), id, ok: false, subscriptionAttempts, qualityAttempts: [...attempts, {
+          provider: to.provider, model: to.model, channel: 'harness-llm', ok: false,
+          usage: null, usageIncomplete: true, pricingSnapshot: to.pricing ?? null, finishedAt: Date.now(),
+        }] }, { checkBudget: true })
+        return true
       },
     })
   }
@@ -922,40 +1099,50 @@ export async function executeConfiguredAssignment(ctx, task, config = {}, option
       workspace: options.workspace,
       signal: options.signal,
       ...hooks,
-      billing,
+      onCheckpointStart: item => lifecycle.onCheckpointStart(item),
+      onCheckpointResult: result => lifecycle.onCheckpointResult(result),
+      onSubscriptionResult: event => checkpointSubscription(lifecycle, event),
+      billing: billing ? { ...billing, routes } : null,
       apiFallback: gatedApi,
     })
   } catch (error) {
     // Steps that already ran (and may have been paid for) are always recorded with their spend.
     const message = String(error?.message ?? error)
-    const partial = { status: options.signal?.aborted ? 'cancelled' : 'failed', packages: finished, aggregate: '', error: message }
+    const receipts = new Map([...finished, ...lifecycle.results(), ...(error.execution?.packages ?? [])].map(item => [item.id, item]))
+    const partial = { status: options.signal?.aborted ? 'cancelled' : 'failed', packages: [...receipts.values()], aggregate: '', error: message }
     const run = buildRunRecord({
-      id: randomUUID(), createdAt: startedAt, finishedAt: Date.now(), task: taskText, plan, execution: partial,
+      id: runId, createdAt: startedAt, finishedAt: Date.now(), task: taskText, plan, execution: partial,
       preset: plan.preset ?? preset, workspace: options.workspace ?? '',
       pricingFor: item => routePricing(routes, item), billingFor: billingForResult,
       budget: { estimateUsd: budget.estimateUsd, exceeded: budget.exceeded, downgraded: budget.downgraded === true, confirmed: budget.exceeded ? true : undefined },
     })
     run.error = message.slice(0, 2_000)
     let stored = true
-    try { await routerStateStore().appendRun(run) } catch { stored = false }
+    try {
+      if (error.code === 'ROUTER_BUDGET_CHANGED') stored = await stopExecutionLifecycle(lifecycle, error, run)
+      else if (error.code === 'ROUTER_CHECKPOINT_FAILED') { await lifecycle.interrupt(run); stored = false }
+      else await lifecycle.finish(run)
+    } catch { stored = false; await lifecycle.interrupt(run) }
     const wrapped = new Error(`${message}${finished.length ? `（已完成 ${finished.length} 个步骤，${stored ? `已记录到运行 ${run.id}，费用计入预算` : '但运行记录保存失败'}）` : ''}`)
     wrapped.runId = stored ? run.id : null
     wrapped.cause = error
     throw wrapped
   }
   const run = buildRunRecord({
-    id: randomUUID(), createdAt: startedAt, finishedAt: Date.now(), task: taskText, plan, execution,
+    id: runId, createdAt: startedAt, finishedAt: Date.now(), task: taskText, plan, execution,
     preset: plan.preset ?? preset, workspace: options.workspace ?? '',
     pricingFor: item => routePricing(routes, item),
     billingFor: billingForResult,
     budget: { estimateUsd: budget.estimateUsd, exceeded: budget.exceeded, downgraded: budget.downgraded === true, confirmed: budget.exceeded ? true : undefined },
   })
   await reportRunProgress(options, { type: 'stage', stage: 'reviewing' })
-  const reviews = await reviewRunPackages(ctx, run, routes, config, { signal: options.signal, random: options.random })
+  let reviews
+  try { reviews = await reviewRunPackages(ctx, run, routes, config, { signal: options.signal, random: options.random, lifecycle }) }
+  catch (error) { await lifecycle.interrupt(run); throw error }
   if (options.signal?.aborted) { run.status = 'cancelled'; execution.status = 'cancelled' }
   await reportRunProgress(options, { type: 'stage', stage: 'saving' })
   let stored = true
-  try { await routerStateStore().appendRun(run) } catch { stored = false }
+  try { await lifecycle.finish(run) } catch { stored = false; await lifecycle.interrupt(run) }
   const awaiting = pausedSteps(execution)
   return { plan, execution, budget, runId: run.id, run, reviews, stored, ...(awaiting.length ? { awaitingConfirmation: awaiting } : {}) }
 }
@@ -1022,6 +1209,7 @@ function rerunEstimates(run, ids, targetId, override, routes, dataOptions) {
 
 export async function rerunRecordedStep(ctx, config = {}, { runId, packageId, provider, model, confirmOverBudget = false, confirmWrite = false, confirmUnsandboxed = false, subscriptionChoice = null, workspace, root, signal, ...options } = {}) {
   const { run, saved } = await storedRun(runId)
+  if (saved.budgetReservations?.[run.id]) throw new Error('该运行仍在执行或费用待核对，请先核对原任务与厂商账单，不能直接重跑。')
   const target = run.packages.find(item => item.id === text(packageId))
   if (!target) throw new Error(`运行记录中没有工作包 ${text(packageId)}`)
   const choice = text(subscriptionChoice) || null
@@ -1061,14 +1249,24 @@ export async function rerunRecordedStep(ctx, config = {}, { runId, packageId, pr
   const retryIds = new Set([target.id, ...downstreamPackageIds(run.packages, target.id)
     .filter(id => run.packages.find(item => item.id === id)?.ok !== true)])
   const estimates = rerunEstimates(run, retryIds, target.id, override, routes, planDataOptions(refreshed, config))
-  const budget = budgetFor(config, saved, estimates.total)
+  const retryBilling = await billingContext(config, options)
+  const retryPlan = teamPlanFromRun(run, [...retryIds], override, target.id, estimates.byId)
+  if (run.kind !== 'team') for (const item of retryPlan.team.workPackages) {
+    const previous = run.packages.find(entry => entry.id === item.id)
+    if (!override || item.id !== target.id) { item.recommendedProvider = previous.provider ?? previous.recommendedProvider; item.recommendedModel = previous.model ?? previous.recommendedModel }
+  }
+  const retryContext = accountingContext(retryBilling, routes, run.kind === 'team')
+  retryContext.billingChoices = choice ? { [target.id]: choice } : {}
+  attachPlanAccounting(retryPlan, run.task, routes, retryContext)
+  estimates.reservations = accountingEstimates(retryPlan)
+  const budget = budgetFor(config, saved, retryPlan.accounting.apiEstimatedCostUsd, { apiExposure: retryPlan.accounting.apiExposure })
   if (budget.exceeded && confirmOverBudget !== true) {
     return { paused: true, budget: { ...budget, paused: true, message: `${budget.message} 已暂停重跑，请确认后再试。` }, run }
   }
   const cwd = text(workspace) || run.workspace
   if (!cwd || !(await fileExists(cwd))) throw new Error(`原运行的工作区 ${cwd || '(未记录)'} 不可用，无法重跑该步骤；请恢复该目录，或在原工作区的会话中调用 model_router_rerun_step。`)
   if (run.kind === 'team') return rerunTeamStep(ctx, { run, target, override, routes, budget,
-    ids: [...retryIds], estimates: estimates.byId, cwd, root: text(root) || cwd, signal, options, config })
+    ids: [...retryIds], estimates: estimates.byId, reservations: estimates.reservations, confirmOverBudget, cwd, root: text(root) || cwd, signal, options, config })
   const manualRetries = Object.fromEntries(run.packages.filter(item => retryIds.has(item.id) && item.manualAssignment)
     .map(item => [item.id, item.id === target.id && override ? { kind: 'api', ...override } : item.manualAssignment]))
   if (Object.keys(manualRetries).length) {
@@ -1088,7 +1286,18 @@ export async function rerunRecordedStep(ctx, config = {}, { runId, packageId, pr
   }
   const limit = boundedInteger(valueOf(config, 'maxConsultOutputChars', 12_000), 12_000, 500, 50_000)
   const retryGate = parseQualityGateJson(valueOf(config, 'qualityGateJson', ''))
-  const execution = await rerunAssignmentPackage({
+  const buildRetry = ({ status, results }) => {
+    const next = structuredClone(run)
+    mergeRerun(next, { status, packages: results }, { rerunIds: [...retryIds], pricingFor: item => routePricing(routes, item), billingFor: billingForResult })
+    for (const item of next.packages) if (retryIds.has(item.id)) item.estimatedCost = estimates.byId.get(item.id) ?? null
+    return next
+  }
+  const lifecycle = await beginExecutionLifecycle({ state: routerStateStore(), buildRun: buildRetry,
+    packageEstimates: estimates.reservations,
+    settings: budgetSettings(config), confirmOverBudget })
+  if (!lifecycle.accepted) return { paused: true, run, budget: pausedExecutionBudget(lifecycle) }
+  let execution
+  try { execution = await rerunAssignmentPackage({
     task: run.task,
     packages: run.packages.map(item => ({
       id: item.id, name: item.name, objective: item.objective, dependsOn: item.dependsOn,
@@ -1108,17 +1317,22 @@ export async function rerunRecordedStep(ctx, config = {}, { runId, packageId, pr
     signal,
     ...(choice ? { subscriptionChoice: choice } : {}),
     ...executionHooks(ctx, options),
-    billing: await billingContext(config, options),
-    apiFallback: async ({ route, task: packageTask, signal: callSignal, subscription }) => subscription
-      ? consultConfiguredModel(ctx, route, packageTask, limit, callSignal)
-      : consultWithQualityGate(ctx, route, packageTask, limit, callSignal, { gate: retryGate }),
-  })
-  const updated = await routerStateStore().updateRun(run.id, current => {
-    mergeRerun(current, execution, { rerunIds: execution.ranIds, pricingFor: item => routePricing(routes, item), billingFor: billingForResult })
-    for (const item of current.packages) {
-      if (execution.ranIds.includes(item.id)) item.estimatedCost = estimates.byId.get(item.id) ?? null
-    }
-  })
+    onCheckpointStart: item => lifecycle.onCheckpointStart(item),
+    onCheckpointResult: result => lifecycle.onCheckpointResult(result),
+    onSubscriptionResult: event => checkpointSubscription(lifecycle, event),
+    billing: retryBilling,
+    apiFallback: async ({ route, task: packageTask, signal: callSignal, subscription }) => {
+      if (subscription) return consultConfiguredModel(ctx, route, packageTask, limit, callSignal)
+      const id = lifecycle.activePackageId()
+      const previous = run.packages.find(item => item.id === id)
+      const expected = override && id === target.id ? override
+        : { provider: previous?.provider ?? previous?.recommendedProvider, model: previous?.model ?? previous?.recommendedModel }
+      const denied = await reserveChangedApiRoute(lifecycle, expected, route, packageTask, config, confirmOverBudget)
+      return denied ?? consultWithQualityGate(ctx, route, packageTask, limit, callSignal, { gate: retryGate })
+    },
+  }) } catch (error) { await stopExecutionLifecycle(lifecycle, error); throw error }
+  const updated = buildRetry({ status: execution.status, results: execution.packages })
+  try { await lifecycle.finish(updated) } catch (error) { await lifecycle.interrupt(updated); throw error }
   const awaiting = pausedSteps(execution)
   return { run: updated, execution, budget, ...(awaiting.length ? { awaitingConfirmation: awaiting } : {}) }
 }
@@ -1162,7 +1376,7 @@ function teamPlanFromRun(run, ids, override, targetId, estimates) {
  * Read-only team retry: the failed step plus downstream steps that had not
  * succeeded run through the same signed runner; earlier answers are context.
  */
-async function rerunTeamStep(ctx, { run, target, override, routes, budget, ids, estimates, cwd, root, signal, options, config = {} }) {
+async function rerunTeamStep(ctx, { run, target, override, routes, budget, ids, estimates, reservations, confirmOverBudget, cwd, root, signal, options, config = {} }) {
   const mode = run.executionMode === 'workspace-write' ? 'workspace-write' : 'read-only'
   const executionEnvironment = teamExecutionEnvironment(run.executionEnvironment, mode)
   const plan = teamPlanFromRun(run, ids, override, target.id, estimates)
@@ -1175,10 +1389,31 @@ async function rerunTeamStep(ctx, { run, target, override, routes, budget, ids,
     .map(item => ({ id: item.id, name: item.name, finalText: item.answer }))
   const runTeam = options.runTeam ?? runOfficialTeam
   const installed = Array.isArray(options.installedToolIds) ? options.installedToolIds : await installedToolIds()
-  const execution = await runTeam({ plan, task: run.task, workspace: cwd, allowedRoot: root ?? cwd, mode, executionEnvironment,
+  const buildRetry = ({ status, results, workspace = {} }) => {
+    const next = structuredClone(run)
+    const converted = teamExecutionResults(plan, { status, results })
+    if (override) {
+      const item = converted.packages.find(item => item.id === target.id)
+      if (item) item.reassigned = true
+    }
+    mergeRerun(next, converted, { rerunIds: ids, pricingFor: item => routePricing(routes, item), billingFor: billingForResult })
+    for (const item of next.packages) if (ids.includes(item.id)) item.estimatedCost = estimates.get(item.id) ?? null
+    next.executionEnvironment = executionEnvironment
+    if (mode === 'workspace-write' && workspace.workspace) next.isolatedWorkspace = workspace.workspace
+    if (workspace.baseCommit) next.baseCommit = workspace.baseCommit
+    return next
+  }
+  const lifecycle = await beginExecutionLifecycle({ state: routerStateStore(), buildRun: buildRetry,
+    packageEstimates: reservations, settings: budgetSettings(config), confirmOverBudget })
+  if (!lifecycle.accepted) return { paused: true, run, budget: pausedExecutionBudget(lifecycle) }
+  let execution
+  try { execution = await runTeam({ plan, task: run.task, workspace: cwd, allowedRoot: root ?? cwd, mode, executionEnvironment,
     installedIds: installed, cliModels, signal, sandbox: ctx.sandbox, previous, onlyIds: ids,
+    onCheckpointStart: item => lifecycle.onCheckpointStart(item), onCheckpointResult: result => lifecycle.onCheckpointResult(result),
+    onWorkspace: value => lifecycle.onWorkspace(value),
     ...(mode === 'workspace-write' ? { seedFrom: { workspace: run.isolatedWorkspace, baseCommit: run.baseCommit } } : {}),
-    ...(options.runtime ? { runtime: options.runtime } : {}) })
+    ...(options.runtime ? { runtime: options.runtime } : {}) }) }
+  catch (error) { await stopExecutionLifecycle(lifecycle, error); throw error }
   const converted = teamExecutionResults(plan, execution)
   if (override) {
     const entry = converted.packages.find(item => item.id === target.id)
@@ -1190,8 +1425,9 @@ async function rerunTeamStep(ctx, { run, target, override, routes, budget, ids,
     const note = await noteCliQuota(config, result.toolId, `${result.error ?? ''}\n${result.outputTail ?? ''}`)
     if (note) quotaNotes.push([result.id, note])
   }
-  const updated = await routerStateStore().updateRun(run.id, current => {
-    mergeRerun(current, converted, { rerunIds: ids, pricingFor: item => routePricing(routes, item), billingFor: billingForResult })
+  const updated = buildRetry({ status: execution.status, results: execution.results,
+    workspace: { workspace: execution.workspace, baseCommit: execution.baseCommit } })
+  const current = updated
     for (const item of current.packages) {
       if (ids.includes(item.id)) item.estimatedCost = estimates.get(item.id) ?? null
     }
@@ -1214,7 +1450,7 @@ async function rerunTeamStep(ctx, { run, target, override, routes, budget, ids,
       if (cliModels[target.id]) bindings[target.id] = cliModels[target.id]
       current.cliModels = bindings
     }
-  })
+  try { await lifecycle.finish(updated) } catch (error) { await lifecycle.interrupt(updated); throw error }
   return { run: updated, execution: { ...converted, ranIds: ids, raw: execution }, budget }
 }
 
@@ -1240,6 +1476,7 @@ async function rerunToolRun(ctx, config, { run, confirmOverBudget, confirmWrite,
   const cwd = text(workspace) || run.workspace
   if (!cwd || !(await fileExists(cwd))) throw new Error('原运行的工作区不可用，无法重跑；请在原工作区的会话中重试。')
   const { result, recorded } = await runPlannedTool(ctx, config, planned, { cwd, root: text(root) || cwd, signal, rerunOf: run.id,
+    confirmOverBudget,
     ...(options.runTask ? { runTask: options.runTask } : {}) })
   const execution = { status: result.status, packages: recorded?.packages ?? [], ranIds: ['direct'], raw: result }
   return { run: recorded ?? run, execution, budget: planned.budget, rerunOf: run.id, newRunId: recorded?.id ?? null }
@@ -1302,22 +1539,51 @@ export async function planToolRun(ctx, config, args = {}, { signal } = {}) {
     modelId = text(args.cliModel)
   }
   const estimate = route ? createPlanFromRoutes(taskText, routes, { mode: 'direct', directProvider: route.provider, directModel: route.model }).estimatedCost : null
-  const budget = budgetFor(config, await savedState(), Number.isFinite(estimate) ? estimate : null)
-  return { toolId, tool, taskText, mode, modelId, route, routes, estimate: Number.isFinite(estimate) ? estimate : null, budget,
+  const funding = initialFunding(route ?? {}, { ...accountingContext(null, routes, true), toolId })
+  const apiEstimate = funding.billing === 'subscription' ? 0 : estimate
+  const budget = budgetFor(config, await savedState(), apiEstimate, { apiExposure: funding.billing === 'api' })
+  const resources = route ? estimateAssignedPackage(route, { id: 'direct', objective: taskText, type: 'general' }, taskText) : null
+  const accounting = { apiEstimatedCostUsd: apiEstimate, apiExposure: funding.billing === 'api', packages: [{ id: 'direct', billing: funding.billing,
+    apiEstimatedCostUsd: apiEstimate, estimatedUsage: { inputTokens: resources?.inputTokens ?? null, outputTokens: resources?.outputTokens ?? null } }] }
+  return { toolId, tool, taskText, mode, modelId, route, routes, accounting, funding: funding.billing, apiEstimate, estimate: Number.isFinite(estimate) ? estimate : null, budget,
     provider: route?.provider ?? '', model: route?.model ?? '', cliModel: modelId }
 }
 
 /** Run a planned tool call and record it; `rerunOf` links a rerun to the original run. */
-async function runPlannedTool(ctx, config, planned, { cwd, root, signal, rerunOf = null, runTask = runOfficialTask }) {
+async function runPlannedTool(ctx, config, planned, { cwd, root, signal, rerunOf = null, confirmOverBudget = false, runTask = runOfficialTask }) {
   const startedAt = Date.now()
-  const result = await runTask({ toolId: planned.toolId, task: planned.taskText, modelId: planned.modelId, workspace: cwd, allowedRoot: root ?? cwd,
-    mode: planned.mode, signal, sandbox: ctx.sandbox })
-  const recorded = result.status === 'unsupported' ? null : await recordToolRun({
-    toolId: planned.toolId, task: planned.taskText, provider: planned.provider, model: planned.model, cliModel: planned.cliModel,
-    mode: planned.mode, workspace: cwd, result, startedAt, routes: planned.routes, config,
-    estimatedCost: planned.estimate, budget: planned.budget, rerunOf,
-  })
-  return { result, recorded }
+  const runId = randomUUID()
+  const makeToolRecord = (result, location = {}) => {
+    const run = buildToolRunRecord({ id: runId, createdAt: startedAt, finishedAt: Date.now(),
+      toolId: planned.toolId, toolLabel: planned.tool?.label ?? planned.toolId, task: planned.taskText,
+      provider: planned.provider, model: planned.model, cliModel: planned.cliModel,
+      mode: planned.mode, workspace: cwd, result, estimatedCost: planned.estimate, rerunOf,
+      pricingFor: item => routePricing(planned.routes, item), billingFor: billingForResult, budget: planned.budget })
+    if (location.isolatedWorkspace) run.isolatedWorkspace = location.isolatedWorkspace
+    if (location.baseCommit) run.baseCommit = location.baseCommit
+    return run
+  }
+  const lifecycle = await beginExecutionLifecycle({ state: routerStateStore(), settings: budgetSettings(config), confirmOverBudget,
+    packageEstimates: [{ id: 'direct', billing: planned.funding ?? 'api', estimatedCostUsd: planned.apiEstimate ?? planned.estimate ?? null }],
+    buildRun: ({ status, results, workspace }) => makeToolRecord(results[0] ?? { status, notStarted: true }, workspace) })
+  if (!lifecycle.accepted) {
+    planned.budget = pausedExecutionBudget(lifecycle)
+    return { result: { status: 'paused-budget', budget: planned.budget }, recorded: null }
+  }
+  let result
+  try {
+    result = await runTask({ toolId: planned.toolId, task: planned.taskText, modelId: planned.modelId, workspace: cwd, allowedRoot: root ?? cwd,
+      mode: planned.mode, signal, sandbox: ctx.sandbox,
+      onCheckpointStart: item => lifecycle.onCheckpointStart(item), onCheckpointResult: item => lifecycle.onCheckpointResult(item),
+      onWorkspace: value => lifecycle.onWorkspace(value) })
+  } catch (error) { await stopExecutionLifecycle(lifecycle, error); throw error }
+  const recorded = makeToolRecord(result, { isolatedWorkspace: result.isolatedWorkspace, baseCommit: result.baseCommit })
+  try {
+    if (result.status !== 'succeeded') await annotateCliQuota(recorded, config,
+      [{ id: 'direct', toolId: planned.toolId, text: `${result.error ?? result.reason ?? ''}\n${result.outputTail ?? ''}` }])
+    await lifecycle.finish(recorded)
+  } catch (error) { await lifecycle.interrupt(recorded); throw error }
+  return { result, recorded: result.status === 'unsupported' ? null : recorded }
 }
 
 /** Ledger record for model_router_tool_run. */
@@ -1356,9 +1622,13 @@ export async function rateRecordedResult({ runId, packageId, rating, expectedFin
 
 /** Everything the workbench shows: recent runs, spending, budget, learned biases and settings. */
 export async function ledgerSummary(config = {}, { limit = 30 } = {}) {
+  await createBudgetReservations({ state: routerStateStore() }).recoverInterruptedExecutions()
   const saved = await routingSavedState(config)
   const spent = spending(saved.runs, undefined, saved.archivedSpending)
   const settings = budgetSettings(config)
+  const entries = Object.values(saved.budgetReservations ?? {})
+  const reserved = { ...reservationSpending(saved), activeCount: entries.filter(item => item.status === 'active').length,
+    interruptedCount: entries.filter(item => item.status === 'interrupted').length }
   return {
     runs: saved.runs.slice(-limit).reverse().map(run => ({
       ...run,
@@ -1367,7 +1637,14 @@ export async function ledgerSummary(config = {}, { limit = 30 } = {}) {
         .map(item => ({ ...item, answer: text(item.answer).slice(0, 1_500) })),
     })),
     spent,
-    budget: { ...settings, ...budgetCheck({ estimateUsd: null, spent, ...settings }), historyVerified: saved.historyVerified !== false },
+    subscriptionUsage: { ...subscriptionUsage(saved.runs, Date.now(), saved.archivedSubscriptionUsage), historyIncomplete: saved.subscriptionUsageIncomplete === true },
+    reserved,
+    reservations: entries.map(entry => ({ id: entry.id, runId: entry.runId, status: entry.status, updatedAt: entry.updatedAt,
+      billing: entry.packages.every(item => item.billing === 'subscription') ? 'subscription' : entry.packages.some(item => item.billing === 'subscription') ? 'mixed' : 'api',
+      unknown: entry.packages.some(item => item.billing !== 'subscription' && (item.estimatedCostUsd === null || entry.status === 'interrupted' && item.started)),
+      remainingEstimateUsd: entry.packages.every(item => Number.isFinite(item.estimatedCostUsd))
+        ? entry.packages.reduce((sum, item) => sum + item.estimatedCostUsd, 0) : null })),
+    budget: { ...budgetFor(config, saved, null, { checkEstimate: false }), historyVerified: saved.historyVerified !== false },
     storageAvailable: saved.storageAvailable !== false,
     storageNotice: saved.storageAvailable === false ? '执行记录存储暂不可用；下方费用与学习摘要尚未核验，不能当作零花费或没有反馈。'
       : saved.historyVerified === false ? '此前执行记录已损坏或不完整，当前摘要只包含可读记录；不能视为完整费用历史，请从备份恢复后再核验预算。' : '',
@@ -1494,10 +1771,12 @@ export async function planOfficialTeam(ctx, config = {}, args = {}, options = {}
   const supported = new Set(executableRoutes.map(route => toolForProvider(route.provider).id))
   const configuredBudget = valueOf(config, 'budgetUsd', DEFAULT_ROUTER_SETTINGS.budgetUsd)
   const budgetUsd = Math.max(0, finiteNumber(args.budgetUsd, finiteNumber(configuredBudget, 0)))
+  const fundingPrices = planningFundingPrices(executableRoutes, accountingContext(null, executableRoutes, true))
   const plan = createPlanFromRoutes(taskText, executableRoutes, {
-    ...planDataOptions(saved, config), mode: 'team', budgetUsd, installedToolIds: installed, forceOfficialCli: true,
+    ...planDataOptions(saved, config), pricing: fundingPrices.pricing, mode: 'team', budgetUsd, installedToolIds: installed, forceOfficialCli: true,
     runnableToolIds: installed.filter(id => supported.has(id)), preset: routingPresetOf(config, args.preset),
   })
+  plan.subscriptionPricedRoutes = fundingPrices.subscriptionPricedRoutes
   const bindingsText = text(args.cliModelsJson)
   if (bindingsText.length > 4_000) throw new Error('cliModelsJson 超过 4000 字符上限')
   let requestedModels = {}
@@ -1506,7 +1785,8 @@ export async function planOfficialTeam(ctx, config = {}, args = {}, options = {}
     catch { throw new Error('cliModelsJson 不是有效的 JSON 对象') }
   }
   const cliModels = resolveTeamCliModelBindings(plan, executableRoutes, requestedModels)
-  const budget = budgetFor(config, await savedState(), plan.estimatedCost)
+  attachPlanAccounting(plan, taskText, executableRoutes, accountingContext(null, executableRoutes, true))
+  const budget = budgetFor(config, await savedState(), plan.accounting.apiEstimatedCostUsd, { apiExposure: plan.accounting.apiExposure })
   return { ...base, status: 'planned', plan, cliModels, budget }
 }
 
@@ -1516,7 +1796,8 @@ export async function executeOfficialTeamPlan(ctx, config = {}, planned, options
   if (!planned?.plan || !['read-only', 'workspace-write'].includes(planned.mode)) throw new Error('缺少有效的官方 CLI 团队计划')
   const executionEnvironment = teamExecutionEnvironment(planned.executionEnvironment, planned.mode)
   const workspace = options.workspace ?? planned.workspace
-  const budget = budgetFor(config, await savedState(), planned.plan.estimatedCost)
+  attachPlanAccounting(planned.plan, planned.taskText, planned.routes, accountingContext(null, planned.routes, true))
+  const budget = budgetFor(config, await savedState(), planned.plan.accounting.apiEstimatedCostUsd, { apiExposure: planned.plan.accounting.apiExposure })
   const common = { plan: planned.plan, workspace, mode: planned.mode, executionEnvironment, budget }
   if (budget.exceeded && options.confirmOverBudget !== true) return { ...common, status: 'paused-budget',
     notice: `${budget.message} 已暂停团队执行。请向用户确认后再执行。` }
@@ -1528,15 +1809,39 @@ export async function executeOfficialTeamPlan(ctx, config = {}, planned, options
     reason: '官方 Harness 进程沙箱不可用，不能执行官方 CLI 团队。' }
   throwIfAborted(options.signal)
   const startedAt = Date.now()
-  const execution = await (options.runTeam ?? runOfficialTeam)({ plan: planned.plan, task: planned.taskText, workspace,
+  const runId = randomUUID()
+  const makeTeamRecord = (execution, location = {}) => {
+    const run = buildTeamRunRecord({ id: runId, createdAt: startedAt, finishedAt: Date.now(), task: planned.taskText,
+      plan: planned.plan, execution, mode: planned.mode, workspace,
+      preset: planned.plan.preset ?? DEFAULT_ROUTING_PRESET, pricingFor: item => routePricing(planned.routes, item), billingFor: billingForResult,
+      budget: { estimateUsd: budget.estimateUsd, confirmed: options.confirmOverBudget === true } })
+    run.executionEnvironment = executionEnvironment
+    run.cliModels = { ...planned.cliModels }
+    if (planned.mode === 'workspace-write' && location.workspace) run.isolatedWorkspace = location.workspace
+    if (location.baseCommit) run.baseCommit = location.baseCommit
+    return run
+  }
+  const lifecycle = await beginExecutionLifecycle({ state: routerStateStore(), settings: budgetSettings(config),
+    confirmOverBudget: options.confirmOverBudget === true, packageEstimates: packageEstimates(planned.plan, planned.taskText),
+    buildRun: ({ status, results, workspace: location }) => makeTeamRecord({ status, results }, location) })
+  if (!lifecycle.accepted) return { ...common, status: 'paused-budget', budget: pausedExecutionBudget(lifecycle) }
+  let execution
+  try { execution = await (options.runTeam ?? runOfficialTeam)({ plan: planned.plan, task: planned.taskText, workspace,
     allowedRoot: options.root ?? workspace, mode: planned.mode, executionEnvironment, installedIds: planned.installed,
     cliModels: planned.cliModels, signal: options.signal, sandbox: ctx.sandbox,
     onPackageStart: item => reportRunProgress(options, { type: 'package-start', package: item }),
     onPackage: item => reportRunProgress(options, { type: 'package-complete', package: item }),
-    onStage: stage => reportRunProgress(options, { type: 'stage', stage }) })
+    onStage: stage => reportRunProgress(options, { type: 'stage', stage }),
+    onCheckpointStart: item => lifecycle.onCheckpointStart(item), onCheckpointResult: result => lifecycle.onCheckpointResult(result),
+    onWorkspace: value => lifecycle.onWorkspace(value) }) }
+  catch (error) { await stopExecutionLifecycle(lifecycle, error); throw error }
   await reportRunProgress(options, { type: 'stage', stage: 'saving' })
-  const run = await recordTeamRun({ task: planned.taskText, plan: planned.plan, execution, mode: planned.mode, executionEnvironment, workspace,
-    routes: planned.routes, cliModels: planned.cliModels, budget, startedAt, config })
+  const run = makeTeamRecord(execution, { workspace: execution.workspace, baseCommit: execution.baseCommit })
+  try {
+    await annotateCliQuota(run, config, (execution.results ?? []).filter(item => item.status !== 'succeeded' && item.toolId)
+      .map(item => ({ id: item.id, toolId: item.toolId, text: `${item.error ?? ''}\n${item.outputTail ?? ''}` })))
+    await lifecycle.finish(run)
+  } catch (error) { await lifecycle.interrupt(run); throw error }
   return { ...common, status: execution.status, execution, run, runId: run?.id ?? null,
     rerunNotice: planned.mode === 'read-only'
       ? '失败的工作包可用 model_router_rerun_step 单步重跑（只重跑该步及其未完成的下游）。'
@@ -1555,7 +1860,8 @@ export function decisionSummary(plan) {
     preset: plan?.preset ?? DEFAULT_ROUTING_PRESET,
     complexity: plan?.complexity ?? null,
     reason: plan?.reason ?? '',
-    estimatedCost: plan?.estimatedCost ?? null,
+    accounting: plan?.accounting ?? null,
+    estimatedCost: plan?.accounting ? plan.accounting.apiEstimatedCostUsd : plan?.estimatedCost ?? null,
     packages: packages.map(item => ({
       id: item.id, name: item.name, route: `${item.recommendedProvider}/${item.recommendedModel}`,
       difficulty: item.difficulty ?? null, estimatedCost: item.estimatedCost ?? null,
@@ -1634,7 +1940,7 @@ const APPROVAL_TEXT = Object.freeze({
  */
 export function approvalReasonCodes(name, args = {}, config = {}, { rerunRun = null } = {}) {
   const codes = []
-  const runKinds = ['model_router_execute', 'model_router_rerun_step', 'model_router_team_execute', 'model_router_tool_run']
+  const runKinds = ['model_router_execute', 'model_router_rerun_step', 'model_router_team_execute', 'model_router_tool_run', 'model_router_consult']
   if (!runKinds.includes(name)) return codes
   if ((name === 'model_router_tool_run' || name === 'model_router_team_execute') && args.mode === 'workspace-write') codes.push('workspace-write')
   if (name === 'model_router_rerun_step' && rerunRun && rerunSupport(rerunRun).writes) codes.push(rerunRun.kind === 'tool' ? 'workspace-write' : 'rerun-write')
@@ -1736,7 +2042,7 @@ async function prepareWorkbenchPreview(ctx, config, supplied = {}, options = {})
       executor: 'official-team', executionMode: mode, executionEnvironment: planned.executionEnvironment, workspace, status: planned.status,
       ...(planned.reason ? { reason: planned.reason } : {}),
       decision, selected: planned.plan?.selected ?? null, routingBypassed: false,
-      estimatedCost: planned.plan?.estimatedCost ?? null, budget: planned.budget,
+      accounting: planned.plan?.accounting ?? null, estimatedCost: planned.plan?.accounting ? planned.plan.accounting.apiEstimatedCostUsd : planned.plan?.estimatedCost ?? null, budget: planned.budget,
       reasons: confirmationReasons(codes, { sandboxAvailable: typeof ctx.sandbox?.confine === 'function', executionEnvironment: planned.executionEnvironment }),
       readOnly: mode === 'read-only',
     } }
@@ -1757,7 +2063,8 @@ async function prepareWorkbenchPreview(ctx, config, supplied = {}, options = {})
     decision: decisionSummary(planned.plan),
     selected: planned.plan.selected ?? null,
     routingBypassed: planned.plan.routingBypassed === true,
-    estimatedCost: planned.plan.estimatedCost ?? null,
+    accounting: planned.plan.accounting ?? null,
+    estimatedCost: planned.plan.accounting ? planned.plan.accounting.apiEstimatedCostUsd : planned.plan.estimatedCost ?? null,
     budget: planned.budget,
     reasons: confirmationReasons(codes, { sandboxAvailable: typeof ctx.sandbox?.confine === 'function' }),
     readOnly: true,
@@ -2012,6 +2319,7 @@ export function apply(ctx, config = {}) {
       provider: { type: 'string', description: 'Configured provider id; pair with model.' },
       model: { type: 'string', description: 'Configured model id; pair with provider.' },
       outputLimit: { type: 'number', description: 'Maximum returned characters, from 500 to 50000.' },
+      confirmOverBudget: { type: 'boolean', description: 'Only after explicit user approval when the API budget is exceeded or unverified.' },
     },
     output: JSON_OUTPUT,
     async execute(args, exec) {
@@ -2022,7 +2330,7 @@ export function apply(ctx, config = {}) {
       const route = requested ?? chooseConsultRoute(plan, routes, exec.agent)
       const fallback = valueOf(config, 'maxConsultOutputChars', 12_000)
       const limit = boundedInteger(args.outputLimit, finiteNumber(fallback, 12_000), 500, 50_000)
-      return jsonValue(await consultConfiguredModel(ctx, route, args.task, limit, exec.signal))
+      return jsonValue(await executeBudgetedConsult(ctx, route, args.task, config, { routes, limit, signal: exec.signal, confirmOverBudget: args.confirmOverBudget === true }))
     },
   }))
   ctx.commands.register({
@@ -2239,14 +2547,14 @@ function registerOfficialToolModels(ctx, config, assertInstallPreferences) {
       const planned = await planToolRun(ctx, config, args, { signal: exec.signal })
       if (planned.mode === 'workspace-write' && sandboxMode === 'read-only') throw new Error('当前 Harness 会话为只读模式，不能请求可编辑 CLI 执行')
       if (planned.budget.exceeded && args.confirmOverBudget !== true) {
-        return jsonValue({ status: 'paused-budget', budget: { ...planned.budget, paused: true }, estimateUsd: planned.estimate,
+        return jsonValue({ status: 'paused-budget', budget: { ...planned.budget, paused: true }, estimateUsd: planned.apiEstimate ?? (planned.funding === 'subscription' ? 0 : planned.estimate), accounting: planned.accounting ?? null,
           notice: `${planned.budget.message} 已暂停，未启动 ${planned.tool.label}。请向用户说明后，以 confirmOverBudget: true 重新调用。` })
       }
-      const { result, recorded } = await runPlannedTool(ctx, config, planned, { cwd, root, signal: exec.signal })
-      return jsonValue({ ...result, runId: recorded?.id ?? null, estimateUsd: planned.estimate, budget: planned.budget,
+      const { result, recorded } = await runPlannedTool(ctx, config, planned, { cwd, root, signal: exec.signal, confirmOverBudget: args.confirmOverBudget === true })
+      return jsonValue({ ...result, runId: recorded?.id ?? null, estimateUsd: planned.apiEstimate ?? (planned.funding === 'subscription' ? 0 : planned.estimate), accounting: planned.accounting ?? null, budget: planned.budget,
         ...(!planned.modelId && planned.model ? { modelNotice: result.modelNotice
           ?? 'Harness 模型 ID 未经此厂商 CLI 验证；本次使用厂商 CLI 已配置的默认模型。' } : {}),
-        ...(planned.estimate === null ? { costNotice: '未指定带单价的 provider/model 路线，无法预估费用；仅在预算已用尽时暂停。' } : {}),
+        ...(planned.funding === 'subscription' ? { costNotice: '订阅单独统计用量，不占用 API 金额预算；厂商未回报的用量保持未知。' } : planned.estimate === null ? { costNotice: '实际计费方式或 API 单价未知，请先核对后确认。' } : {}),
       })
     },
   }))