dsh-dispatch-board 0.2.1 → 0.2.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/lib/index.js CHANGED
@@ -6,7 +6,7 @@
6
6
  * ({type:'client-request', rpcId, method, payload} → {type:'server-response', rpcId, result})
7
7
  * 给浏览器端提供 snapshot / add-task / update-task / delete-task / dispatch-now /
8
8
  * set-config / archive-done / install-preset / bind-main-session / clear-main-session /
9
- * ensure-workspace-lead / upload-attachment / attachment 等端点;
9
+ * set-workspace-filter / set-workspace-draft / ensure-workspace-lead / upload-attachment / attachment 等端点;
10
10
  * 2. 持久化任务看板到 $DSH_HOME/storages/dsh-taskboard/board.json(原子写);
11
11
  * 3. 轮询「待开始」列(v0.2.0 默认 workspace-lead 模式):按任务工作区复用/懒创建常驻工作区组长
12
12
  * (taskboard-dispatch 预设),用 agent.followup() 推一条【任务看板 · 待开始】消息;
@@ -59,10 +59,24 @@ const DEFAULT_POLL_INTERVAL_MS = 15000
59
59
  const DEFAULT_MAX_NOTIFICATIONS = 5
60
60
  const MAX_NOTE_CHARS = 4000
61
61
  const MAX_TITLE_CHARS = 200
62
+
63
+ /**
64
+ * v0.2.2「待你处理」(needsUser,§1.9)的字段上限:
65
+ * - question ≤500;questionOptions ≤4 个、每个 ≤80;用户回答 ≤1000。
66
+ */
67
+ export const MAX_QUESTION_CHARS = 500
68
+ export const MAX_ANSWER_CHARS = 1000
69
+ export const MAX_QUESTION_OPTIONS = 4
70
+ export const MAX_OPTION_CHARS = 80
62
71
  /** 会话标题(主会话 / 工作区组长)最长字符数。 */
63
72
  const SESSION_TITLE_MAX = 200
64
73
  /** config.workspaceLeads 最多保存多少条工作区 → 组长映射(§2)。 */
65
74
  const MAX_WORKSPACE_LEADS = 32
75
+ /**
76
+ * 看板「工作区」过滤选择的持久化上限(config.workspaceFilter,§2 / §5.1.1)。
77
+ * 合法值是工作区路径(Windows 下 260 左右,留足余量到 1024)或空串(全部工作区)。
78
+ */
79
+ export const MAX_WORKSPACE_FILTER_CHARS = 1024
66
80
  /** 完成回执每批最多合并多少条任务(§1.6)。 */
67
81
  const MAX_RECEIPT_BATCH = 10
68
82
  /** 完成回执里每条任务结论压成单行后的最大字符数(§1.6)。 */
@@ -241,6 +255,11 @@ export function createEmptyBoard() {
241
255
  mainSessionId: null,
242
256
  mainSessionTitle: '',
243
257
  workspaceLeads: {},
258
+ // v0.2.3:看板「工作区」过滤选择('' = 全部工作区,默认)。
259
+ workspaceFilter: '',
260
+ // v0.2.3:平台看板新建行「任务所属工作区」选择('' = 未选择,提交禁用)。
261
+ // 与 workspaceFilter 各自独立记忆、互不串值。
262
+ workspaceDraft: '',
244
263
  },
245
264
  tasks: [],
246
265
  }
@@ -304,6 +323,20 @@ export function putWorkspaceLead(leads, key, entry) {
304
323
  return next
305
324
  }
306
325
 
326
+ /**
327
+ * 规范化看板「工作区」过滤选择(config.workspaceFilter,§2 / §5.1.1):
328
+ * - 合法值 = 非空工作区路径字符串(≤ MAX_WORKSPACE_FILTER_CHARS)或 `''`(全部工作区);
329
+ * - 非字符串 / 全空白 / 超长一律归一化为 `''`(默认「全部工作区」),不抛错——
330
+ * 这是 UI 偏好,坏值只该回退默认,不该让宿主 / 看板白屏(§3.3 无错误分支)。
331
+ * 是否仍指向现存工作区由 Client 拿 snapshot.workspaces 判定(`resolveWorkspaceSelection`)。
332
+ */
333
+ export function normalizeWorkspaceSelection(raw) {
334
+ if (typeof raw !== 'string') return ''
335
+ const text = raw.trim()
336
+ if (text === '' || text.length > MAX_WORKSPACE_FILTER_CHARS) return ''
337
+ return text
338
+ }
339
+
307
340
  export function normalizeConfig(raw) {
308
341
  const config = isPlainObject(raw) ? raw : {}
309
342
  const interval = Number(config.pollIntervalMs)
@@ -326,15 +359,40 @@ export function normalizeConfig(raw) {
326
359
  })(),
327
360
  mainSessionTitle: trimmed(config.mainSessionTitle, SESSION_TITLE_MAX),
328
361
  workspaceLeads: normalizeWorkspaceLeads(config.workspaceLeads),
362
+ // v0.2.3:看板「工作区」过滤选择(UI 偏好,'' = 全部工作区;坏值回退默认)。
363
+ workspaceFilter: normalizeWorkspaceSelection(config.workspaceFilter),
364
+ // v0.2.3:新建行「任务所属工作区」选择(UI 偏好,'' = 未选择;坏值回退默认)。
365
+ workspaceDraft: normalizeWorkspaceSelection(config.workspaceDraft),
329
366
  }
330
367
  }
331
368
 
369
+ /**
370
+ * 规范化 `questionOptions`(§1.9):只保留非空字符串,逐个 trim 截 80 字符,去重,最多 4 个。
371
+ * 非法项(非字符串 / 空串 / 重复)静默过滤——组长的选项是提示,不值得为一项写错整条任务。
372
+ */
373
+ export function normalizeQuestionOptions(raw) {
374
+ if (!Array.isArray(raw)) return []
375
+ const options = []
376
+ for (const item of raw) {
377
+ if (typeof item !== 'string') continue
378
+ const text = trimmed(item, MAX_OPTION_CHARS)
379
+ if (text === '' || options.includes(text)) continue
380
+ options.push(text)
381
+ if (options.length >= MAX_QUESTION_OPTIONS) break
382
+ }
383
+ return options
384
+ }
385
+
332
386
  function normalizeTask(raw, index) {
333
387
  if (!isPlainObject(raw)) return null
334
388
  const status = STATUSES.includes(raw.status) ? raw.status : 'todo'
335
389
  const title = trimmed(raw.title, MAX_TITLE_CHARS)
336
390
  if (title === '') return null
337
391
  const id = trimmed(raw.id, 40) || 't-' + String(index + 1)
392
+ // §1.9:flagged 但问题为空(坏数据 / 老版本写坏)→ 保守降级为未 flag,不丢整条任务。
393
+ // archived 是终态:旧 board.json 里归档后仍带标记的,读盘时也按未 flag 处理(§1.9 第 5 条)。
394
+ const question = trimmed(raw.question, MAX_QUESTION_CHARS)
395
+ const needsUser = raw.needsUser === true && question !== '' && status !== 'archived'
338
396
  return {
339
397
  id,
340
398
  title,
@@ -349,6 +407,14 @@ function normalizeTask(raw, index) {
349
407
  reportedAt: asString(raw.reportedAt) || null,
350
408
  // v0.2.0 自动建任务标记(§1.8):只有 'lead-dispatch' 合法,其它一律 null(= 普通任务)。
351
409
  autoDispatch: raw.autoDispatch === LEAD_AUTO_MARK ? LEAD_AUTO_MARK : null,
410
+ // v0.2.2「待你处理」(§1.9):不新增 status,只在任务上打标记 + 问题 / 选项 / 提问者。
411
+ needsUser,
412
+ question: needsUser ? question : '',
413
+ questionOptions: needsUser ? normalizeQuestionOptions(raw.questionOptions) : [],
414
+ askedAt: needsUser ? asString(raw.askedAt) || null : null,
415
+ askedBy: needsUser ? asString(raw.askedBy) || null : null,
416
+ lastAnswer: trimmed(raw.lastAnswer, MAX_ANSWER_CHARS),
417
+ answeredAt: asString(raw.answeredAt) || null,
352
418
  cwd: typeof raw.cwd === 'string' && raw.cwd !== '' ? raw.cwd : null,
353
419
  assignee: trimmed(raw.assignee, 200),
354
420
  result: truncateNote(raw.result, MAX_NOTE_CHARS),
@@ -743,6 +809,12 @@ export function addTask(state, input, now = Date.now()) {
743
809
  if (!isPlainObject(input)) throw new BoardError('bad-request', '参数必须是对象')
744
810
  const title = trimmed(input.title, MAX_TITLE_CHARS)
745
811
  if (title === '') throw new BoardError('bad-request', '标题不能为空')
812
+ // §1.9:建任务时也可以直接带问题(宿主 / 测试用;UI 的新建行不传这些字段)。
813
+ const needsUser = input.needsUser === true
814
+ const question = trimmed(input.question, MAX_QUESTION_CHARS)
815
+ if (needsUser && question === '') {
816
+ throw new BoardError('bad-request', 'needsUser=true 时必须提供非空的 question')
817
+ }
746
818
  const stamp = iso(now)
747
819
  const task = {
748
820
  id: nextTaskId(state),
@@ -756,6 +828,13 @@ export function addTask(state, input, now = Date.now()) {
756
828
  dispatchedSessionTitle: '',
757
829
  reportedAt: null,
758
830
  autoDispatch: null,
831
+ needsUser,
832
+ question: needsUser ? question : '',
833
+ questionOptions: needsUser ? normalizeQuestionOptions(input.questionOptions) : [],
834
+ askedAt: needsUser ? stamp : null,
835
+ askedBy: needsUser && typeof input.askedBy === 'string' && input.askedBy !== '' ? input.askedBy : null,
836
+ lastAnswer: '',
837
+ answeredAt: null,
759
838
  cwd: typeof input.cwd === 'string' && input.cwd !== '' ? input.cwd : null,
760
839
  assignee: '',
761
840
  result: '',
@@ -777,9 +856,19 @@ export function canTransition(from, to) {
777
856
  return Array.isArray(allowed) && allowed.includes(to)
778
857
  }
779
858
 
859
+ /** 清空「待你处理」的问题五字段(保留 `lastAnswer` / `answeredAt` 留档)。 */
860
+ function clearNeedsUserFields(task) {
861
+ task.needsUser = false
862
+ task.question = ''
863
+ task.questionOptions = []
864
+ task.askedAt = null
865
+ task.askedBy = null
866
+ }
867
+
780
868
  export function applyTaskUpdate(state, id, patch, now = Date.now()) {
781
869
  const task = findTask(state, id)
782
870
  if (!isPlainObject(patch)) throw new BoardError('bad-request', 'patch 必须是对象')
871
+ // ---- 先完成全部可能抛错的校验:本函数抛错前不改任何任务字段(调用方也不会 commit)。----
783
872
  if (patch.status !== undefined) {
784
873
  if (!STATUSES.includes(patch.status)) {
785
874
  throw new BoardError('bad-request', '非法状态:' + String(patch.status), { allowed: STATUSES })
@@ -792,8 +881,74 @@ export function applyTaskUpdate(state, id, patch, now = Date.now()) {
792
881
  })
793
882
  }
794
883
  }
884
+ let nextTitle = null
885
+ if (patch.title !== undefined) {
886
+ nextTitle = trimmed(patch.title, MAX_TITLE_CHARS)
887
+ if (nextTitle === '') throw new BoardError('bad-request', '标题不能为空')
888
+ }
889
+ // v0.2.3(§1.9):归档是终态,看板「待你处理」派生明确排除 archived(lib/client.js),
890
+ // 在归档任务上提问只会静默石沉大海。这里直接拒绝:本次 patch 没有同时改 status(重开 / 再次归档)
891
+ // 却试图设置提问(needsUser:true 或带 question)→ conflict;先于任何字段写入,失败不留部分修改。
892
+ // needsUser:false(取消提问)仍幂等成功;`{status:'archived', …}` 走下面的归档优先分支。
893
+ if (
894
+ task.status === 'archived' &&
895
+ patch.status === undefined &&
896
+ (patch.needsUser === true || patch.question !== undefined)
897
+ ) {
898
+ throw new BoardError('conflict', '任务已归档,不能在归档任务上提问;请新建一条任务或先重开该任务')
899
+ }
900
+ // v0.2.2「待你处理」(§1.9):
901
+ // - 给 question(或显式 needsUser:true)即进入 flagged 状态;needsUser:false 清问题四字段、保留回答留档;
902
+ // - flagged 但 question 为空 → bad-request;
903
+ // - 只给 questionOptions、既不 flag 也不带 question → bad-request(不静默丢选项);
904
+ // - 重设 question 但没带 questionOptions → 清空旧选项(旧按钮与新闻题无关,别让用户点错);
905
+ // - askedAt / askedBy 由宿主 / 工具设置:首次 flag 补 askedAt(重复更新保留最早时间,用于「最旧优先」排序)。
906
+ // - 归档优先:patch.status === 'archived' 时跳过上面全部 needsUser 校验,直接清问题标记——
907
+ // 模型漏传 question 的 `{status:'archived', needsUser:true}` 不该被 bad-request 拦住归档。
908
+ // 校验全部在写字段之前完成,needsUser 变更先算成 `preparedNeeds`,最后统一应用。
795
909
  const stamp = iso(now)
796
910
  const previousStatus = task.status
911
+ const wasFlagged = task.needsUser === true
912
+ const needsTouched =
913
+ patch.needsUser !== undefined || patch.question !== undefined || patch.questionOptions !== undefined
914
+ let preparedNeeds = null
915
+ if (patch.status === 'archived') {
916
+ // 归档是终态,清掉问题标记 / 四字段,保留 lastAnswer / answeredAt 留档。
917
+ preparedNeeds = { needsUser: false, question: '', questionOptions: [], askedAt: null, askedBy: null }
918
+ } else if (needsTouched) {
919
+ const nextFlag = patch.needsUser !== undefined ? patch.needsUser === true : wasFlagged || patch.question !== undefined
920
+ if (!nextFlag) {
921
+ if (patch.questionOptions !== undefined) {
922
+ throw new BoardError('bad-request', 'questionOptions 需要同时提供 question 或 needsUser:true')
923
+ }
924
+ preparedNeeds = { needsUser: false, question: '', questionOptions: [], askedAt: null, askedBy: null }
925
+ } else {
926
+ const question = patch.question !== undefined ? trimmed(patch.question, MAX_QUESTION_CHARS) : task.question || ''
927
+ if (question === '') throw new BoardError('bad-request', 'needsUser=true 时必须提供非空的 question')
928
+ preparedNeeds = {
929
+ needsUser: true,
930
+ question,
931
+ questionOptions:
932
+ patch.questionOptions !== undefined
933
+ ? normalizeQuestionOptions(patch.questionOptions)
934
+ : patch.question !== undefined
935
+ ? []
936
+ : Array.isArray(task.questionOptions)
937
+ ? task.questionOptions
938
+ : [],
939
+ askedAt: wasFlagged && typeof task.askedAt === 'string' && task.askedAt !== '' ? task.askedAt : stamp,
940
+ askedBy:
941
+ patch.askedBy !== undefined
942
+ ? typeof patch.askedBy === 'string' && patch.askedBy !== ''
943
+ ? patch.askedBy
944
+ : null
945
+ : wasFlagged
946
+ ? task.askedBy
947
+ : null,
948
+ }
949
+ }
950
+ }
951
+ // ---- 以下才开始写任务字段(校验已完成,不再抛错)----
797
952
  if (patch.status !== undefined && patch.status !== previousStatus) {
798
953
  task.status = patch.status
799
954
  // 状态变了,上一轮「派发跳过」的原因就过期了,别让它挂在卡片上误导人。
@@ -824,16 +979,23 @@ export function applyTaskUpdate(state, id, patch, now = Date.now()) {
824
979
  task.autoDispatch = null
825
980
  }
826
981
  }
827
- if (patch.title !== undefined) {
828
- const title = trimmed(patch.title, MAX_TITLE_CHARS)
829
- if (title === '') throw new BoardError('bad-request', '标题不能为空')
830
- task.title = title
831
- }
982
+ if (nextTitle !== null) task.title = nextTitle
832
983
  if (patch.note !== undefined) task.note = truncateNote(patch.note, MAX_NOTE_CHARS)
833
984
  if (patch.result !== undefined) task.result = truncateNote(patch.result, MAX_NOTE_CHARS)
834
985
  if (patch.assignee !== undefined) task.assignee = trimmed(patch.assignee, 200)
835
986
  if (patch.lastError !== undefined) task.lastError = trimmed(patch.lastError, 500)
836
987
  if (patch.clearError === true) task.lastError = ''
988
+ if (preparedNeeds !== null) {
989
+ task.needsUser = preparedNeeds.needsUser
990
+ task.question = preparedNeeds.question
991
+ task.questionOptions = preparedNeeds.questionOptions
992
+ task.askedAt = preparedNeeds.askedAt
993
+ task.askedBy = preparedNeeds.askedBy
994
+ }
995
+ // v0.2.3(§1.9):归档是终态——落字段后再兜底清一次问题标记与四个问题字段,
996
+ // 防历史脏数据 / 其它路径在归档任务上留下「等待用户回答」的 flag(看板「待你处理」不显示
997
+ // 归档任务,留着只会误导人)。
998
+ if (task.status === 'archived') clearNeedsUserFields(task)
837
999
  if (patch.sessionId !== undefined) {
838
1000
  task.sessionId = typeof patch.sessionId === 'string' && patch.sessionId !== '' ? patch.sessionId : null
839
1001
  }
@@ -847,6 +1009,8 @@ export function archiveDoneTasks(state, now = Date.now()) {
847
1009
  if (task.status !== 'done') continue
848
1010
  task.status = 'archived'
849
1011
  task.archivedAt = iso(now)
1012
+ // §1.9:归档是终态——flagged 任务归档后不再等用户回答,清问题四字段(回答留档保留)。
1013
+ clearNeedsUserFields(task)
850
1014
  task.updatedAt = iso(now)
851
1015
  archived += 1
852
1016
  }
@@ -950,6 +1114,8 @@ export function selectDispatchCandidates(state, now = Date.now()) {
950
1114
  const cooldown = notifyCooldownMs(config)
951
1115
  return state.tasks
952
1116
  .filter((task) => task.status === 'todo')
1117
+ // §1.9:等待用户回答的任务不投递(问题没回答前重复派发只会让组长重复提问)。
1118
+ .filter((task) => task.needsUser !== true)
953
1119
  .filter((task) => task.notificationCount < config.maxNotifications)
954
1120
  .filter((task) => {
955
1121
  if (!task.notifiedAt) return true
@@ -1068,6 +1234,9 @@ export function requeueTasksOfLead(state, sessionId, now = Date.now()) {
1068
1234
  task.assignee = ''
1069
1235
  task.dispatchedSessionId = null
1070
1236
  task.dispatchedSessionTitle = ''
1237
+ // §1.9:重排后这条任务不再由旧组长/旧提问者跟进,清掉问题标记——
1238
+ // 否则回答会落到创建会话而不是新组长,tick 又会因 flagged 跳过它,任务卡住。
1239
+ clearNeedsUserFields(task)
1071
1240
  // 重排回 todo = 回到轮询队列、归新组长审核:清掉自动任务标记(§1.8),不再被宿主自动 done。
1072
1241
  task.autoDispatch = null
1073
1242
  task.lastError = '工作区组长会话已归档,任务已重新排队,将投给新的组长'
@@ -1189,6 +1358,11 @@ export function buildDispatchText(task, now = Date.now()) {
1189
1358
  const lines = ['【任务看板 · 待开始】' + task.id + ' ' + task.title]
1190
1359
  if (task.note) lines.push('备注:' + task.note)
1191
1360
  if (task.cwd) lines.push('工作目录:' + task.cwd)
1361
+ // §1.9:todo 任务提问 → 用户回答 → 清标记后再派发时,组长可能在别的会话里,
1362
+ // 回答必须随派发文本带过去,不然「用户已经拍板」这件事会丢。
1363
+ if (typeof task.lastAnswer === 'string' && task.lastAnswer.trim() !== '') {
1364
+ lines.push('用户最近回答:' + task.lastAnswer)
1365
+ }
1192
1366
  lines.push('')
1193
1367
  lines.push(
1194
1368
  '请按派单规则处理这条看板任务:先用 taskboard_update 把它置为 doing,' +
@@ -1752,6 +1926,10 @@ async function dispatchRpc(rt, method, payload) {
1752
1926
  const result = await tick(rt, { taskId: payload.id, force: true })
1753
1927
  return result
1754
1928
  }
1929
+ case 'answer-task': {
1930
+ // v0.2.2:回答「待你处理」的问题,followup 给组长并清标记(§1.9)。
1931
+ return answerTask(rt, payload.id, payload.answer)
1932
+ }
1755
1933
  case 'set-config': {
1756
1934
  const next = normalizeConfig({ ...normalizeConfig(rt.state.config), ...payload })
1757
1935
  const intervalChanged = next.pollIntervalMs !== normalizeConfig(rt.state.config).pollIntervalMs
@@ -1773,6 +1951,15 @@ async function dispatchRpc(rt, method, payload) {
1773
1951
  // v0.2.0:解除绑定(幂等)。
1774
1952
  return clearMainSession(rt)
1775
1953
  }
1954
+ case 'set-workspace-filter': {
1955
+ // v0.2.3:记住看板「工作区」过滤选择('' = 全部工作区);写失败只记日志,不影响 UI。
1956
+ return setWorkspaceFilter(rt, payload && payload.path)
1957
+ }
1958
+ case 'set-workspace-draft': {
1959
+ // v0.2.3:记住平台看板新建行「任务所属工作区」选择('' = 未选择);
1960
+ // 与 set-workspace-filter 写不同字段,两个下拉互不串值。
1961
+ return setWorkspaceDraft(rt, payload && payload.path)
1962
+ }
1776
1963
  case 'ensure-workspace-lead': {
1777
1964
  // v0.2.0:确保 cwd 所属工作区有可用常驻组长(复用 → 唤醒 → 必要时创建并修复映射)。
1778
1965
  return ensureWorkspaceLead(rt, payload.cwd)
@@ -2048,6 +2235,10 @@ async function runTick(rt, options = {}) {
2048
2235
  if (options.taskId) {
2049
2236
  const single = findTask(rt.state, options.taskId)
2050
2237
  if (single.status !== 'todo') throw new BoardError('conflict', '只有待开始的任务可以立即派发(当前状态:' + single.status + ')')
2238
+ // §1.9:flagged 任务不派发(等用户回答);显式「立即派发」也不越过这条规则。
2239
+ if (single.needsUser === true) {
2240
+ throw new BoardError('conflict', '任务正在等待用户回复(needsUser),回答后才能继续派发')
2241
+ }
2051
2242
  candidates = [single]
2052
2243
  } else {
2053
2244
  candidates = selectDispatchCandidates(rt.state, now)
@@ -2165,6 +2356,98 @@ async function deliverBoardTask(rt, task, agent, now) {
2165
2356
  return { dispatched: true, sessionId, task: { ...task } }
2166
2357
  }
2167
2358
 
2359
+ /** 「用户回复」followup 文本(§1.9):任务仍在原状态,要求组长接着处理。 */
2360
+ export function buildAnswerText(task, answer) {
2361
+ return (
2362
+ '【任务看板 · 用户回复】' +
2363
+ task.id +
2364
+ ' ' +
2365
+ task.title +
2366
+ '\n用户回答:' +
2367
+ answer +
2368
+ '\n请继续处理该任务(任务仍在原状态)。'
2369
+ )
2370
+ }
2371
+
2372
+ /**
2373
+ * RPC `answer-task`(§1.9):用户回答「待你处理」的问题。
2374
+ *
2375
+ * 1. 校验:`answer` 非空 ≤1000(bad-request)、任务已归档(conflict)、任务必须 flagged(conflict);
2376
+ * 2. 目标会话按 `dispatchedSessionId` → `askedBy` → `sessionId` 逐个尝试(去重、跳过空值):
2377
+ * 已归档的候选跳过,其它候选复用 `agents.get` / `sessionController.resolveAgent` 找 live Agent;
2378
+ * 只有全部不可用才 → conflict(错误信息列出尝试过的会话);
2379
+ * 3. followup + `sessions.flush`:**flush 成功后才**清标记并写 `lastAnswer` / `answeredAt`;
2380
+ * 发送失败 → internal / conflict(标记保留、写 lastError,用户可重试)。
2381
+ *
2382
+ * @returns {Promise<{task: object, sessionId: string}>}
2383
+ */
2384
+ export async function answerTask(rt, id, answer, now = Date.now()) {
2385
+ const task = findTask(rt.state, id)
2386
+ const text = typeof answer === 'string' ? answer.trim() : ''
2387
+ if (text === '') throw new BoardError('bad-request', '回答不能为空')
2388
+ if (text.length > MAX_ANSWER_CHARS) {
2389
+ throw new BoardError('bad-request', '回答不能超过 ' + MAX_ANSWER_CHARS + ' 字符')
2390
+ }
2391
+ if (task.status === 'archived') throw new BoardError('conflict', '任务已归档,不能再回答')
2392
+ if (task.needsUser !== true) throw new BoardError('conflict', '任务没有在等待用户回复')
2393
+ // 候选按优先级去重:派发到的组长 → 提问的会话(askedBy)→ 创建任务的会话。
2394
+ // askedBy 兜住两类任务:没有 sessionId 的 addTask,以及 todo 阶段被 flag、还没派发过的任务。
2395
+ const candidates = []
2396
+ for (const candidate of [task.dispatchedSessionId, task.askedBy, task.sessionId]) {
2397
+ if (typeof candidate === 'string' && candidate !== '' && !candidates.includes(candidate)) {
2398
+ candidates.push(candidate)
2399
+ }
2400
+ }
2401
+ /** 失败统一收尾:保留 flagged 状态,把原因写进任务 lastError 并落盘,再抛给 RPC。 */
2402
+ const fail = (code, message) => {
2403
+ task.lastError = message
2404
+ task.updatedAt = iso(now)
2405
+ commitBoard(rt.state, rt.filePath)
2406
+ return new BoardError(code, message)
2407
+ }
2408
+ if (candidates.length === 0) {
2409
+ throw fail('conflict', '找不到可以接收回复的会话:任务没有记录派发会话 / 提问会话 / 发起会话')
2410
+ }
2411
+ // 归档候选直接跳过(归档门会拒绝它跑模型步进),继续试下一个;全部不可用才 conflict。
2412
+ const archived = archivedSessionIdSet(rt)
2413
+ const attempted = []
2414
+ let sessionId = ''
2415
+ let agent = null
2416
+ for (const candidate of candidates) {
2417
+ if (archived.has(candidate)) {
2418
+ attempted.push(candidate + ' 已归档')
2419
+ continue
2420
+ }
2421
+ const live = await resolveAgentForSession(rt, candidate)
2422
+ if (live) {
2423
+ sessionId = candidate
2424
+ agent = live
2425
+ break
2426
+ }
2427
+ attempted.push(candidate + ' 不在线')
2428
+ }
2429
+ if (!agent) {
2430
+ throw fail('conflict', '找不到可以接收回复的会话(已尝试:' + attempted.join(';') + ')')
2431
+ }
2432
+ try {
2433
+ agent.followup(createBoardUserMessage(buildAnswerText(task, text)))
2434
+ // 与派发路径一致:等 inbox splice 落盘再清标记,否则重启会丢回答但 needsUser 已经清掉。
2435
+ const sessions = serviceOf(rt.ctx, 'sessions')
2436
+ if (sessions && typeof sessions.flush === 'function') await sessions.flush(agent.session)
2437
+ } catch (error) {
2438
+ console.warn('[taskboard] 用户回复投递失败:' + describeError(error))
2439
+ throw fail('internal', '回复发送失败:' + describeError(error))
2440
+ }
2441
+ const stamp = iso(now)
2442
+ clearNeedsUserFields(task)
2443
+ task.lastAnswer = text
2444
+ task.answeredAt = stamp
2445
+ task.lastError = ''
2446
+ task.updatedAt = stamp
2447
+ commitBoard(rt.state, rt.filePath)
2448
+ return { task: { ...task }, sessionId }
2449
+ }
2450
+
2168
2451
  /** RPC `bind-main-session`(§3.1.1):绑定完成回执收件人;不要求会话当前在线。 */
2169
2452
  export async function bindMainSession(rt, sessionId) {
2170
2453
  if (typeof sessionId !== 'string' || sessionId.trim() === '') {
@@ -2192,6 +2475,96 @@ export async function clearMainSession(rt) {
2192
2475
  return { ok: true }
2193
2476
  }
2194
2477
 
2478
+ /* ------------------------------------------------------------------ *
2479
+ * 工作区偏好(config.workspaceFilter / config.workspaceDraft)的「未落盘」标记
2480
+ *
2481
+ * 背景:`commitBoard` 写盘失败后内存里已经是新值;下一次同值调用若只看「内存值没变」就返回
2482
+ * `saved:true`,盘上其实并没有该字段——`saved:true` 在撒谎。这里按 state 记住哪些字段
2483
+ * 「上次写盘失败 / 尚未落盘」,让同值重试仍然尝试写盘(§3.3)。
2484
+ *
2485
+ * - **不落盘**:WeakMap 只在 Host 进程内存里,`board.json` 不会因此多出任何字段;
2486
+ * - 写成功清除、写失败登记;
2487
+ * - `reloadBoardIfStale` 可能替换 `rt.state`:旧 state 的标记随 WeakMap 自然失效,新 state 的
2488
+ * `config[field]` 回到盘上旧值,下一次调用走正常「值不同 → 写盘」分支——这就是自愈路径,
2489
+ * 不需要人工清理,也**不要**把这份状态写进 board.json;
2490
+ * - 其它路径成功整份写盘(如 `add-task`)后标记会保守保留:最多多一次冗余重写,
2491
+ * 不会丢数据,也不会误报 `saved:true`。
2492
+ * ------------------------------------------------------------------ */
2493
+ const dirtyWorkspacePrefs = new WeakMap()
2494
+
2495
+ /** 登记「该字段上次写盘失败 / 尚未落盘」。 */
2496
+ function markWorkspacePrefDirty(state, field) {
2497
+ if (!state || typeof state !== 'object') return
2498
+ const fields = dirtyWorkspacePrefs.get(state) || new Set()
2499
+ fields.add(field)
2500
+ dirtyWorkspacePrefs.set(state, fields)
2501
+ }
2502
+
2503
+ /** 写盘成功后清除标记。 */
2504
+ function clearWorkspacePrefDirty(state, field) {
2505
+ const fields = state && typeof state === 'object' ? dirtyWorkspacePrefs.get(state) : undefined
2506
+ if (!fields) return
2507
+ fields.delete(field)
2508
+ if (fields.size === 0) dirtyWorkspacePrefs.delete(state)
2509
+ }
2510
+
2511
+ /** 该字段是否「上次写盘失败 / 尚未落盘」。 */
2512
+ function isWorkspacePrefDirty(state, field) {
2513
+ const fields = state && typeof state === 'object' ? dirtyWorkspacePrefs.get(state) : undefined
2514
+ return Boolean(fields && fields.has(field))
2515
+ }
2516
+
2517
+ /**
2518
+ * 写一个「工作区选择」UI 偏好(`config.workspaceFilter` / `config.workspaceDraft`,§2 / §3.1)。
2519
+ *
2520
+ * - 归一化用 `normalizeWorkspaceSelection`(坏值 → `''`,**不报错**);
2521
+ * - 写前 `reloadBoardIfStale(rt)` 对齐盘上状态(另一个标签页 / 进程刚改过就采用盘上状态),
2522
+ * 只改 `field` 这一个字段——**合并写**,任务 / 组长映射 / 主会话绑定 / 另一个偏好都原样保留;
2523
+ * - 值没变且上次写盘成功 → 不写盘(不 bump revision,`{changed:false, saved:true}`);
2524
+ * - 值没变但**上次写盘失败**(`dirtyWorkspacePrefs`)→ 仍重试写盘:`changed:false`,
2525
+ * `saved` 如实反映本次写盘结果(否则「内存已是新值、盘上还没有」时同值调用会谎报 `saved:true`);
2526
+ * - 写盘失败只由 `commitBoard` 记 `console.warn`,响应带 `saved:false`,UI 不受影响
2527
+ * (best-effort,§3.1 / §3.3)。
2528
+ */
2529
+ function writeWorkspacePreference(rt, field, raw) {
2530
+ const value = normalizeWorkspaceSelection(raw)
2531
+ reloadBoardIfStale(rt)
2532
+ const state = rt.state
2533
+ const config = isPlainObject(state && state.config) ? state.config : {}
2534
+ const sameValue = config[field] === value
2535
+ if (sameValue && !isWorkspacePrefDirty(state, field)) {
2536
+ return { value, changed: false, saved: true }
2537
+ }
2538
+ if (!sameValue) state.config = { ...config, [field]: value }
2539
+ const result = commitBoard(state, rt.filePath)
2540
+ if (result.saved === false) {
2541
+ markWorkspacePrefDirty(state, field)
2542
+ return { value, changed: !sameValue, saved: false }
2543
+ }
2544
+ clearWorkspacePrefDirty(state, field)
2545
+ return { value, changed: !sameValue, saved: true }
2546
+ }
2547
+
2548
+ /**
2549
+ * RPC `set-workspace-filter`(§3.1):记住看板「工作区」过滤选择(v0.2.3)。
2550
+ * 归一化 / 合并写 / 幂等 / 写失败后同值重试仍会重试写盘 / 失败降级见 `writeWorkspacePreference` 的说明。
2551
+ */
2552
+ export function setWorkspaceFilter(rt, raw) {
2553
+ const result = writeWorkspacePreference(rt, 'workspaceFilter', raw)
2554
+ return { workspaceFilter: result.value, changed: result.changed, saved: result.saved }
2555
+ }
2556
+
2557
+ /**
2558
+ * RPC `set-workspace-draft`(§3.1,**v0.2.3**):记住平台看板**新建行**
2559
+ * 「任务所属工作区」下拉的选择——与 `setWorkspaceFilter` 同口径(合并写 / 幂等 /
2560
+ * 写失败只告警、同值重试仍会重试写盘),但写的是**另一个字段** `config.workspaceDraft`,
2561
+ * 两个下拉互不串值。`''` = 未选择(= 新建行默认,提交按钮保持禁用)。
2562
+ */
2563
+ export function setWorkspaceDraft(rt, raw) {
2564
+ const result = writeWorkspacePreference(rt, 'workspaceDraft', raw)
2565
+ return { workspaceDraft: result.value, changed: result.changed, saved: result.saved }
2566
+ }
2567
+
2195
2568
  /**
2196
2569
  * RPC `ensure-workspace-lead`(§3.1.1):确保 cwd 所属工作区有可用常驻组长。
2197
2570
  * 复用已有映射(顺手修复 title/cwd)→ 唤醒冷会话 → 失败则创建新组长替换失效映射。
@@ -2840,6 +3213,9 @@ export const TASK_LIST_OUTPUT_SCHEMA = {
2840
3213
  assignee: { type: 'string' },
2841
3214
  result: { type: 'string' },
2842
3215
  updatedAt: { type: 'string' },
3216
+ needsUser: { type: 'boolean' },
3217
+ question: { type: 'string' },
3218
+ questionOptions: { type: 'array', items: { type: 'string' } },
2843
3219
  },
2844
3220
  },
2845
3221
  },
@@ -2864,6 +3240,10 @@ export function taskBrief(task) {
2864
3240
  assignee: task.assignee || '',
2865
3241
  result: task.result || '',
2866
3242
  updatedAt: task.updatedAt,
3243
+ // v0.2.2(§1.9):flagged 任务必须在模型工具输出里可见,组长才能确认自己在等什么。
3244
+ needsUser: task.needsUser === true,
3245
+ question: task.question || '',
3246
+ questionOptions: Array.isArray(task.questionOptions) ? task.questionOptions.slice() : [],
2867
3247
  }
2868
3248
  }
2869
3249
 
@@ -2876,6 +3256,7 @@ function renderTaskList(value) {
2876
3256
  lines.push('- ' + bits.join(' '))
2877
3257
  if (task.note) lines.push(' 备注:' + task.note)
2878
3258
  if (task.result) lines.push(' 结论:' + task.result)
3259
+ if (task.needsUser) lines.push(' 待用户回答:' + task.question)
2879
3260
  }
2880
3261
  return [{ type: 'text', text: lines.join('\n') }]
2881
3262
  }
@@ -2884,6 +3265,7 @@ function renderTaskOne(prefix, task) {
2884
3265
  const lines = [prefix + task.id + ' [' + task.status + '] ' + task.title]
2885
3266
  if (task.note) lines.push('备注:' + task.note)
2886
3267
  if (task.result) lines.push('结论:' + task.result)
3268
+ if (task.needsUser) lines.push('待用户回答:' + task.question)
2887
3269
  lines.push('更新时间:' + task.updatedAt)
2888
3270
  return [{ type: 'text', text: lines.join('\n') }]
2889
3271
  }
@@ -2905,6 +3287,9 @@ export const TASK_ONE_OUTPUT_SCHEMA = {
2905
3287
  assignee: { type: 'string' },
2906
3288
  result: { type: 'string' },
2907
3289
  updatedAt: { type: 'string' },
3290
+ needsUser: { type: 'boolean' },
3291
+ question: { type: 'string' },
3292
+ questionOptions: { type: 'array', items: { type: 'string' } },
2908
3293
  },
2909
3294
  },
2910
3295
  },
@@ -3004,7 +3389,10 @@ export function registerTools(toolCtx, rt) {
3004
3389
  name: 'taskboard_update',
3005
3390
  description:
3006
3391
  '更新看板任务:置为 doing(已派发)、done(审核通过)、todo(打回重做)、archived(归档);' +
3007
- '也可以用 result 写审核结论、assignee 写子 Agent 标识。状态迁移非法时会返回错误。',
3392
+ '也可以用 result 写审核结论、assignee 写子 Agent 标识。状态迁移非法时会返回错误。' +
3393
+ '需要用户决策时用 needsUser:true + question(可选 questionOptions 选项)在任务上提问,' +
3394
+ '看板会把它放进「待你处理」并通知用户回答;needsUser:false 取消提问(问题字段清空,回答留档)。' +
3395
+ '任务已归档时不能再提问(返回 conflict):需要用户拍板请先重开该任务或新建一条任务。',
3008
3396
  parameters: {
3009
3397
  type: 'object',
3010
3398
  additionalProperties: false,
@@ -3015,18 +3403,37 @@ export function registerTools(toolCtx, rt) {
3015
3403
  result: { type: 'string', description: '审核结论 / 子 Agent 汇报摘要' },
3016
3404
  assignee: { type: 'string', description: '子 Agent 的 label 或会话 id' },
3017
3405
  note: { type: 'string', description: '备注(覆盖原备注)' },
3406
+ needsUser: {
3407
+ type: 'boolean',
3408
+ description: '是否在等用户回复:true 时必须同时给 question;false 取消提问',
3409
+ },
3410
+ question: { type: 'string', description: '需要用户决策的问题(≤500 字;给 question 即进入待你处理)' },
3411
+ questionOptions: {
3412
+ type: 'array',
3413
+ items: { type: 'string' },
3414
+ description: '可选答案(最多 4 个,每个 ≤80 字;用户可以在看板上点选)',
3415
+ },
3018
3416
  },
3019
3417
  },
3020
3418
  output: {
3021
3419
  schema: TASK_ONE_OUTPUT_SCHEMA,
3022
3420
  render: (_args, value) => renderTaskOne('已更新任务 ', value.task),
3023
3421
  },
3024
- async execute(args) {
3422
+ async execute(args, exec) {
3025
3423
  if (!args || !args.id) throw new Error('缺少任务 id')
3026
3424
  const patch = {}
3027
- for (const key of ['status', 'result', 'assignee', 'note']) {
3425
+ for (const key of ['status', 'result', 'assignee', 'note', 'needsUser', 'question', 'questionOptions']) {
3028
3426
  if (args[key] !== undefined) patch[key] = args[key]
3029
3427
  }
3428
+ // §1.9:提问的会话 id(askedBy)由宿主补,模型不能伪造别的会话。
3429
+ if (args.needsUser === true || args.question !== undefined) {
3430
+ try {
3431
+ const agent = exec && exec.agent
3432
+ if (agent && agent.session && typeof agent.session.id === 'string') patch.askedBy = agent.session.id
3433
+ } catch {
3434
+ /* 非 agent 调用时忽略 */
3435
+ }
3436
+ }
3030
3437
  if (typeof patch.note === 'string') assertNoteAttachments(patch.note)
3031
3438
  const task = applyTaskUpdate(rt.state, args.id, patch)
3032
3439
  commitBoard(rt.state, rt.filePath)
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "dsh-dispatch-board",
3
- "version": "0.2.1",
3
+ "version": "0.2.3",
4
4
  "description": "DeepSeek Harness 插件:派单看板 + 派单模式。主 Agent 只拆解/派发/审核/汇报,子 Agent 干活;看板四列(待开始/进行中/已完成/已归档)由轮询自动派发,结论按 Markdown 展示。Dispatcher mode plus a dispatch board for DeepSeek Harness.",
5
5
  "type": "module",
6
6
  "main": "lib/index.js",