@ljwei-stak/dsh-model-route-bot 0.64.0 → 0.65.0

package/apps/integration-client/routing-submissions.mjs

@@ -0,0 +1,68 @@
+// One unresolved submission per connected product API. Keep only its reference in window memory;
+// tasks, outputs, credentials and previews never enter this cache or browser storage.
+const scopes = new WeakMap()
+const same = (left, right) => left?.requestKey === right?.requestKey && left?.requesterBotId === right?.requesterBotId
+const reference = value => {
+  for (const field of ['requestKey', 'requesterBotId']) {
+    if (typeof value?.[field] !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(value[field])) throw new TypeError('INVALID_ROUTING_SUBMISSION_REFERENCE')
+  }
+  return { requestKey: value.requestKey, requesterBotId: value.requesterBotId }
+}
+
+// This portable code is a lookup reference, never authority or a task to execute.
+export function submissionCode(input) {
+  const value = reference(input)
+  return `dsh-route-v1:${value.requesterBotId}:${value.requestKey}`
+}
+
+function parseCode(code) {
+  if (typeof code !== 'string' || code.length > 1024) throw new TypeError('INVALID_ROUTING_SUBMISSION_CODE')
+  const match = /^dsh-route-v1:([A-Za-z0-9_-]{1,128}):([A-Za-z0-9_-]{1,128})$/.exec(code.trim())
+  if (!match) throw new TypeError('INVALID_ROUTING_SUBMISSION_CODE')
+  return { requesterBotId: match[1], requestKey: match[2] }
+}
+
+export function routingSubmissions(scope) {
+  if (!scope || !['object', 'function'].includes(typeof scope)) throw new TypeError('ROUTING_SUBMISSION_SCOPE_REQUIRED')
+  if (scopes.has(scope)) return scopes.get(scope)
+  let value = null
+  const listeners = new Set()
+  const publish = next => { value = next === null ? null : Object.freeze(next); for (const listener of [...listeners]) listener() }
+  const store = Object.freeze({
+    getSnapshot: () => value,
+    subscribe: listener => { listeners.add(listener); return () => listeners.delete(listener) },
+    start(input) {
+      const identity = reference(input)
+      if (value) return false
+      publish({ ...identity, state: 'submitting', planId: null, planState: null })
+      return true
+    },
+    restore(code) {
+      if (value) return false
+      publish({ ...parseCode(code), state: 'unknown', planId: null, planState: null })
+      return true
+    },
+    update(input, result) {
+      if (!same(value, input)) return false
+      if (!['unknown', 'not-found', 'confirmed'].includes(result.state)) throw new TypeError('INVALID_ROUTING_SUBMISSION_STATE')
+      // A delayed failed lookup cannot erase a receipt that already confirmed acceptance.
+      if (value.state === 'confirmed' && result.state !== 'confirmed') return false
+      publish({ ...reference(input), state: result.state,
+        planId: result.state === 'confirmed' ? result.planId : null,
+        planState: result.state === 'confirmed' ? result.planState ?? (value.state === 'confirmed' ? value.planState : null) : null })
+      return true
+    },
+    clear(input) {
+      if (!same(value, input) || value.state !== 'confirmed') return false
+      publish(null)
+      return true
+    },
+    dismissUnconfirmed(input) {
+      if (!same(value, input) || value.state !== 'not-found') return false
+      publish(null)
+      return true
+    },
+  })
+  scopes.set(scope, store)
+  return store
+}

package/apps/integration-client/task-progress.mjs

@@ -0,0 +1,46 @@
+import { deriveBotAttention } from './bot-attention.mjs'
+
+export const taskIdOf = row => row.taskId ?? row.id
+export const taskKey = row => JSON.stringify([row.botId ?? '', taskIdOf(row)])
+export const taskTitle = row => row.title || row.input?.task || taskIdOf(row) || '未命名任务'
+export const TASK_FILTERS = Object.freeze([['all', '全部'], ['active', '进行中'], ['attention', '待处理'], ['finished', '已结束']])
+const active = new Set(['queued', 'ready', 'running', 'admitting', 'cancelling'])
+const ended = new Set(['succeeded', 'cancelled', 'skipped'])
+
+/** Counts describe only the loaded, committed records. A truncated view says so in the UI. */
+export function taskProgress(snapshot) {
+  const items = snapshot?.tasks?.status === 'available' && Array.isArray(snapshot.tasks.items) ? snapshot.tasks.items : []
+  const attention = deriveBotAttention({ ...snapshot, tasks: { items } }, { limit: Infinity })
+  const attentionKeys = new Set(attention.map(row => taskKey(row)))
+  const category = row => attentionKeys.has(taskKey(row)) ? 'attention' : active.has(row.state) ? 'active' : ended.has(row.state) ? 'finished' : 'other'
+  const bots = new Map((snapshot?.bots ?? []).map(bot => [bot.id, { botId: bot.id, name: bot.name, all: 0, active: 0, attention: 0, finished: 0, other: 0 }]))
+  const counts = { all: items.length, active: 0, attention: 0, finished: 0, other: 0 }
+  for (const row of items) {
+    const kind = category(row); counts[kind]++
+    if (!bots.has(row.botId)) bots.set(row.botId, { botId: row.botId, name: row.botId || '未取得归属', all: 0, active: 0, attention: 0, finished: 0, other: 0 })
+    const bot = bots.get(row.botId); bot.all++; bot[kind]++
+  }
+  return { items, attention, counts, bots: [...bots.values()], category }
+}
+
+export function filterTasks(progress, { botId = '', status = 'all', query = '' } = {}) {
+  const names = new Map(progress.bots.map(bot => [bot.botId, bot.name]))
+  const text = query.trim().toLocaleLowerCase()
+  return progress.items.filter(row => (!botId || row.botId === botId) && (status === 'all' || progress.category(row) === status)
+    && (!text || [taskTitle(row), row.botId, names.get(row.botId), taskIdOf(row), row.planId, row.operationId, row.attemptId]
+      .some(value => typeof value === 'string' && value.toLocaleLowerCase().includes(text))))
+}
+
+export const TASK_EVENTS = Object.freeze({
+  queued: '任务已排队', dispatched: '开始执行', 'admission-prepared': '开始资金准入',
+  'admission-reference-prepared': '执行引用已保存', 'financial-admission-committed': '资金准入已提交',
+  'execution-linked-before-admission': '已关联原执行记录', settled: '本次尝试已结算',
+  'cancel-requested': '已请求停止，等待确认', 'cancel-requested-unconfirmed': '已请求停止，原操作仍待核对',
+  'plan-cancel-requested': '已请求停止整个计划', 'cancelled-before-dispatch': '启动前已停止',
+  'cancelled-while-waiting-budget': '等待预算期间已停止', 'dependency-blocked': '前置任务失败，尚未执行',
+  interrupted: '宿主中断，执行结果待核对', reconciled: '已核对原执行记录', blocked: '任务受阻',
+  deadline: '已到任务期限', 'budget-wait-expired': '预算等待已到期', 'retry-fenced': '重试已被拦截',
+  'admission-conflict': '资金准入记录冲突，需核对', 'dispatch-closed-before-entry': '启动前已阻止派发',
+  'admission-closed-not-dispatched': '已确认未派发', 'admission-recovered-cancelled': '恢复时确认启动前已停止',
+  'admission-recovered-not-dispatched': '恢复时确认原操作未派发',
+})

package/apps/integration-client/tasks-panel.jsx

@@ -0,0 +1,147 @@
+import React, { useEffect, useMemo, useRef, useState } from 'react'
+import { TASK_STATES } from './api.mjs'
+import { botAttentionSummary, remoteUncertain } from './bot-attention.mjs'
+import { filterTasks, taskProgress, taskIdOf, taskKey, taskTitle, TASK_FILTERS, TASK_EVENTS } from './task-progress.mjs'
+import { UiIcon } from './ui-icons.jsx'
+
+const Tag = ({ children }) => <span className="bp-tag">{children}</span>
+const date = value => value === null || value === undefined || !Number.isFinite(new Date(value).getTime()) ? '未取得' : new Date(value).toLocaleString('zh-CN')
+const Value = ({ label, children }) => <div className="bp-value"><dt>{label}</dt><dd>{children ?? '未取得'}</dd></div>
+const stopKnown = row => !row.result?.remote || row.result.remote.stopConfirmed === true
+
+function TaskActions({ row, actions, dispatch, busy }) {
+  const pending = useRef(false)
+  const run = async action => {
+    if (busy || pending.current || !dispatch || !actions.includes(action)) return
+    pending.current = true
+    try { await dispatch(action, { botId: row.botId, taskId: taskIdOf(row), ...(action === 'task.cancel' ? {} : { requestKey: crypto.randomUUID() }) }) }
+    finally { pending.current = false }
+  }
+  return <>
+    {actions.includes('task.cancel') && !['cancelled', 'succeeded', 'failed', 'skipped'].includes(row.state) && <button disabled={busy} onClick={() => { void run('task.cancel') }}>停止</button>}
+    {actions.includes('task.retry') && ['failed', 'cancelled', 'waiting-budget'].includes(row.state) && <button disabled={busy || !stopKnown(row)} onClick={() => { if (stopKnown(row)) void run('task.retry') }}>重试</button>}
+    {actions.includes('task.reconcile') && row.state === 'needs-reconciliation' && <button disabled={busy} onClick={() => { void run('task.reconcile') }}>核对原收据</button>}
+  </>
+}
+
+function RemoteNotice({ row }) {
+  const remote = row.result?.remote
+  if (!remote) return null
+  if (!stopKnown(row)) return <small role="status">写入或停止尚未确认，请核对原操作；不会自动重发，也暂不能重试。</small>
+  if (remote.notStarted === true && remote.possiblyApplied !== true) return <small>原操作未启动。</small>
+  if (remote.status === 'succeeded') return <small>写入已确认。{row.state === 'cancelled' ? '取消未撤销文件变更。' : ''}</small>
+  return remote.possiblyApplied === true ? <small>操作已停止，文件可能已改变；重试不会撤销已有变更，请先核对产物。</small> : null
+}
+
+function TaskDetail({ task, inspect, busy, actions, dispatch, onClose, bot, openSession }) {
+  const [history, setHistory] = useState(null), [failure, setFailure] = useState(''), [loading, setLoading] = useState(false)
+  const [reload, setReload] = useState(0)
+  const ref = useRef(null)
+  const key = taskKey(task)
+  useEffect(() => { ref.current?.focus({ preventScroll: true }); ref.current?.scrollIntoView?.({ block: 'nearest' }) }, [key])
+  useEffect(() => {
+    const controller = new AbortController()
+    setHistory(null); setFailure(''); setLoading(false)
+    if (!inspect || !actions.includes('task.inspect')) return () => controller.abort()
+    setLoading(true)
+    Promise.resolve().then(() => { if (!controller.signal.aborted) return inspect({ botId: task.botId, taskId: taskIdOf(task) }, controller.signal) }).then(value => {
+      if (controller.signal.aborted) return
+      if (!value?.task || taskKey(value.task) !== key || !Array.isArray(value.attempts) || !Array.isArray(value.timeline?.items)
+        || (task.updatedAt != null && (!Number.isFinite(value.task.updatedAt) || value.task.updatedAt < task.updatedAt))) throw new Error('返回记录与当前任务不一致，请刷新后再次读取。')
+      setHistory(value)
+    }).catch(cause => { if (!controller.signal.aborted) setFailure(cause.message || '任务时间线读取失败。') })
+      .finally(() => { if (!controller.signal.aborted) setLoading(false) })
+    return () => controller.abort()
+  }, [key, task.updatedAt, inspect, actions.includes('task.inspect'), reload])
+  const data = history?.task ?? task
+  return <article className="bp-card bp-task-detail" aria-label="任务详情" ref={ref} tabIndex={-1}>
+    <div className="bp-card-title"><div><h2>任务详情</h2><p>{taskTitle(task)}</p></div><button type="button" onClick={onClose}>关闭</button></div>
+    <div className="bp-actions"><Tag>{TASK_STATES[data.state] ?? data.state}</Tag><span>{bot?.name ?? task.botId ?? '未取得归属'}</span>
+      {bot?.sessionId && openSession && <button type="button" onClick={() => openSession(bot.sessionId)}>打开 Bot 私聊</button>}
+      <TaskActions row={data} actions={actions} dispatch={dispatch} busy={busy} /></div>
+    <RemoteNotice row={data} />
+    <dl className="bp-facts"><Value label="创建">{date(data.createdAt)}</Value><Value label="最近更新">{date(data.updatedAt)}</Value><Value label="期限">{date(data.deadlineAt)}</Value></dl>
+    <h3>任务时间线</h3>
+    {loading && <p role="status" className="bp-muted">正在读取原任务日志…</p>}
+    {failure && <p role="alert" className="bp-error">{failure}</p>}
+    {inspect && actions.includes('task.inspect') && <button type="button" disabled={loading} onClick={() => setReload(value => value + 1)}>重新读取时间线</button>}
+    {!actions.includes('task.inspect') && <p className="bp-muted">此宿主尚未提供任务时间线，可在下方查看现有收据依据。</p>}
+    {history && <>
+      <p className="bp-muted">{history.attempts.length} 次执行尝试 · {history.timeline.total} 条日志{history.timeline.truncated ? `，显示最近 ${history.timeline.items.length} 条` : ''}。停止请求需等待原操作确认。</p>
+      <ol className="bp-task-timeline">{history.timeline.items.map(event => <li key={event.seq}>
+        <span className="bp-timeline-dot" aria-hidden="true" /><div><strong>{TASK_EVENTS[event.kind] ?? '任务状态更新'}</strong>
+          <small><time>{date(event.at)}</time>{event.attemptNumber != null ? ` · 第 ${event.attemptNumber} 次尝试` : ''}{event.outcome ? ` · ${TASK_STATES[event.outcome] ?? (event.outcome === 'unknown' ? '结果未知' : event.outcome)}` : ''}</small>
+          {event.code && <small className="bp-code">{event.code}</small>}</div>
+      </li>)}</ol>
+      {history.timeline.items.length === 0 && <p className="bp-muted">原日志中暂无事件。</p>}
+      <details className="bp-technical"><summary>每次尝试的身份与时间</summary><ul className="bp-checklist">{history.attempts.map(attempt => <li key={attempt.attemptId}>
+        <strong>第 {attempt.number} 次 · {TASK_STATES[attempt.state] ?? attempt.state}</strong><small>开始 {date(attempt.startedAt)} · 结束 {date(attempt.finishedAt)}</small><small className="bp-code">{attempt.attemptId} · {attempt.operationId}</small>
+      </li>)}</ul></details>
+    </>}
+    <details className="bp-technical"><summary>原任务与操作编号</summary><dl className="bp-facts"><Value label="Task">{taskIdOf(data)}</Value><Value label="Package">{data.packageId}</Value><Value label="Attempt">{data.attemptId}</Value><Value label="Operation">{data.operationId}</Value><Value label="MR 运行">{data.legacyRunIds?.join('、')}</Value></dl></details>
+    <details className="bp-technical"><summary>执行与收据依据</summary><pre>{JSON.stringify({ attempts: history?.attempts ?? task.attempts, executionRef: task.executionRef, remoteReceipt: data.result?.remote, reconciliation: data.reconciliation, packages: task.packages }, null, 2)}</pre></details>
+  </article>
+}
+
+export function TaskWorkspace({ snapshot, dispatch, busy, scope, inspect, openSession, routingCard }) {
+  const progress = useMemo(() => taskProgress(snapshot), [snapshot])
+  const [botId, setBotId] = useState(''), [status, setStatus] = useState('all'), [query, setQuery] = useState('')
+  const [expanded, setExpanded] = useState(false), [selection, setSelection] = useState(null)
+  useEffect(() => { setBotId(''); setStatus('all'); setQuery(''); setExpanded(false); setSelection(null) }, [scope])
+  const rows = filterTasks(progress, { botId, status, query })
+  const task = selection && selection.scope === scope ? progress.items.find(row => taskKey(row) === selection.key) : null
+  const actions = snapshot.availableActions ?? []
+  const select = row => setSelection({ scope, key: taskKey(row) })
+  const attention = expanded ? progress.attention : progress.attention.slice(0, 6)
+  const [showPlans, setShowPlans] = useState(false)
+  return <>
+    <section className="bp-card bp-task-overview" aria-label="多 Bot 任务总览">
+      <div className="bp-card-title"><div><h2>团队任务</h2><p className="bp-muted">按 Bot 查看进展，优先处理需要你介入的任务。</p></div><Tag>{progress.items.length} 条已加载</Tag></div>
+      {snapshot.tasks.truncated && <p role="status" className="bp-blocked">已加载 {progress.items.length} / {snapshot.tasks.total} 条任务，优先显示待处理与进行中的记录。下方数量与筛选仅针对已加载任务。</p>}
+      <div className="bp-task-counts" aria-label="按状态筛选任务">{TASK_FILTERS.map(([value, label]) => <button key={value} type="button" aria-pressed={status === value} onClick={() => setStatus(value)}><strong>{progress.counts[value]}</strong><span>{label}</span></button>)}</div>
+      <div className="bp-task-bots" aria-label="按 Bot 筛选任务"><button type="button" aria-pressed={!botId} onClick={() => setBotId('')}>全部 Bot</button>{progress.bots.map(bot => <button key={bot.botId ?? ''} type="button" aria-pressed={botId === bot.botId} onClick={() => setBotId(bot.botId ?? '')}>
+        <UiIcon name="bot" size={16} /><span>{bot.name}<small>{bot.active} 进行中 · {bot.attention} 待处理 · {bot.all} 条任务</small></span></button>)}</div>
+    </section>
+    {progress.attention.length > 0 && <section className="bp-card bp-attention" aria-label="需要你处理">
+      <div className="bp-card-title"><h2>需要你处理</h2><Tag>{botAttentionSummary(progress.attention)}</Tag></div>
+      <ul className="bp-attention-list">{attention.map(row => {
+        const original = progress.items.find(task => taskKey(task) === taskKey(row))
+        return <li key={taskKey(row)} className={`bp-attention-row bp-attention-${row.stage}`}><div><strong>{row.title}</strong><p className="bp-muted">{row.detail}</p>
+          {row.stage === 'approve' && <small>打开 Bot 私聊查看原审批请求。</small>}
+          {remoteUncertain(original) && <small>原操作仍待核对，请查看任务详情。</small>}</div><div className="bp-actions">
+          <button type="button" onClick={() => select(original)}>打开任务</button>
+          {row.stage === 'approve' && openSession && snapshot.bots?.find(bot => bot.id === row.botId)?.sessionId && <button type="button" onClick={() => openSession(snapshot.bots.find(bot => bot.id === row.botId).sessionId)}>打开审批会话</button>}
+          {row.stage === 'reconcile' && actions.includes('task.reconcile') && <TaskActions row={original} actions={['task.reconcile']} dispatch={dispatch} busy={busy} />}
+          {row.stage === 'failed' && actions.includes('task.retry') && <TaskActions row={original} actions={['task.retry']} dispatch={dispatch} busy={busy} />}
+        </div></li>
+      })}</ul>
+      {progress.attention.length > 6 && <button type="button" aria-expanded={expanded} onClick={() => setExpanded(value => !value)}>{expanded ? '收起待处理事项' : `查看全部 ${progress.attention.length} 项待处理`}</button>}
+    </section>}
+    {task && <TaskDetail key={taskKey(task)} task={task} inspect={inspect} busy={busy} actions={actions} dispatch={dispatch} onClose={() => setSelection(null)} bot={snapshot.bots?.find(bot => bot.id === task.botId)} openSession={openSession} />}
+    <section className="bp-card" aria-label="任务记录"><div className="bp-card-title"><h2>任务记录</h2><span className="bp-muted" role="status">显示 {rows.length} / {progress.items.length} 条</span></div>
+      <div className="bp-task-search"><label>搜索任务<input type="search" value={query} placeholder="任务名称、Bot 或任务 / 计划 / 操作编号" onChange={event => setQuery(event.target.value)} /></label>
+        {(query || botId || status !== 'all') && <button type="button" onClick={() => { setQuery(''); setBotId(''); setStatus('all') }}>清除筛选</button>}</div>
+      {!progress.items.length ? <p className="bp-empty">尚无持久任务。在 Main 私聊中提出目标后，可在这里查看工作包、执行尝试与收据。</p> : rows.length === 0 ? <p className="bp-empty">没有符合当前筛选的任务。可清除筛选查看其他记录。</p> : <div className="bp-table-wrap"><table>
+        <thead><tr><th>任务</th><th>Bot</th><th>状态</th><th>执行尝试</th><th>操作</th></tr></thead><tbody>{rows.map(row => <tr key={taskKey(row)}>
+          <td><button className="bp-text-button" onClick={() => select(row)}>{taskTitle(row)}</button><small>更新 {date(row.updatedAt)}</small></td>
+          <td>{snapshot.bots?.find(bot => bot.id === row.botId)?.name ?? row.botId ?? '未取得归属'}</td><td><Tag>{TASK_STATES[row.state] ?? row.state}</Tag>{row.blockedReason && <small>{row.blockedReason}</small>}<RemoteNotice row={row} /></td>
+          <td>{Number.isSafeInteger(row.attempts) ? row.attempts : row.attempts?.length ?? row.attemptCount ?? '未知'}</td><td className="bp-actions"><TaskActions row={row} actions={actions} dispatch={dispatch} busy={busy} /></td>
+        </tr>)}</tbody></table></div>}
+    </section>
+    {snapshot.tasks.plans?.length > 0 && <section className="bp-task-plans"><button type="button" aria-expanded={showPlans} onClick={() => setShowPlans(value => !value)}>{showPlans ? '收起协作计划' : `查看 ${snapshot.tasks.plans.length} 个协作计划`}</button>
+      {/* Dependency and cancellation evidence stays visible even when other plans are collapsed. */}
+      {snapshot.tasks.plans.filter(plan => showPlans || plan.needsReconciliation || !['succeeded', 'cancelled', 'failed'].includes(plan.state)).map((plan, index) => <article className="bp-card" key={plan.planId}>
+        <div className="bp-card-title"><div><h2>协作计划 {index + 1}</h2><p className="bp-muted">{plan.packages.length} 个工作包 · {plan.packages.filter(item => item.state === 'succeeded').length} 个已完成</p></div><div className="bp-actions"><Tag>{TASK_STATES[plan.state] ?? plan.state}</Tag>
+          {actions.includes('task.plan.cancel') && !['succeeded', 'cancelled'].includes(plan.state) && <button disabled={busy} onClick={() => dispatch('task.plan.cancel', { botId: plan.ownerBotId, planId: plan.planId })}>停止整个计划</button>}</div></div>
+        {plan.needsReconciliation && <p role="status">有工作包停止尚未确认，请核对原收据；计划尚未完成停止。</p>}
+        <ul className="bp-plan-list">{plan.packages.map((item, step) => {
+          const linked = progress.items.find(row => taskIdOf(row) === item.taskId && row.botId === item.targetBotId)
+          return <li key={item.id}><span className="bp-plan-step">{item.state === 'succeeded' ? <UiIcon name="check" size={13} /> : step + 1}</span><div className="bp-plan-copy">
+            {linked ? <button className="bp-text-button" onClick={() => select(linked)}>{taskTitle(linked)}</button> : <strong>{plan.plan?.packages?.find(pkg => pkg.id === item.id)?.objective ?? `工作包 ${step + 1}`}</strong>}
+            <small>{snapshot.bots?.find(bot => bot.id === item.targetBotId)?.name ?? item.targetBotId}{item.dependsOn.length > 0 && ` · 前置：${item.dependsOn.join('、')}`}{item.result?.code === 'DEPENDENCY_FAILED' && ' · 前置包失败，尚未执行'}</small></div><Tag>{TASK_STATES[item.state] ?? item.state}</Tag></li>
+        })}</ul><details className="bp-technical bp-plan-id"><summary>计划编号</summary><p className="bp-code">{plan.planId}</p></details>
+      </article>)}
+    </section>}
+    {routingCard}
+  </>
+}

package/modules/bot-runtime/read-model.mjs

@@ -11,13 +11,13 @@ const missing = {
   usage: blocked('宿主尚未提供统一费用与预占投影。', '接入唯一 MR 资金库的只读投影；已有 Token 用量仍可在 DS 用量页查看。'),
 }
 const ACTIONS = new Set([
-  'task.cancel', 'task.retry', 'task.reconcile', 'task.plan.submit', 'task.plan.cancel', 'usage.resolve',
+  'task.inspect', 'task.cancel', 'task.retry', 'task.reconcile', 'task.plan.submit', 'task.plan.cancel', 'usage.resolve',
   'binding.save', 'funding.account.save', 'machine.secret', 'machine.pair', 'machine.bind', 'machine.probe',
   'machine.revoke', 'machine.reconcile', 'machine.artifact', 'machine.desktop.view', 'machine.desktop.act',
   'machine.desktop.open', 'machine.desktop.renew', 'machine.desktop.close',
   'library.list', 'library.read', 'library.write', 'library.upload', 'library.download', 'library.remove', 'library.mkdir', 'library.search',
   'routine.list', 'routine.run', 'routine.save', 'routine.remove', 'routine.history', 'routine.cancel', 'routine.resolve', 'roles.list',
-  'botRoutingInspect', 'botRoutingDecide', 'botRouting.dispatch', 'botRouting.save',
+  'botRoutingInspect', 'botRoutingDecide', 'botRouting.dispatch', 'botRouting.save', 'botRouting.status',
   'botRuntimeStatus', 'botRuntimeMove', 'botRuntimeHistory', 'botRuntimeMessage',
 ])
 const plain = value => value && typeof value === 'object' && !Array.isArray(value)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ljwei-stak/dsh-model-route-bot",
-  "version": "0.64.0",
+  "version": "0.65.0",
   "type": "module",
   "description": "DSH Bot workspace with integrated model routing, official tools and remote computers",
   "repository": {
@@ -90,56 +90,18 @@
     "README.md",
     "README.zh.md",
     "README.i18n.yaml",
-    "docs/WORKBENCH_USER_GUIDE.zh.md",
-    "docs/ROUTING_RESEARCH.zh.md",
-    "docs/ROUTING_DERIVATION_EXPERIMENTS.zh.md",
-    "docs/ROUTING_LIVEBENCH_VALIDATION.zh.md",
-    "docs/ROUTING_LIVEBENCH_DATA_SEARCH.zh.md",
-    "docs/ROUTING_SELFTEST_STEPS.zh.md",
-    "docs/ROUTING_ADAPTIVE_LEARNING.zh.md",
-    "docs/ROUTING_MATURITY.zh.md",
-    "docs/assets/workbench-task-preview.jpg",
-    "docs/assets/routing-workflow.svg",
-    "docs/assets/desktop-official-tools-0.9.0.png",
-    "docs/assets/workbench-usage.svg",
-    "docs/assets/candidate-pruning.svg",
-    "docs/INSTALLATION_GUIDE.zh.md",
-    "docs/archive/MIGRATION.md",
     "LICENSE",
-    "CHANGELOG.md",
-    "docs/assets/router-only-0.12.0.png",
-    "docs/releases/0.20.0-validation.md",
     ".dsh-plugin/shared/reasoning-execution.mjs",
     ".dsh-plugin/shared/routing-evidence.mjs",
     ".dsh-plugin/shared/quality-gates.mjs",
-    "docs/ROUTING_ALGORITHM_OPTIMIZATION.zh.md",
     ".dsh-plugin/shared/package-assignments.mjs",
     ".dsh-plugin/shared/manual-plan.mjs",
     ".dsh-plugin/shared/run-jobs.mjs",
-    "docs/MANUAL_TASK_ASSIGNMENT.zh.md",
-    "docs/releases/0.22.0-validation.md",
-    "docs/releases/0.23.0-validation.md",
-    "docs/assets/workbench-run-progress.png",
-    "docs/releases/0.23.1-validation.md",
-    "docs/assets/workbench-run-timeout.png",
     ".dsh-plugin/shared/budget-reservations.mjs",
     ".dsh-plugin/shared/execution-lifecycle.mjs",
-    "docs/releases/0.24.0-validation.md",
-    "docs/assets/workbench-budget-reservations.png",
     ".dsh-plugin/shared/execution-accounting.mjs",
     ".dsh-plugin/shared/subscription-usage.mjs",
-    "docs/releases/0.25.0-validation.md",
-    "docs/releases/0.25.1-validation.md",
-    "docs/releases/0.25.2-validation.md",
-    "docs/releases/0.25.3-validation.md",
-    "docs/assets/workbench-subscription-usage.png",
     ".dsh-plugin/shared/zcode-npm-shims.mjs",
-    "docs/releases/0.25.4-validation.md",
-    "docs/releases/0.25.5-validation.md",
-    "docs/releases/0.26.0-preview.0-validation.md",
-    "docs/releases/0.26.0-preview.1-validation.md",
-    "docs/releases/0.26.0-preview.1-f-difference.json",
-    "docs/releases/0.26.0-preview.1-f-difference.md",
     ".dsh-plugin/shared/legacy-policy.mjs",
     "modules/bot-runtime/index.mjs",
     "modules/bot-runtime/read-model.mjs",
@@ -367,61 +329,18 @@
     "remote-computer-agent/package-lock.json",
     "modules/bot-runtime/schedule-compat.mjs",
     "modules/bot-runtime/product-overlay/",
-    "docs/releases/0.63.0-validation.md",
     ".dsh-plugin/router-core.mjs",
     ".dsh-plugin/bot-product.mjs"
   ],
   "scripts": {
     "build:client": "node scripts/build-client.mjs",
+    "build:router-package": "node scripts/build-router-package.mjs",
     "check:client": "node scripts/build-client.mjs --check",
-    "preview:ui": "node scripts/workbench-preview.mjs",
-    "eval:routing": "node scripts/evaluate-routing.mjs",
-    "experiment:routing-search": "node scripts/routing-search-experiment.mjs",
-    "experiment:routing-regression": "node scripts/routing-regression-study.mjs",
-    "experiment:routing-summary": "node scripts/summarize-routing-search.mjs",
-    "experiment:routing-adaptive": "node scripts/adaptive-routing-study.mjs",
-    "audit:livebench": "node scripts/livebench-aggregate-audit.mjs",
+    "build:agent": "node remote-computer-agent/build.mjs",
+    "check:source": "node scripts/integration-product-source.mjs",
+    "pretest": "node scripts/prepare-product-tests.mjs",
     "test": "node scripts/run-tests.mjs",
-    "prepack": "node scripts/prepack.mjs",
-    "pack:local": "npm pack --pack-destination dist",
-    "test:routing-algorithm": "node --test tests/effort-execution.test.mjs tests/routing-evidence.test.mjs tests/routing-query-effort.test.mjs tests/routing-search-frontier.test.mjs tests/quality-gates.test.mjs tests/algorithm-host-integration.test.mjs tests/quality-attempt-ledger.test.mjs",
-    "build:routing-evidence": "node scripts/build-routing-evidence.mjs",
-    "test:manual-assignment": "node --test tests/manual-package-execution.test.mjs tests/manual-plan.test.mjs tests/manual-assignment-ui.test.mjs tests/manual-assignment-host.test.mjs",
-    "check:readme": "node scripts/check-readme.mjs",
-    "integration:status": "node scripts/integration-progress.mjs status",
-    "integration:check": "node scripts/integration-progress.mjs check",
-    "integration:report": "node scripts/integration-progress.mjs report",
-    "test:integration": "node --test tests/integration-progress.test.mjs tests/integration-host-probe.test.mjs tests/integration-inventory.test.mjs tests/integration-documents.test.mjs tests/integration-combined-host.test.mjs tests/capability-authority.test.mjs tests/capability-bridge.test.mjs tests/bot-policy.test.mjs tests/legacy-policy.test.mjs tests/ds-lifecycle.test.mjs tests/ds-workspace-privacy.test.mjs tests/deferred-router-state.test.mjs tests/task-contract.test.mjs tests/task-reconciliation.test.mjs",
-    "test:cli-native": "node --test tests/cli-runtime-native.test.mjs tests/cli-native-peer-job.native.mjs tests/cli-native-peer-probe.native.mjs",
-    "test:product-refresh": "node --test tests/product-refresh-order.test.mjs",
-    "integration:probe-cli-native": "node scripts/integration-cli-native.mjs",
-    "integration:probe-remote-agent": "node scripts/integration-remote-agent.mjs",
-    "integration:probe-remote-agent-browser": "node scripts/integration-remote-agent-browser.mjs",
-    "integration:probe-remote-agent-desktop": "node scripts/integration-remote-agent-desktop.mjs",
-    "integration:probe-product-source": "node scripts/integration-product-source.mjs",
-    "integration:probe-product-client": "node scripts/integration-product-client.mjs --check",
-    "integration:probe-product-upstream": "node scripts/integration-product-upstream-tests.mjs",
-    "integration:probe-product-host": "node scripts/integration-product-host.mjs",
-    "integration:probe-cli-runtime": "node scripts/integration-cli-runtime.mjs",
-    "integration:probe-host": "node scripts/integration-host-probe.mjs",
-    "integration:probe-sqlite": "node scripts/integration-sqlite-probe.mjs",
-    "integration:inventory": "node scripts/integration-inventory.mjs",
-    "integration:upstream-proposal": "node scripts/integration-upstream-proposal.mjs",
-    "integration:upstream-include": "node scripts/integration-upstream-include.mjs",
-    "integration:probe-combined": "node scripts/integration-combined-host.mjs",
-    "integration:probe-linux-isolation": "node scripts/integration-linux-isolation.mjs",
-    "integration:probe-finance": "node scripts/integration-finance-probe.mjs",
-    "integration:probe-tasks": "node scripts/integration-task-probe.mjs",
-    "integration:probe-codex-profile": "node scripts/integration-codex-profile.mjs",
-    "integration:probe-product-default": "node scripts/integration-product-default.mjs",
-    "integration:probe-remote-machines": "node scripts/integration-remote-machines.mjs",
-    "integration:probe-cli-execution": "node scripts/integration-cli-execution.mjs",
-    "integration:probe-web-search-config": "node scripts/integration-web-search-config.mjs",
-    "integration:migrate-profile": "node scripts/integration-migrate-profile.mjs",
-    "integration:probe-migration-audit": "node scripts/integration-migration-audit.mjs",
-    "integration:probe-remote-container": "node scripts/integration-remote-container.mjs",
-    "integration:probe-cli-installed": "node scripts/integration-cli-installed.mjs",
-    "build:router-package": "node scripts/build-router-package.mjs"
+    "prepack": "node remote-computer-agent/build.mjs && node scripts/prepack.mjs"
   },
   "license": "MIT",
   "engines": {

package/packages/model-router-plugin/README.md

@@ -1,34 +1,58 @@
 # DSH Model Router
 
-[中文](README.zh.md) | English
+English · [简体中文](README.zh.md)
 
 [![npm version](https://flat.badgen.net/npm/v/@ljwei-stak/dsh-model-router)](https://www.npmjs.com/package/@ljwei-stak/dsh-model-router)
 
-The model-routing workbench for DeepSeek Harness. This package keeps the standard Harness interface and adds a **Model Router / 模型路由** panel. It does not install DS Bot, Bot chat, the Bot library, routines or remote computers.
+**Task-oriented model routing inside the standard DeepSeek Harness interface.**
 
-For the complete Bot workspace with routing, install **`@ljwei-stak/dsh-model-route-bot`** instead. Choose one edition in a profile; both use the same router configuration ID.
+Describe the result you want, choose suitable configured models or native CLI tools, review the plan, then follow execution and accounting from one workbench. This edition adds a **Model Router** sidebar entry and keeps the existing Harness workspace.
+
+**Stable version: 0.65.0.** For Bot conversations, multi-Bot delegation, remote computers, private libraries, and routines, use the [full Bot edition](https://github.com/Alice-Marx/dsh-model-router/blob/main/README.md): **`@ljwei-stak/dsh-model-route-bot`**. Select one edition per profile.
 
 ## Install
 
-In Harness **Plugins → Add plugin**, enter `@ljwei-stak/dsh-model-router@0.64.0`. Open **模型路由** from the sidebar. Configure provider credentials and models in the standard Harness **Models** settings.
+1. In Harness **Plugins → Add plugin**, enter `@ljwei-stak/dsh-model-router@0.65.0`.
+2. Enable it, quit Harness including its tray process, and restart.
+3. Configure provider credentials/models in Harness **Models**, then open **Model Router** from the sidebar.
+
+```powershell
+dsh plugin --profile desktop add @ljwei-stak/dsh-model-router@0.65.0
+```
+
+## Run your first task
+
+1. In **Model configuration**, refresh exact routes and enter known prices/capabilities. Unknown information can remain blank.
+2. In **Task & execution**, start with **Project check**, **Organize documentation**, or **Compare approaches**, then edit the task and acceptance criteria. **Undo template** restores the previous text.
+3. Choose **Next: preview execution → Preview execution plan**. Inspect models/tools, workspace, permissions, and API cost or subscription usage estimates.
+4. Confirm the required items to start execution. Review output, receipts, cancellation, and supported retries in **Execution history**.
+
+The current application uses Chinese interface labels; these English descriptions explain the corresponding controls.
+
+![Actual workbench component with offline demonstration data](https://raw.githubusercontent.com/Alice-Marx/dsh-model-router/main/.github/assets/workbench-task.png)
+
+*Models, prices, usage, and paths in the screenshot are examples; it does not show a live model run.*
 
-## Use
+## Workbench features
 
-1. Describe the goal and expected result. Single-task mode selects one route; team mode plans dependent work packages; direct mode uses the exact model you select.
-2. Optionally compare local route suggestions or adjust package assignments. Estimates need prices for the exact configured models.
-3. Preview execution. Check the model/tool, workspace, permissions, estimated API charges and subscription usage before confirming. Previewing does not call a model.
-4. Confirm execution to start the selected model or supported official tool. Use execution records to inspect results, costs, cancellations and supported retries.
+| Page | What it provides |
+| --- | --- |
+| Task & execution / 任务与执行 | Single-route, dependency-based team, and exact-model planning; optional route comparison and manual package assignment; preview and confirmed execution. |
+| Model configuration / 模型配置 | Exact route profiles, prices, quality evidence, billing preferences, and CLI model mappings. |
+| Native tools / 官方工具 | Detection, supported install methods, login/readiness inspection, and interactive CLI terminals. |
+| Budget & safety / 预算与安全 | Per-task estimates, API daily/monthly limits and reservations, separate subscription calls/tokens, review policy, and explicit feedback. |
+| Execution history / 执行记录 | Results, receipts, attempt status, cancellation, supported retries, and reconciliation of interrupted/unknown effects. |
 
-**Models** manages route profiles and pricing. **Official tools** detects, installs and opens supported vendor CLIs; each tool uses its own login. **Budget and safety** contains API limits and separate subscription accounting. Installed or logged-in tools still need to pass the selected execution mode's readiness checks.
+Route comparison and execution preview run locally without model calls. Confirmation starts the selected provider or supported tool. **Model routing is read-only**; editing requires **Team → Native-tool collaboration → Edit files**. Tool installation/login and readiness for a specific managed execution mode are separate checks. Vendor-native processes run as the current system user; a worktree organizes changes rather than restricting system access.
 
-Model-route execution is read-only. To edit files, select team mode, official-tool collaboration and the explicit file-edit permission, then review the resulting preview. CLI-native execution uses the current user's permissions; an isolated worktree collects changes and does not restrict access outside it.
+Draft task, mode, exact model, and explicit estimate survive page remounts in the **current window's memory**. Closing the app or reloading the client clears the draft. Close **Needs your attention** with **×** and restore it from the header; the device remembers this visibility preference. Failed-run reminders open the relevant record.
 
-Close **需要你处理** with its × button; use **显示待处理提醒** in the header to restore it. The current device remembers this preference.
+API money and reservations are separate from subscription calls/reported tokens. Missing usage remains unknown; provider bills remain authoritative. Switching a subscription attempt to API requires fresh admission and the relevant confirmation. Review remote effects before retrying an interrupted task.
 
 ## Switch editions
 
-To use the complete Bot workspace, remove this package entry in Plugin Manager and add **`@ljwei-stak/dsh-model-route-bot`** in the same Harness profile. Keep the existing data directories and reuse your configured Bot directory. The internal router configuration ID is retained; enable one edition at a time.
+Remove the current package entry in plugin management, then add the full Bot package in the same Harness profile. Retain your data directories and configured Bot home. Both editions share the routing configuration; enable one at a time.
 
-## License and reference
+## License and support
 
-[MIT](LICENSE). Current source and the full-edition guide: [GitHub](https://github.com/Alice-Marx/dsh-model-router). [Technical documents and release history](https://gitlab.com/Alice_marx/dsh-model-router).
+[MIT license](https://github.com/Alice-Marx/dsh-model-router/blob/main/LICENSE) · [Full guide](https://github.com/Alice-Marx/dsh-model-router/blob/main/README.md) · [Issues](https://github.com/Alice-Marx/dsh-model-router/issues) · [Installation files](https://github.com/Alice-Marx/dsh-model-router/releases/latest)

package/packages/model-router-plugin/README.zh.md

@@ -1,34 +1,58 @@
 # DSH 模型路由
 
-中文 | [English](README.md)
+[English](README.md) · 简体中文
 
 [![npm 版本](https://flat.badgen.net/npm/v/@ljwei-stak/dsh-model-router)](https://www.npmjs.com/package/@ljwei-stak/dsh-model-router)
 
-DeepSeek Harness 的模型路由工作台。安装后保留 Harness 原有界面，在侧栏增加 **模型路由** 入口。此包不安装 DS Bot、Bot 对话、Bot 资料库、例行任务和远程电脑。
+**在 DeepSeek Harness 原有界面中，按任务选择模型并组织执行。**
 
-需要包含模型路由的完整 Bot 工作区，请安装 **`@ljwei-stak/dsh-model-route-bot`**。同一个 profile 选择一种安装形态；两者沿用同一个路由配置标识。
+写清期望结果，选择合适的已配置模型或原生 CLI 工具，审查计划后启动，并在同一工作台跟踪执行和费用。此版本保留现有 Harness 工作区，在侧栏增加 **模型路由** 入口。
+
+**当前正式版：0.65.0。** 如需 Bot 对话、多 Bot 分工、远程电脑、私有资料库和例行任务，请使用 [完整 Bot 版本](https://github.com/Alice-Marx/dsh-model-router/blob/main/README.zh.md)：**`@ljwei-stak/dsh-model-route-bot`**。同一 profile 选择一种版本。
 
 ## 安装
 
-在 Harness 的 **插件 → 添加插件** 输入 `@ljwei-stak/dsh-model-router@0.64.0`，从侧栏打开 **模型路由**。Provider 凭据和模型仍在 Harness 官方 **模型** 设置中配置。
+1. 在 Harness **插件 → 添加插件** 输入 `@ljwei-stak/dsh-model-router@0.65.0`。
+2. 启用后，连同托盘进程完全退出 Harness，再重新启动。
+3. 在 Harness **模型** 中配置 Provider 凭据和模型，从侧栏打开 **模型路由**。
+
+```powershell
+dsh plugin --profile desktop add @ljwei-stak/dsh-model-router@0.65.0
+```
+
+## 完成第一个任务
+
+1. 在 **模型配置** 刷新准确路线，填写已知价格和能力，未知信息留空。
+2. 在 **任务与执行** 选择 **项目检查**、**整理说明** 或 **方案比较** 模板，修改任务与验收标准。**撤销模板** 可恢复原文。
+3. 点击 **下一步：预览执行 → 预览执行计划**，检查模型/工具、工作区、权限和 API 费用或订阅用量估算。
+4. 确认所需项目后启动执行，在 **执行记录** 检查结果、收据、取消状态及受支持的重试。
+
+当前应用界面使用中文，英文文档提供对应操作解释。
+
+![真实工作台组件，使用离线演示数据](https://raw.githubusercontent.com/Alice-Marx/dsh-model-router/main/.github/assets/workbench-task.png)
+
+*截图中的模型、价格、用量和路径均为示例，不是实时模型执行结果。*
 
-## 使用
+## 工作台功能
 
-1. 填写目标与预期结果。单任务选择一条路线，团队分工生成有依赖的工作包，指定模型使用你选择的准确模型。
-2. 按需比较本地路线建议或手动调整工作包。费用估算需要为准确模型配置价格。
-3. 预览执行，核对模型/工具、工作区、权限、API 预估费用与订阅用量。预览不会调用模型。
-4. 确认后启动选中的模型或受支持的官方工具。在执行记录中查看结果、费用、取消状态及受支持的重试。
+| 页面 | 可用能力 |
+| --- | --- |
+| 任务与执行 | 单路线、带依赖团队、指定模型；可选路线比较、工作包手动分配、预览与确认执行。 |
+| 模型配置 | 准确路线档案、价格、质量证据、计费偏好与 CLI 模型映射。 |
+| 官方工具 | 工具检测、受支持的安装方式、登录/就绪检查与 CLI 交互终端。 |
+| 预算与安全 | 单次估算、API 日/月限额及预占、独立订阅调用/token、复核策略和显式反馈。 |
+| 执行记录 | 结果、收据、执行尝试、取消、受支持的重试及中断/未知影响核对。 |
 
-**模型配置** 管理路线档案与价格；**官方工具** 检测、安装及打开厂商 CLI，各工具使用自己的登录；**预算与安全** 设置 API 限额，并单独核对订阅用量。已安装、已登录仍需通过所选执行模式的就绪检查。
+路线比较和执行预览在本地进行，不调用模型；确认才会启动所选供应商或受支持的工具。**模型路由为只读执行**；修改文件需选择 **团队分工 → 官方工具协作 → 编辑文件**。工具安装/登录与具体托管执行模式就绪分别检查。厂商原生进程使用当前系统用户权限；工作树用于整理改动，不限制系统访问。
 
-模型路由按只读方式执行。需要修改文件时，选择团队分工、官方工具协作和明确的“编辑文件”权限，核对预览后执行。厂商 CLI 正常环境使用当前用户权限；独立工作树归集修改，不限制工作树外访问。
+页面重新挂载时，任务、模式、准确模型及显式估算保留在**当前窗口内存**，关闭应用或重载客户端后清除。**需要你处理** 面板可用 **×** 关闭，由顶部入口恢复，当前设备会记住显示偏好；失败提醒会打开对应记录。
 
-“需要你处理”面板可用右上角 × 关闭，顶部 **显示待处理提醒** 可恢复；当前设备会记住选择。
+API 金额/预占与订阅调用/已报告 token 分别核算；缺失用量保持未知，账单以供应商为准。订阅转 API 需要重新准入及相应确认；中断后先核对远程实际影响，再决定重试。
 
-## 切换安装形态
+## 切换版本
 
-需要完整 Bot 工作区时，在插件管理中移除此安装入口，再在同一个 Harness profile 添加 **`@ljwei-stak/dsh-model-route-bot`**。保留现有数据目录并沿用已配置的 Bot 目录。内部路由配置标识沿用原值；同一时间启用一种安装形态。
+在插件管理中移除当前包入口，再在同一 Harness profile 添加完整 Bot 包，保留数据目录并沿用已配置的 Bot home。两种版本共用路由配置，同一时间启用一种。
 
-## 许可与参考
+## 许可与支持
 
-[MIT](LICENSE)。当前源码与完整版本说明：[GitHub](https://github.com/Alice-Marx/dsh-model-router)。[技术文档及版本记录](https://gitlab.com/Alice_marx/dsh-model-router)。
+[MIT 许可证](https://github.com/Alice-Marx/dsh-model-router/blob/main/LICENSE) · [完整指南](https://github.com/Alice-Marx/dsh-model-router/blob/main/README.zh.md) · [问题反馈](https://github.com/Alice-Marx/dsh-model-router/issues) · [安装文件](https://github.com/Alice-Marx/dsh-model-router/releases/latest)

package/packages/model-router-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ljwei-stak/dsh-model-router",
-  "version": "0.64.0",
+  "version": "0.65.0",
   "type": "module",
   "license": "MIT",
   "repository": {