@ljwei-stak/dsh-model-router 0.22.1 → 0.23.0

package/.dsh-plugin/index.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)
@@ -1482,7 +1501,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 +1743,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 +1774,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 +1785,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 +1839,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 +1857,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 +1890,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`)
@@ -231,6 +240,8 @@ export const OFFICIAL_TOOLS_REMOTE_DESCRIPTORS = Object.freeze([
   // Workbench "start a run": plan preview with cost estimate and confirmation reasons, then execute.
   descriptor('previewRun', [jsonParameter('request', runRequestCodec)], anyObjectCodec('RunPreview')),
   descriptor('startRun', [jsonParameter('request', runRequestCodec)], anyObjectCodec('RunStarted')),
+  descriptor('runStatus', [jsonParameter('request', runJobRequestCodec)], anyObjectCodec('RunJobStatus')),
+  descriptor('cancelRun', [jsonParameter('request', runJobRequestCodec)], anyObjectCodec('RunJobStatus')),
   // 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)

package/.dsh-plugin/shared/run-jobs.mjs

@@ -0,0 +1,169 @@
+/**
+ * In-memory Host workbench jobs. Only package identity and state enter progress;
+ * answers and the rest of the workbench response stay in the final result.
+ */
+import { randomUUID } from 'node:crypto'
+
+const ACTIVE = new Set(['running', 'cancelling'])
+const PACKAGE_DONE = new Set(['succeeded', 'failed', 'cancelled', 'blocked', 'skipped'])
+const FAILURE = 'Run failed. Please try again.'
+
+const copy = value => JSON.parse(JSON.stringify(value))
+const label = (value, fallback = '') => typeof value === 'string' ? value : fallback
+
+function positiveLimit(value, name) {
+  if (!Number.isSafeInteger(value) || value < 1) throw new TypeError(`${name} must be a positive integer.`)
+  return value
+}
+
+function completionStatus(item) {
+  if (item.cancelled === true || item.status === 'cancelled') return 'cancelled'
+  if (item.blocked === true || item.status === 'blocked') return 'blocked'
+  if (item.notStarted === true || item.status === 'skipped') return 'skipped'
+  if (item.status === 'succeeded' || item.status === 'failed') return item.status
+  return item.ok === true ? 'succeeded' : 'failed'
+}
+
+/**
+ * start() returns before invoking run(). Cancellation requests abort the same
+ * signal given to run(), but the job remains active until run actually settles.
+ * maxJobs bounds all retained jobs, and only terminal jobs may be evicted.
+ */
+export function createRunJobs({ now = Date.now, maxJobs = 50, maxActive = 4 } = {}) {
+  if (typeof now !== 'function') throw new TypeError('now must be a function.')
+  positiveLimit(maxJobs, 'maxJobs')
+  positiveLimit(maxActive, 'maxActive')
+  const jobs = new Map()
+  let disposed = false
+
+  // A clock supplied by a Host must not turn a settled worker into an unhandled
+  // rejection or make a snapshot impossible to send over JSON.
+  const timestamp = () => {
+    try {
+      const value = now()
+      if (typeof value === 'number' && Number.isFinite(value)) return value
+    } catch { /* retain a usable timestamp if the injected clock fails */ }
+    return Date.now()
+  }
+  const snapshot = job => copy(job.snapshot)
+  const find = jobId => {
+    const job = jobs.get(jobId)
+    if (!job) throw new Error('Unknown run job id.')
+    return job
+  }
+
+  function refreshProgress(job) {
+    const progress = job.snapshot.progress
+    progress.total = progress.packages.length
+    progress.completed = progress.packages.filter(item => PACKAGE_DONE.has(item.status)).length
+    const current = progress.packages.findLast(item => item.status === 'running')
+    progress.current = current ? { id: current.id, name: current.name } : null
+  }
+
+  function packageFor(job, value) {
+    if (!value || typeof value !== 'object') return null
+    const id = label(value.id)
+    if (!id) return null
+    let item = job.snapshot.progress.packages.find(item => item.id === id)
+    if (!item) {
+      item = { id, name: label(value.name, id), status: 'pending' }
+      job.snapshot.progress.packages.push(item)
+    }
+    return item
+  }
+
+  function progressFor(job, event) {
+    if (!ACTIVE.has(job.snapshot.status) || !event || typeof event !== 'object') return
+    // Progress is advisory: malformed events must not break the actual worker.
+    try {
+      if (event.type === 'stage') {
+        if (typeof event.stage === 'string') job.snapshot.progress.stage = event.stage.slice(0, 120)
+        return
+      }
+      if (event.type !== 'package-start' && event.type !== 'package-complete') return
+      const item = packageFor(job, event.package)
+      if (!item || PACKAGE_DONE.has(item.status)) return
+      item.status = event.type === 'package-start' ? 'running' : completionStatus(event.package)
+      refreshProgress(job)
+    } catch { /* progress cannot affect the final workbench response */ }
+  }
+
+  function finish(job, status, result = null) {
+    if (!ACTIVE.has(job.snapshot.status)) return
+    const state = job.snapshot
+    state.status = status
+    state.finishedAt = timestamp()
+    state.result = result
+    state.progress.stage = status
+    for (const item of state.progress.packages) {
+      if (PACKAGE_DONE.has(item.status)) continue
+      // Pending packages were never observed running; once the worker settles,
+      // they cannot start. An interrupted running package has a known outcome.
+      item.status = status === 'cancelled' ? 'cancelled'
+        : item.status === 'running' ? (status === 'failed' ? 'failed' : 'succeeded') : 'skipped'
+    }
+    refreshProgress(job)
+    if (status === 'failed') state.error = FAILURE
+  }
+
+  function fail(job) {
+    finish(job, job.controller.signal.aborted ? 'cancelled' : 'failed')
+  }
+
+  function requestCancel(job) {
+    if (ACTIVE.has(job.snapshot.status) && !job.snapshot.cancelRequested) {
+      job.snapshot.cancelRequested = true
+      job.snapshot.status = 'cancelling'
+      job.snapshot.progress.stage = 'cancelling'
+      job.controller.abort()
+    }
+    return snapshot(job)
+  }
+
+  return {
+    start({ run, packages = [] } = {}) {
+      if (disposed) throw new Error('Run job manager is disposed.')
+      if (typeof run !== 'function') throw new TypeError('Run job requires a run function.')
+      if ([...jobs.values()].filter(job => ACTIVE.has(job.snapshot.status)).length >= maxActive) {
+        throw new Error('Too many active run jobs.')
+      }
+      // Evict the oldest terminal snapshots first. A cancelling worker still
+      // occupies capacity because its process/cleanup may still be running.
+      if (jobs.size >= maxJobs) {
+        const terminal = [...jobs].find(([, job]) => !ACTIVE.has(job.snapshot.status))
+        if (!terminal) throw new Error('Run job capacity reached; active jobs are still running.')
+        jobs.delete(terminal[0])
+      }
+      const job = {
+        controller: new AbortController(),
+        snapshot: {
+          jobId: randomUUID(), status: 'running', startedAt: timestamp(), finishedAt: null,
+          cancelRequested: false,
+          progress: { total: 0, completed: 0, current: null, stage: 'starting', packages: [] },
+          result: null,
+        },
+      }
+      for (const item of Array.isArray(packages) ? packages : []) packageFor(job, item)
+      refreshProgress(job)
+      jobs.set(job.snapshot.jobId, job)
+      // Both rejection paths are attached before the worker can run. Result
+      // cloning also detaches the worker's mutable response from stored state.
+      Promise.resolve().then(() => run({
+        signal: job.controller.signal,
+        onProgress: event => progressFor(job, event),
+      })).then(result => {
+        const value = result == null ? null : copy(result)
+        const cancelled = value?.status === 'cancelled' || value?.execution?.status === 'cancelled'
+        finish(job, cancelled ? 'cancelled' : 'completed', value)
+      }, () => fail(job)).catch(() => fail(job))
+      return snapshot(job)
+    },
+    status(jobId) { return snapshot(find(jobId)) },
+    cancel(jobId) { return requestCancel(find(jobId)) },
+    dispose() {
+      if (disposed) return
+      disposed = true
+      for (const job of jobs.values()) requestCancel(job)
+    },
+  }
+}

package/.dsh-plugin/shared/task-executors.mjs

@@ -1223,6 +1223,12 @@ function aggregateOf(results) {
   return { status, packages: results, aggregate }
 }
 
+/** Host-only observation hooks must never discard execution or billing evidence. */
+export async function observeExecutionProgress(hook, value) {
+  if (typeof hook !== 'function') return
+  try { await hook(value) } catch { /* Progress reporting does not control execution. */ }
+}
+
 function checkedPackageSelections(packages, routes, overrides, runVerified, targets) {
   const preceding = new Set()
   const selected = {}
@@ -1299,10 +1305,12 @@ async function runManualTool(target, prompt, options) {
  */
 async function runPackages({ packages, task, routingBypassed, routes, previous = [], targets = null, overrides = {}, choices = {}, options }) {
   const routeList = Array.isArray(routes) ? routes : []
-  const { credentialsFor, onPackage, billing, ...runOptions } = options
+  const { credentialsFor, onPackageStart, onPackage, onStage, billing, ...runOptions } = options
+  await observeExecutionProgress(onStage, 'preparing')
   const effectivePackages = checkedPackageSelections(packages, routeList, overrides, runOptions.runVerified, targets)
   const results = []
   const ranIds = []
+  if (!runOptions.signal?.aborted) await observeExecutionProgress(onStage, 'executing')
   for (const item of effectivePackages) {
     const kept = previous.find(result => result.id === item.id)
     if (targets && !targets.has(item.id) && kept) {
@@ -1315,14 +1323,17 @@ async function runPackages({ packages, task, routingBypassed, routes, previous =
     const provider = target?.kind === 'tool' ? 'official-tool' : target?.provider ?? override?.provider ?? item.recommendedProvider
     const model = target?.kind === 'tool' ? target.toolId : target?.model ?? override?.model ?? item.recommendedModel
     const identity = { ...selection, ...(item.type ? { type: item.type } : {}), ...(item.purpose ? { purpose: item.purpose } : {}) }
-    if (runOptions.signal?.aborted) {
+    const cancelledBeforeStart = async () => {
       // Cancelled: later packages are not started (no CLI process, no API spend).
       const cancelled = { id: item.id, name: item.name, ok: false, provider, model,
         channel: target?.kind === 'tool' ? 'official-cli' : 'harness-llm', ...(target?.kind === 'tool' ? { toolId: target.toolId } : {}),
         ...identity, answer: '', fallback: null, cancelled: true, notStarted: true, error: '执行已取消，此步骤未开始。' }
       results.push(cancelled)
       ranIds.push(item.id)
-      if (typeof onPackage === 'function') await onPackage(cancelled)
+      await observeExecutionProgress(onPackage, cancelled)
+    }
+    if (runOptions.signal?.aborted) {
+      await cancelledBeforeStart()
       continue
     }
     const unmet = (item.dependsOn ?? []).filter(id => results.find(result => result.id === id)?.ok !== true)
@@ -1338,7 +1349,7 @@ async function runPackages({ packages, task, routingBypassed, routes, previous =
       }
       results.push(blocked)
       ranIds.push(item.id)
-      if (typeof onPackage === 'function') await onPackage(blocked)
+      await observeExecutionProgress(onPackage, blocked)
       continue
     }
     const plannedRoute = routeList.find(candidate => candidate.provider === provider && candidate.model === model)
@@ -1347,13 +1358,24 @@ async function runPackages({ packages, task, routingBypassed, routes, previous =
       : target?.kind === 'tool' ? { provider, model } : reasoningRouteForAssignment(plannedRoute, item, override)
     if (target?.kind === 'api') delete route.reasoningEffort
     const promptText = routingBypassed ? checkedTask(task) : packagePrompt(task, item, results)
+    const credentials = !target ? (typeof credentialsFor === 'function' ? await credentialsFor(route) : runOptions.credentials ?? null) : null
+    if (runOptions.signal?.aborted) {
+      await cancelledBeforeStart()
+      continue
+    }
     const startedAt = Date.now()
+    await observeExecutionProgress(onPackageStart, { ...item, ...identity, provider, model, startedAt,
+      channel: target?.kind === 'tool' ? 'official-cli' : 'harness-llm',
+      ...(target?.kind === 'tool' ? { toolId: target.toolId } : {}) })
+    if (runOptions.signal?.aborted) {
+      await cancelledBeforeStart()
+      continue
+    }
     let result
     if (target?.kind === 'tool') result = await runManualTool(target, promptText, runOptions)
     else if (target?.kind === 'api') result = { ...await useApi(runOptions.apiFallback, { route, task: promptText,
       signal: runOptions.signal, preference: 'api', reason: '按工作包手动选择模型目录 API。' }), fallback: null }
     else {
-      const credentials = typeof credentialsFor === 'function' ? await credentialsFor(route) : runOptions.credentials ?? null
       result = await executeRouteWithBilling({
         ...runOptions,
         billing: billing ? { ...billing, routes: billing.routes ?? routeList, ...(choices[item.id] ? { choice: choices[item.id] } : {}) } : null,
@@ -1382,7 +1404,7 @@ async function runPackages({ packages, task, routingBypassed, routes, previous =
     }
     results.push(entry)
     ranIds.push(item.id)
-    if (typeof onPackage === 'function') await onPackage(entry)
+    await observeExecutionProgress(onPackage, entry)
   }
   return { ...aggregateOf(results), ranIds }
 }