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

package/.dsh-plugin/index.mjs

@@ -4,7 +4,7 @@ import { homedir } from 'node:os'
 import { isAbsolute } from 'node:path'
 import z from '@deepseek-ai/schemastery'
 import { defineTool } from '@deepseek-ai/dsh-tools'
-import { DEFAULT_ROUTER_SETTINGS, modelMetadata } from './shared/router.mjs'
+import { DEFAULT_ROUTER_SETTINGS, estimateAssignedPackage, modelMetadata } from './shared/router.mjs'
 import { DEFAULT_ROUTING_PRESET, normalizeRoutingPreset, routingPreset } from './shared/routing-presets.mjs'
 import { HEALTH_CACHE_MS, apiKeyEnvPresent, healthCache, runHealthCheck, subscriptionLoginOf } from './shared/tool-health.mjs'
 import { latestVersions } from './shared/latest-versions.mjs'
@@ -12,6 +12,7 @@ import {
   DEFAULT_COOLDOWN_MINUTES, billingOverview, billingPlan, createQuotaTracker, detectQuotaExhaustion, parseQuotaPatterns, vendorKey,
 } from './shared/subscription-billing.mjs'
 import { createRouterState } from './shared/router-state.mjs'
+import { createRunJobs } from './shared/run-jobs.mjs'
 import { applyFeedbackProfile, buildFeedbackProfile } from './shared/adaptive-feedback.mjs'
 import { buildRoutingEvidence, parseRoutingEvidenceJson } from './shared/routing-evidence.mjs'
 import { apiReasoningRequest } from './shared/reasoning-execution.mjs'
@@ -28,7 +29,7 @@ import { applyManualPackagePlan } from './shared/manual-plan.mjs'
 import { parsePackageAssignments, packagePlanKey } from './shared/package-assignments.mjs'
 import { applyModelProfiles, parseModelProfilesJson } from './shared/model-profiles.mjs'
 import { registerOfficialToolsRemote } from './official-tools-remote-service.mjs'
-import { parseRunRequest } from './shared/official-tools-remote.mjs'
+import { parseRunRequest, parseRunJobRequest } from './shared/official-tools-remote.mjs'
 import { createTerminalManager } from './shared/cli-terminal.mjs'
 import {
   parseTerminalRead,
@@ -682,6 +683,7 @@ export async function reviewRunPackages(ctx, run, routes, config, { signal, rand
   const reviewerQuality = routeQuality(reviewer)
   const reviews = []
   for (const item of run.packages) {
+    if (signal?.aborted) break
     if (!item.ok || !text(item.answer)) continue
     if (item.provider === reviewer.provider && item.model === reviewer.model) continue
     const own = routeQuality(routes.find(route => route.provider === item.provider && route.model === item.model))
@@ -708,16 +710,26 @@ export async function reviewRunPackages(ctx, run, routes, config, { signal, rand
       run.reviews.push(entry)
       reviews.push({ ...entry, score })
     } catch (error) {
-      if (signal?.aborted) throw error
+      if (signal?.aborted) break
       item.review = { provider: reviewer.provider, model: reviewer.model, score: null, summary: `审阅失败：${errorText(error).slice(0, 200)}`, at: Date.now() }
     }
   }
   return reviews
 }
 
+async function reportRunProgress(options, event) {
+  try { if (typeof options.onProgress === 'function') await options.onProgress(event) }
+  catch { /* Observing progress must not discard results or incurred spend. */ }
+}
+
 function executionHooks(ctx, options) {
   return {
     skipOfficial: options.skipOfficial ?? (request => healthCache.skipReason(request)),
+    onStage: stage => reportRunProgress(options, { type: 'stage', stage }),
+    onPackageStart: async item => {
+      await reportRunProgress(options, { type: 'package-start', package: item })
+      if (typeof options.onPackageStart === 'function') await options.onPackageStart(item)
+    },
     onPackage: async result => {
       // A CLI that reports "not logged in" is marked; with a subscription the router then asks instead of using the API key.
       const failed = result?.toolId && (result.fallback?.loginRequired ? result.fallback.error : result.pause?.loginRequired && result.pause.kind !== 'subscription-login' ? result.pause.detail : null)
@@ -729,6 +741,7 @@ function executionHooks(ctx, options) {
         healthCache.clearLoggedOut(result.toolId)
         try { await routerStateStore().saveAuthFailure(result.toolId, null) } catch { /* the cache still serves this process */ }
       }
+      await reportRunProgress(options, { type: 'package-complete', package: result })
       if (typeof options.onPackage === 'function') await options.onPackage(result)
     },
     credentialsFor: route => credentialsForRoute(ctx, route),
@@ -857,7 +870,10 @@ export async function executeConfiguredAssignment(ctx, task, config = {}, option
     }
   }
   const finished = []
-  const hooks = executionHooks(ctx, { ...options, onPackage: result => { finished.push(result) } })
+  const hooks = executionHooks(ctx, { ...options, onPackage: async result => {
+    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()
@@ -934,7 +950,10 @@ export async function executeConfiguredAssignment(ctx, task, config = {}, option
     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 })
+  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 }
   const awaiting = pausedSteps(execution)
@@ -976,6 +995,31 @@ export function rerunSupport(run) {
   return { ok: true, kind: run.kind === 'team' ? 'team' : 'assign', writes: false }
 }
 
+/** Estimate exactly the packages a retry will start, retaining unknown prices. */
+function rerunEstimates(run, ids, targetId, override, routes, dataOptions) {
+  const estimates = new Map()
+  for (const item of run.packages.filter(item => ids.has(item.id))) {
+    const assigned = item.id === targetId ? override : null
+    const provider = assigned?.provider ?? item.provider ?? item.recommendedProvider
+    const model = assigned?.model ?? item.model ?? item.recommendedModel
+    const changedRoute = provider !== item.recommendedProvider || model !== item.recommendedModel
+    const reassignsRoute = assigned && (assigned.provider !== (item.provider ?? item.recommendedProvider)
+      || assigned.model !== (item.model ?? item.recommendedModel))
+    let estimate = item.estimatedCost
+    // An unchanged route can retain its planned effort; changing identity uses
+    // the new adapter's default effort, just like rerunAssignmentPackage.
+    if (reassignsRoute || changedRoute) {
+      const route = routes.find(route => route.provider === provider && route.model === model)
+      estimate = route ? estimateAssignedPackage(route, item, run.task,
+        run.decision?.complexity?.band ?? 'balanced', dataOptions).estimatedCost : null
+    }
+    estimates.set(item.id, Number.isFinite(estimate) && estimate >= 0 ? estimate : null)
+  }
+  const values = [...estimates.values()]
+  const total = values.every(value => value !== null) ? values.reduce((sum, value) => sum + value, 0) : null
+  return { byId: estimates, total: Number.isFinite(total) ? total : null }
+}
+
 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)
   const target = run.packages.find(item => item.id === text(packageId))
@@ -1014,16 +1058,17 @@ export async function rerunRecordedStep(ctx, config = {}, { runId, packageId, pr
     return { paused: true, needsConfirmation: missingConfirmations, run,
       budget: null, message: '请确认续跑所需的文件修改与执行环境权限后继续；厂商 CLI 正常环境以当前用户权限运行，独立 Git 工作树不是操作系统读写边界。' }
   }
-  const sameRoute = !override || (override.provider === target.recommendedProvider && override.model === target.recommendedModel)
-  const budget = budgetFor(config, saved, sameRoute ? target.estimatedCost : null)
+  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)
   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, cwd, root: text(root) || cwd, signal, options, config })
-  const retryIds = new Set([target.id, ...downstreamPackageIds(run.packages, target.id)
-    .filter(id => run.packages.find(item => item.id === id)?.ok !== true)])
+  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 })
   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) {
@@ -1070,6 +1115,9 @@ export async function rerunRecordedStep(ctx, config = {}, { runId, packageId, pr
   })
   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
+    }
   })
   const awaiting = pausedSteps(execution)
   return { run: updated, execution, budget, ...(awaiting.length ? { awaitingConfirmation: awaiting } : {}) }
@@ -1095,7 +1143,7 @@ async function cancelPausedStep(runId, packageId) {
 }
 
 /** Stored team packages in plan shape; `override` reassigns the retried package. */
-function teamPlanFromRun(run, ids, override, targetId) {
+function teamPlanFromRun(run, ids, override, targetId, estimates) {
   const workPackages = run.packages.filter(item => ids.includes(item.id)).map(item => ({
     id: item.id, name: item.name, objective: item.objective, dependsOn: item.dependsOn ?? [],
     type: item.type ?? 'general', purpose: item.purpose ?? 'execution',
@@ -1105,7 +1153,7 @@ function teamPlanFromRun(run, ids, override, targetId) {
     ...(item.plannedReasoningEffort && !(item.id === targetId && override
       && (override.provider !== item.recommendedProvider || override.model !== item.recommendedModel))
       ? { recommendedReasoningEffort: item.plannedReasoningEffort } : {}),
-    estimatedCost: item.estimatedCost ?? null,
+    estimatedCost: estimates.get(item.id) ?? null,
   }))
   return { mode: 'team', team: { workPackages } }
 }
@@ -1114,13 +1162,10 @@ function teamPlanFromRun(run, ids, override, targetId) {
  * 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, cwd, root, signal, options, config = {} }) {
+async function rerunTeamStep(ctx, { run, target, override, routes, budget, ids, estimates, cwd, root, signal, options, config = {} }) {
   const mode = run.executionMode === 'workspace-write' ? 'workspace-write' : 'read-only'
   const executionEnvironment = teamExecutionEnvironment(run.executionEnvironment, mode)
-  const downstream = downstreamPackageIds(run.packages, target.id)
-    .filter(id => !run.packages.find(item => item.id === id)?.ok)
-  const ids = [target.id, ...downstream]
-  const plan = teamPlanFromRun(run, ids, override, target.id)
+  const plan = teamPlanFromRun(run, ids, override, target.id, estimates)
   const cliModels = Object.fromEntries(Object.entries(run.cliModels ?? {}).filter(([key]) => ids.includes(key) && !(override && key === target.id)))
   if (override) {
     const reassignedPlan = { team: { workPackages: plan.team.workPackages.filter(item => item.id === target.id) } }
@@ -1147,6 +1192,9 @@ async function rerunTeamStep(ctx, { run, target, override, routes, budget, cwd,
   }
   const updated = await routerStateStore().updateRun(run.id, current => {
     mergeRerun(current, converted, { rerunIds: ids, pricingFor: item => routePricing(routes, item), billingFor: billingForResult })
+    for (const item of current.packages) {
+      if (ids.includes(item.id)) item.estimatedCost = estimates.get(item.id) ?? null
+    }
     for (const [id, note] of quotaNotes) {
       const stored = current.packages.find(item => item.id === id)
       if (stored) stored.billingSwitch = note
@@ -1482,7 +1530,11 @@ export async function executeOfficialTeamPlan(ctx, config = {}, planned, options
   const startedAt = Date.now()
   const 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 })
+    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 }) })
+  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 })
   return { ...common, status: execution.status, execution, run, runId: run?.id ?? null,
@@ -1720,15 +1772,26 @@ export async function previewWorkbenchRun(ctx, config, request = {}, options = {
 /** Execute from the workbench; refuses until every current reason is in confirmedReasons. */
 export async function startWorkbenchRun(ctx, config, supplied = {}, options = {}) {
   const prepared = await prepareWorkbenchPreview(ctx, config, supplied, options)
-  const { preview, request } = prepared
+  return refusedWorkbenchStart(prepared) ?? executePreparedWorkbenchRun(ctx, config, prepared, options)
+}
+
+function refusedWorkbenchStart({ preview, request }) {
   if (preview.status === 'blocked') return preview
-  const confirmed = new Set(Array.isArray(request.confirmedReasons) ? request.confirmedReasons : [])
+  const confirmed = new Set(request.confirmedReasons ?? [])
   const missing = preview.reasons.filter(item => !confirmed.has(item.code))
-  if (missing.length) return { ...preview, status: 'needs-confirmation', reasons: preview.reasons, missing: missing.map(item => item.code) }
+  return missing.length ? { ...preview, status: 'needs-confirmation', reasons: preview.reasons,
+    missing: missing.map(item => item.code) } : null
+}
+
+async function executePreparedWorkbenchRun(ctx, config, prepared, options = {}) {
+  const { preview, request } = prepared
+  const confirmed = new Set(Array.isArray(request.confirmedReasons) ? request.confirmedReasons : [])
+  throwIfAborted(options.signal)
+  await reportRunProgress(options, { type: 'stage', stage: 'executing' })
   if (request.executor === 'official-team') {
     const result = await (options.executeOfficialTeam ?? executeOfficialTeamPlan)(ctx, config, prepared.planned, {
-      workspace: preview.workspace, root: preview.workspace, signal: options.signal,
       confirmOverBudget: confirmed.has('over-budget'), confirmUnsandboxed: confirmed.has('unsandboxed'), ...(options.teamOptions ?? {}),
+      workspace: preview.workspace, root: preview.workspace, signal: options.signal, onProgress: options.onProgress,
     })
     return { status: result.status, runId: result.runId ?? null, workspace: preview.workspace,
       executor: 'official-team', executionMode: request.executionMode, executionEnvironment: preview.executionEnvironment, decision: preview.decision,
@@ -1740,8 +1803,8 @@ export async function startWorkbenchRun(ctx, config, supplied = {}, options = {}
     provider: request.provider, model: request.model, planMode: request.planMode, preset: request.preset,
     ...manualRequestOptions(request),
     budgetUsd: finiteNumber(request.budgetUsd, finiteNumber(configuredBudget, 0)),
-    confirmOverBudget: confirmed.has('over-budget'), workspace: preview.workspace, signal: options.signal, ...options.planOptions,
-    preparedAssignment: prepared.planned,
+    confirmOverBudget: confirmed.has('over-budget'), workspace: preview.workspace, ...options.planOptions,
+    preparedAssignment: prepared.planned, signal: options.signal, onProgress: options.onProgress,
   })
   const awaiting = result.awaitingConfirmation ?? []
   return {
@@ -1751,6 +1814,25 @@ export async function startWorkbenchRun(ctx, config, supplied = {}, options = {}
   }
 }
 
+/** Desktop starts an observable job after fresh preflight and confirmation checks. */
+export async function launchWorkbenchRun(ctx, config, supplied = {}, { runJobs, ...options } = {}) {
+  if (!runJobs) throw new Error('工作台任务服务不可用，请重启 Harness 后重试。')
+  const prepared = await prepareWorkbenchPreview(ctx, config, supplied, options)
+  const refused = refusedWorkbenchStart(prepared)
+  if (refused) return refused
+  return runJobs.start({
+    packages: prepared.preview.decision?.packages ?? [],
+    run: async ({ signal, onProgress }) => {
+      try { return await executePreparedWorkbenchRun(ctx, config, prepared, { ...options, signal, onProgress }) }
+      catch (error) {
+        if (error?.runId) return { status: signal.aborted ? 'cancelled' : 'failed', runId: error.runId,
+          workspace: prepared.preview.workspace, notice: '执行未完成，已产生的结果与费用请查看执行记录。' }
+        throw error
+      }
+    },
+  })
+}
+
 /** Host operations behind the workbench RPC; the client never supplies commands or paths. */
 /**
  * One terminal manager per Host plugin fiber. Sessions run outside the
@@ -1786,7 +1868,7 @@ function terminalServices(terminals, assertPreferences = () => {}) {
   }
 }
 
-export function routerRemoteServices(ctx, config, { terminals = null, assertPreferences } = {}) {
+export function routerRemoteServices(ctx, config, { terminals = null, assertPreferences, runJobs = createRunJobs(), runOptions = {} } = {}) {
   return {
     ...terminalServices(terminals, assertPreferences),
     health: async fresh => {
@@ -1804,8 +1886,10 @@ export function routerRemoteServices(ctx, config, { terminals = null, assertPref
       ...(request?.subscriptionChoice ? { subscriptionChoice: request.subscriptionChoice } : {}),
     }),
     boundaries: () => securityBoundaries(ctx, config),
-    previewRun: request => previewWorkbenchRun(ctx, config, request),
-    startRun: request => startWorkbenchRun(ctx, config, request),
+    previewRun: request => previewWorkbenchRun(ctx, config, request, runOptions),
+    startRun: request => launchWorkbenchRun(ctx, config, request, { ...runOptions, runJobs }),
+    runStatus: request => runJobs.status(parseRunJobRequest(request).jobId),
+    cancelRun: request => runJobs.cancel(parseRunJobRequest(request).jobId),
   }
 }
 
@@ -1835,14 +1919,15 @@ export function apply(ctx, config = {}) {
   // supply only the model/command services and do not expose the Desktop RPC.
   if (ctx.typert) {
     const terminals = createRouterTerminals()
+    const runJobs = createRunJobs()
     // Plugin unload or patch reload kills every interactive session.
     ctx.effect(() => {
-      const onExit = () => { terminals.disposeAll('dispose') }
+      const onExit = () => { terminals.disposeAll('dispose'); runJobs.dispose() }
       process.once('exit', onExit)
-      return () => { process.off('exit', onExit); terminals.disposeAll('dispose') }
+      return () => { process.off('exit', onExit); terminals.disposeAll('dispose'); runJobs.dispose() }
     }, 'model-router-galgame: interactive terminals')
     registerOfficialToolsRemote(ctx, {
-      ...routerRemoteServices(ctx, config, { terminals, assertPreferences: assertInstallPreferences }),
+      ...routerRemoteServices(ctx, config, { terminals, runJobs, assertPreferences: assertInstallPreferences }),
       installSettingsError: () => installPreferenceError,
       installRequestedDirectory: () => valueOf(config, 'toolInstallDir', ''),
       zcodeRequestedDirectory: () => valueOf(config, 'zcodeInstallDir', ''),

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

@@ -149,6 +149,8 @@ export class OfficialToolsRemoteService extends TypertRemoteService {
 
   /** Execute a previewed run once every listed reason was confirmed. */
   startRun(request) { return settled(() => (this.services.startRun ?? unavailable)(request)) }
+  runStatus(request) { return settled(() => (this.services.runStatus ?? unavailable)(request)) }
+  cancelRun(request) { return settled(() => (this.services.cancelRun ?? unavailable)(request)) }
 
   /** Terminal backend (PTY or pipe fallback), limits and live sessions. */
   terminalInfo() { return settled(() => (this.services.terminalInfo ?? unavailable)()) }

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

@@ -11,7 +11,7 @@ import { tmpdir } from 'node:os'
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path'
 import { runOfficialTool, officialToolExecutionCapabilities, officialToolReadiness } from './official-tool-executor.mjs'
 import { toolForProvider } from './official-tool-registry.mjs'
-import { redactDiagnostic, verifiedDiagnostic } from './task-executors.mjs'
+import { observeExecutionProgress, redactDiagnostic, verifiedDiagnostic } from './task-executors.mjs'
 import { unsupportedCliReasoning } from './reasoning-execution.mjs'
 
 const MAX_GIT_OUTPUT = 64_000_000
@@ -96,6 +96,8 @@ export async function sessionWorkspace(ctx, exec) {
 }
 
 function git(args, { cwd, input, signal, timeoutMs = GIT_TIMEOUT_MS } = {}) {
+  // In particular, never start git apply with an already cancelled signal.
+  if (signal?.aborted) return Promise.resolve({ ok: false, code: null, output: Buffer.alloc(0), cancelled: true })
   return new Promise(resolveResult => {
     let child
     try {
@@ -123,6 +125,7 @@ function git(args, { cwd, input, signal, timeoutMs = GIT_TIMEOUT_MS } = {}) {
     const timer = setTimeout(() => { timedOut = true; child.kill('SIGTERM') }, timeoutMs)
     child.on('error', error => finish(null, error))
     child.on('close', code => finish(code))
+    if (signal?.aborted) onAbort()
     if (input === undefined) child.stdin.end()
     else child.stdin.end(input)
     let finished = false
@@ -412,7 +415,8 @@ async function seedWorktree(isolated, seedFrom, signal) {
 }
 
 /** Sequential execution preserves DAG dependencies and avoids edit conflicts. */
-export async function runOfficialTeam({ plan, task, workspace, allowedRoot, mode = 'read-only', executionEnvironment = 'harness', installedIds = [], cliModels, signal, sandbox, runtime, previous = [], onlyIds = null, seedFrom = null }) {
+export async function runOfficialTeam({ plan, task, workspace, allowedRoot, mode = 'read-only', executionEnvironment = 'harness', installedIds = [], cliModels, signal, sandbox, runtime, previous = [], onlyIds = null, seedFrom = null, onPackageStart, onPackage, onStage }) {
+  await observeExecutionProgress(onStage, 'preparing')
   if (!['harness', 'cli-native'].includes(executionEnvironment)
     || (executionEnvironment === 'cli-native' && mode !== 'workspace-write')) throw new TypeError('invalid team CLI execution environment')
   // A retry runs only `onlyIds`; earlier results feed dependency context. An
@@ -431,6 +435,7 @@ export async function runOfficialTeam({ plan, task, workspace, allowedRoot, mode
   if (mode !== 'read-only' && mode !== 'workspace-write') throw new TypeError('team mode must be read-only or workspace-write')
   const configuredCliModels = checkedTeamCliModels(cliModels, assigned)
   const source = await approvedSource(workspace, allowedRoot)
+  if (signal?.aborted) return { status: 'cancelled', workspace: source, results: [] }
   if (executionEnvironment === 'harness' && typeof sandbox?.confine !== 'function') return { status: 'blocked', blocking: [{ reason: '官方 Harness 进程沙箱不可用。' }], results: [] }
   // The Host passes no runtime override. Tests can inject inert CLI adapters to
   // exercise assignment, stopping, and Git integration without provider accounts.
@@ -440,6 +445,7 @@ export async function runOfficialTeam({ plan, task, workspace, allowedRoot, mode
   const unready = readiness.filter(item => !item.ready || !(item.readyModes ?? item.modes ?? [mode]).includes(mode))
   if (unready.length > 0) return { status: 'blocked', blocking: unready.map(item => ({ toolId: item.id,
     reason: item.reason ?? `官方 CLI 尚未就绪，或不支持 ${mode} 模式。` })), results: [] }
+  if (signal?.aborted) return { status: 'cancelled', workspace: source, results: [] }
   const isolated = mode === 'workspace-write' ? await isolatedWorktree(source, signal, allowedRoot) : null
   const runWorkspace = isolated?.workspace ?? source
   let seeded = null
@@ -451,13 +457,18 @@ export async function runOfficialTeam({ plan, task, workspace, allowedRoot, mode
     }
   }
   const completed = []
+  const cancelledRun = () => ({ status: 'cancelled', workspace: runWorkspace, results: completed,
+    ...(isolated ? { baseCommit: isolated.baseCommit } : {}), ...(seeded ? { seeded } : {}) })
   const context = retry ? (Array.isArray(previous) ? previous : []).filter(item => item?.id && typeof item.finalText === 'string') : []
+  if (!signal?.aborted) await observeExecutionProgress(onStage, 'executing')
   for (const item of assigned) {
-    if (signal?.aborted) return { status: 'cancelled', workspace: runWorkspace, results: completed,
-      ...(isolated ? { baseCommit: isolated.baseCommit } : {}), ...(seeded ? { seeded } : {}) }
+    if (signal?.aborted) return cancelledRun()
     const cliModel = teamCliModel(item, configuredCliModels)
     const prompt = packagePrompt(task, item, [...context, ...completed])
     const startedAt = Date.now()
+    await observeExecutionProgress(onPackageStart, { ...item, provider: item.recommendedProvider,
+      model: item.recommendedModel, requestedCliModel: cliModel, startedAt })
+    if (signal?.aborted) return cancelledRun()
     let result
     try {
       result = await runTool({
@@ -507,11 +518,15 @@ export async function runOfficialTeam({ plan, task, workspace, allowedRoot, mode
       error: modelMismatch ? '官方 CLI 实际模型与指定模型不一致。'
         : (result.error || result.reason) ? executionDiagnostic(result.error || result.reason) : null,
       outputTail: result.status === 'succeeded' ? null : executionDiagnostic(verifiedDiagnostic(result)) || null })
+    await observeExecutionProgress(onPackage, completed.at(-1))
+    if (signal?.aborted) return cancelledRun()
     if (packageStatus !== 'succeeded') return { status: packageStatus === 'cancelled' ? 'cancelled' : 'incomplete', workspace: runWorkspace, results: completed,
       ...(isolated ? { baseCommit: isolated.baseCommit } : {}), ...(seeded ? { seeded } : {}) }
   }
   if (!isolated) return { status: 'cli-completed', workspace: runWorkspace, results: completed,
     notice: '只读模式已收集各工作包结果；模型输出仍需人工验收。' }
+  await observeExecutionProgress(onStage, 'integrating')
+  if (signal?.aborted) return cancelledRun()
   try {
     const integration = await integrateWorktree(source, runWorkspace, isolated.baseCommit, signal)
     return { status: integration.ignoredArtifacts > 0 ? 'integration-pending' : 'cli-completed',
@@ -520,6 +535,8 @@ export async function runOfficialTeam({ plan, task, workspace, allowedRoot, mode
         ? '受 Git 管理的源文件已整合；忽略产物保留在独立工作区，仍需核对和补交。'
         : '各 CLI 进程成功结束且可用补丁已整合；文件内容仍需按任务要求验收。' }
   } catch (error) {
+    if (signal?.aborted) return { ...cancelledRun(), error: String(error?.message ?? error),
+      notice: '执行已取消；独立工作区及工作包结果已保留。' }
     return { status: 'integration-pending', workspace: runWorkspace, results: completed, baseCommit: isolated.baseCommit,
       ...(seeded ? { seeded } : {}),
       error: String(error?.message ?? error), notice: '独立工作区已保留；原工作区未自动整合。' }
@@ -529,12 +546,14 @@ export async function runOfficialTeam({ plan, task, workspace, allowedRoot, mode
 /** One editable CLI task also uses the same isolated workspace and merge gate. */
 export async function runOfficialTask({ toolId, task, workspace, allowedRoot, modelId, mode = 'read-only', signal, sandbox, runtime }) {
   const source = await approvedSource(workspace, allowedRoot)
+  if (signal?.aborted) return { toolId, status: 'cancelled', notStarted: true, finalText: '' }
   if (typeof sandbox?.confine !== 'function') return { toolId, status: 'unsupported', reason: '官方 Harness 进程沙箱不可用。' }
   // The Host supplies no runtime override; offline tests use inert adapters.
   const readiness = await (runtime?.readiness ?? officialToolReadiness)(toolId, source)
   const readyModes = readiness.readyModes ?? readiness.modes ?? []
   if (!readiness.ready || !readyModes.includes(mode)) return { toolId, status: 'unsupported',
     reason: readiness.reason ?? readiness.modeReasons?.[mode] ?? `官方 CLI 尚未就绪，或不支持 ${mode} 模式。` }
+  if (signal?.aborted) return { toolId, status: 'cancelled', notStarted: true, finalText: '' }
   const isolated = mode === 'workspace-write' ? await isolatedWorktree(source, signal, allowedRoot) : null
   let result
   try {
@@ -545,6 +564,8 @@ export async function runOfficialTask({ toolId, task, workspace, allowedRoot, mo
     result = executionException(error, signal)
   }
   result = withFailureDiagnostic(result)
+  if (signal?.aborted) return { ...result, status: 'cancelled',
+    ...(isolated ? { isolatedWorkspace: isolated.workspace, baseCommit: isolated.baseCommit } : {}) }
   if (!isolated || result.status !== 'succeeded') return { ...result, ...(isolated ? { isolatedWorkspace: isolated.workspace, baseCommit: isolated.baseCommit } : {}) }
   try {
     const integration = await integrateWorktree(source, isolated.workspace, isolated.baseCommit, signal)
@@ -552,6 +573,8 @@ export async function runOfficialTask({ toolId, task, workspace, allowedRoot, mo
       ...(integration.ignoredArtifacts > 0 ? { status: 'integration-pending' } : {}),
       isolatedWorkspace: isolated.workspace, integration }
   } catch (error) {
+    if (signal?.aborted) return { ...result, status: 'cancelled', isolatedWorkspace: isolated.workspace,
+      baseCommit: isolated.baseCommit, integrationError: String(error?.message ?? error) }
     return { ...result, status: 'integration-pending', isolatedWorkspace: isolated.workspace,
       integrationError: String(error?.message ?? error) }
   }

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

@@ -104,6 +104,15 @@ const idText = (value, subject) => {
   return value
 }
 
+/** A status/cancel request can only address an existing Host-owned run. */
+export function parseRunJobRequest(value) {
+  const request = plainObject(value, 'run job request')
+  if (Object.keys(request).some(key => key !== 'jobId')) throw new TypeError('run job request only accepts jobId')
+  return { jobId: idText(request.jobId, 'jobId') }
+}
+
+const runJobRequestCodec = strictCodec(`${OFFICIAL_TOOLS_REMOTE_PACKAGE}#RunJobRequest`, parseRunJobRequest)
+
 const optionalRouteText = (value, subject) => {
   if (value === undefined || value === null || value === '') return undefined
   if (typeof value !== 'string' || value.length > 240 || value.includes('\0')) throw new TypeError(`${subject} is invalid`)
@@ -196,7 +205,7 @@ const terminalStopCodec = strictCodec(`${OFFICIAL_TOOLS_REMOTE_PACKAGE}#Terminal
 
 const runRequestCodec = strictCodec(`${OFFICIAL_TOOLS_REMOTE_PACKAGE}#RunRequest`, parseRunRequest)
 
-function descriptor(method, parameters, result) {
+function descriptor(method, parameters, result, cancellable = false) {
   return Object.freeze({
     id: `${OFFICIAL_TOOLS_REMOTE_PACKAGE}#${OFFICIAL_TOOLS_REMOTE_NAMESPACE}/${method}`,
     service: OFFICIAL_TOOLS_REMOTE_NAMESPACE,
@@ -205,6 +214,7 @@ function descriptor(method, parameters, result) {
     invocation: { kind: 'direct' },
     parameters,
     result,
+    ...(cancellable ? { cancellation: { parameter: 'signal' } } : {}),
   })
 }
 
@@ -229,8 +239,10 @@ export const OFFICIAL_TOOLS_REMOTE_DESCRIPTORS = Object.freeze([
   descriptor('rerunStep', [jsonParameter('request', rerunRequestCodec)], anyObjectCodec('RerunResult')),
   descriptor('boundaries', [], anyObjectCodec('SecurityBoundaries')),
   // Workbench "start a run": plan preview with cost estimate and confirmation reasons, then execute.
-  descriptor('previewRun', [jsonParameter('request', runRequestCodec)], anyObjectCodec('RunPreview')),
+  descriptor('previewRun', [jsonParameter('request', runRequestCodec)], anyObjectCodec('RunPreview'), true),
   descriptor('startRun', [jsonParameter('request', runRequestCodec)], anyObjectCodec('RunStarted')),
+  descriptor('runStatus', [jsonParameter('request', runJobRequestCodec)], anyObjectCodec('RunJobStatus'), true),
+  descriptor('cancelRun', [jsonParameter('request', runJobRequestCodec)], anyObjectCodec('RunJobStatus'), true),
   // Workbench "官方工具终端": interactive shell / fixed official CLI sessions.
   // Output streams through long-poll reads; input and resize are unary calls.
   descriptor('terminalInfo', [], anyObjectCodec('TerminalInfo')),

package/.dsh-plugin/shared/router-state.mjs

@@ -269,7 +269,12 @@ export function createRouterState({ file = defaultStatePath(), maxRuns = MAX_RUN
       try {
         cache = null
         const { state } = await readFresh({ recoverCorrupt: true })
-        if (pendingNotices.length) state.notices.push(...pendingNotices)
+        if (pendingNotices.length) {
+          state.notices.push(...pendingNotices)
+          // Recovery may already have moved the damaged file before a failed
+          // update. Its pending notice must carry the missing-history marker.
+          state.historyIncomplete ||= pendingNotices.some(notice => notice.kind === 'state-corrupt')
+        }
         const result = await change(state)
         const returned = result === undefined ? undefined : structuredClone(result)
         retainRuns(state, historyLimit)