dsh-dispatch-board 0.2.0 → 0.2.2
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/client.js +621 -64
- package/lib/index.js +377 -8
- package/package.json +1 -1
- package/presets/taskboard.patch.yml +12 -2
package/lib/index.js
CHANGED
|
@@ -59,6 +59,15 @@ 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)。 */
|
|
@@ -67,6 +76,11 @@ const MAX_WORKSPACE_LEADS = 32
|
|
|
67
76
|
const MAX_RECEIPT_BATCH = 10
|
|
68
77
|
/** 完成回执里每条任务结论压成单行后的最大字符数(§1.6)。 */
|
|
69
78
|
const RECEIPT_RESULT_CHARS = 200
|
|
79
|
+
/**
|
|
80
|
+
* 归档保留期(§1.2 / §2):`archived` 任务在归档满 30 分钟后由宿主自动从看板删除,
|
|
81
|
+
* 不需要用户手动点「删除」。判定见 `pruneArchivedTasks()`。
|
|
82
|
+
*/
|
|
83
|
+
export const ARCHIVE_RETENTION_MS = 30 * 60 * 1000
|
|
70
84
|
|
|
71
85
|
/* ------------------------------------------------------------------ *
|
|
72
86
|
* 粘贴图片附件(v0.2.0,§2.1)
|
|
@@ -324,12 +338,33 @@ export function normalizeConfig(raw) {
|
|
|
324
338
|
}
|
|
325
339
|
}
|
|
326
340
|
|
|
341
|
+
/**
|
|
342
|
+
* 规范化 `questionOptions`(§1.9):只保留非空字符串,逐个 trim 截 80 字符,去重,最多 4 个。
|
|
343
|
+
* 非法项(非字符串 / 空串 / 重复)静默过滤——组长的选项是提示,不值得为一项写错整条任务。
|
|
344
|
+
*/
|
|
345
|
+
export function normalizeQuestionOptions(raw) {
|
|
346
|
+
if (!Array.isArray(raw)) return []
|
|
347
|
+
const options = []
|
|
348
|
+
for (const item of raw) {
|
|
349
|
+
if (typeof item !== 'string') continue
|
|
350
|
+
const text = trimmed(item, MAX_OPTION_CHARS)
|
|
351
|
+
if (text === '' || options.includes(text)) continue
|
|
352
|
+
options.push(text)
|
|
353
|
+
if (options.length >= MAX_QUESTION_OPTIONS) break
|
|
354
|
+
}
|
|
355
|
+
return options
|
|
356
|
+
}
|
|
357
|
+
|
|
327
358
|
function normalizeTask(raw, index) {
|
|
328
359
|
if (!isPlainObject(raw)) return null
|
|
329
360
|
const status = STATUSES.includes(raw.status) ? raw.status : 'todo'
|
|
330
361
|
const title = trimmed(raw.title, MAX_TITLE_CHARS)
|
|
331
362
|
if (title === '') return null
|
|
332
363
|
const id = trimmed(raw.id, 40) || 't-' + String(index + 1)
|
|
364
|
+
// §1.9:flagged 但问题为空(坏数据 / 老版本写坏)→ 保守降级为未 flag,不丢整条任务。
|
|
365
|
+
// archived 是终态:旧 board.json 里归档后仍带标记的,读盘时也按未 flag 处理(§1.9 第 5 条)。
|
|
366
|
+
const question = trimmed(raw.question, MAX_QUESTION_CHARS)
|
|
367
|
+
const needsUser = raw.needsUser === true && question !== '' && status !== 'archived'
|
|
333
368
|
return {
|
|
334
369
|
id,
|
|
335
370
|
title,
|
|
@@ -344,6 +379,14 @@ function normalizeTask(raw, index) {
|
|
|
344
379
|
reportedAt: asString(raw.reportedAt) || null,
|
|
345
380
|
// v0.2.0 自动建任务标记(§1.8):只有 'lead-dispatch' 合法,其它一律 null(= 普通任务)。
|
|
346
381
|
autoDispatch: raw.autoDispatch === LEAD_AUTO_MARK ? LEAD_AUTO_MARK : null,
|
|
382
|
+
// v0.2.2「待你处理」(§1.9):不新增 status,只在任务上打标记 + 问题 / 选项 / 提问者。
|
|
383
|
+
needsUser,
|
|
384
|
+
question: needsUser ? question : '',
|
|
385
|
+
questionOptions: needsUser ? normalizeQuestionOptions(raw.questionOptions) : [],
|
|
386
|
+
askedAt: needsUser ? asString(raw.askedAt) || null : null,
|
|
387
|
+
askedBy: needsUser ? asString(raw.askedBy) || null : null,
|
|
388
|
+
lastAnswer: trimmed(raw.lastAnswer, MAX_ANSWER_CHARS),
|
|
389
|
+
answeredAt: asString(raw.answeredAt) || null,
|
|
347
390
|
cwd: typeof raw.cwd === 'string' && raw.cwd !== '' ? raw.cwd : null,
|
|
348
391
|
assignee: trimmed(raw.assignee, 200),
|
|
349
392
|
result: truncateNote(raw.result, MAX_NOTE_CHARS),
|
|
@@ -738,6 +781,12 @@ export function addTask(state, input, now = Date.now()) {
|
|
|
738
781
|
if (!isPlainObject(input)) throw new BoardError('bad-request', '参数必须是对象')
|
|
739
782
|
const title = trimmed(input.title, MAX_TITLE_CHARS)
|
|
740
783
|
if (title === '') throw new BoardError('bad-request', '标题不能为空')
|
|
784
|
+
// §1.9:建任务时也可以直接带问题(宿主 / 测试用;UI 的新建行不传这些字段)。
|
|
785
|
+
const needsUser = input.needsUser === true
|
|
786
|
+
const question = trimmed(input.question, MAX_QUESTION_CHARS)
|
|
787
|
+
if (needsUser && question === '') {
|
|
788
|
+
throw new BoardError('bad-request', 'needsUser=true 时必须提供非空的 question')
|
|
789
|
+
}
|
|
741
790
|
const stamp = iso(now)
|
|
742
791
|
const task = {
|
|
743
792
|
id: nextTaskId(state),
|
|
@@ -751,6 +800,13 @@ export function addTask(state, input, now = Date.now()) {
|
|
|
751
800
|
dispatchedSessionTitle: '',
|
|
752
801
|
reportedAt: null,
|
|
753
802
|
autoDispatch: null,
|
|
803
|
+
needsUser,
|
|
804
|
+
question: needsUser ? question : '',
|
|
805
|
+
questionOptions: needsUser ? normalizeQuestionOptions(input.questionOptions) : [],
|
|
806
|
+
askedAt: needsUser ? stamp : null,
|
|
807
|
+
askedBy: needsUser && typeof input.askedBy === 'string' && input.askedBy !== '' ? input.askedBy : null,
|
|
808
|
+
lastAnswer: '',
|
|
809
|
+
answeredAt: null,
|
|
754
810
|
cwd: typeof input.cwd === 'string' && input.cwd !== '' ? input.cwd : null,
|
|
755
811
|
assignee: '',
|
|
756
812
|
result: '',
|
|
@@ -772,9 +828,19 @@ export function canTransition(from, to) {
|
|
|
772
828
|
return Array.isArray(allowed) && allowed.includes(to)
|
|
773
829
|
}
|
|
774
830
|
|
|
831
|
+
/** 清空「待你处理」的问题五字段(保留 `lastAnswer` / `answeredAt` 留档)。 */
|
|
832
|
+
function clearNeedsUserFields(task) {
|
|
833
|
+
task.needsUser = false
|
|
834
|
+
task.question = ''
|
|
835
|
+
task.questionOptions = []
|
|
836
|
+
task.askedAt = null
|
|
837
|
+
task.askedBy = null
|
|
838
|
+
}
|
|
839
|
+
|
|
775
840
|
export function applyTaskUpdate(state, id, patch, now = Date.now()) {
|
|
776
841
|
const task = findTask(state, id)
|
|
777
842
|
if (!isPlainObject(patch)) throw new BoardError('bad-request', 'patch 必须是对象')
|
|
843
|
+
// ---- 先完成全部可能抛错的校验:本函数抛错前不改任何任务字段(调用方也不会 commit)。----
|
|
778
844
|
if (patch.status !== undefined) {
|
|
779
845
|
if (!STATUSES.includes(patch.status)) {
|
|
780
846
|
throw new BoardError('bad-request', '非法状态:' + String(patch.status), { allowed: STATUSES })
|
|
@@ -787,8 +853,63 @@ export function applyTaskUpdate(state, id, patch, now = Date.now()) {
|
|
|
787
853
|
})
|
|
788
854
|
}
|
|
789
855
|
}
|
|
856
|
+
let nextTitle = null
|
|
857
|
+
if (patch.title !== undefined) {
|
|
858
|
+
nextTitle = trimmed(patch.title, MAX_TITLE_CHARS)
|
|
859
|
+
if (nextTitle === '') throw new BoardError('bad-request', '标题不能为空')
|
|
860
|
+
}
|
|
861
|
+
// v0.2.2「待你处理」(§1.9):
|
|
862
|
+
// - 给 question(或显式 needsUser:true)即进入 flagged 状态;needsUser:false 清问题四字段、保留回答留档;
|
|
863
|
+
// - flagged 但 question 为空 → bad-request;
|
|
864
|
+
// - 只给 questionOptions、既不 flag 也不带 question → bad-request(不静默丢选项);
|
|
865
|
+
// - 重设 question 但没带 questionOptions → 清空旧选项(旧按钮与新闻题无关,别让用户点错);
|
|
866
|
+
// - askedAt / askedBy 由宿主 / 工具设置:首次 flag 补 askedAt(重复更新保留最早时间,用于「最旧优先」排序)。
|
|
867
|
+
// - 归档优先:patch.status === 'archived' 时跳过上面全部 needsUser 校验,直接清问题标记——
|
|
868
|
+
// 模型漏传 question 的 `{status:'archived', needsUser:true}` 不该被 bad-request 拦住归档。
|
|
869
|
+
// 校验全部在写字段之前完成,needsUser 变更先算成 `preparedNeeds`,最后统一应用。
|
|
790
870
|
const stamp = iso(now)
|
|
791
871
|
const previousStatus = task.status
|
|
872
|
+
const wasFlagged = task.needsUser === true
|
|
873
|
+
const needsTouched =
|
|
874
|
+
patch.needsUser !== undefined || patch.question !== undefined || patch.questionOptions !== undefined
|
|
875
|
+
let preparedNeeds = null
|
|
876
|
+
if (patch.status === 'archived') {
|
|
877
|
+
// 归档是终态,清掉问题标记 / 四字段,保留 lastAnswer / answeredAt 留档。
|
|
878
|
+
preparedNeeds = { needsUser: false, question: '', questionOptions: [], askedAt: null, askedBy: null }
|
|
879
|
+
} else if (needsTouched) {
|
|
880
|
+
const nextFlag = patch.needsUser !== undefined ? patch.needsUser === true : wasFlagged || patch.question !== undefined
|
|
881
|
+
if (!nextFlag) {
|
|
882
|
+
if (patch.questionOptions !== undefined) {
|
|
883
|
+
throw new BoardError('bad-request', 'questionOptions 需要同时提供 question 或 needsUser:true')
|
|
884
|
+
}
|
|
885
|
+
preparedNeeds = { needsUser: false, question: '', questionOptions: [], askedAt: null, askedBy: null }
|
|
886
|
+
} else {
|
|
887
|
+
const question = patch.question !== undefined ? trimmed(patch.question, MAX_QUESTION_CHARS) : task.question || ''
|
|
888
|
+
if (question === '') throw new BoardError('bad-request', 'needsUser=true 时必须提供非空的 question')
|
|
889
|
+
preparedNeeds = {
|
|
890
|
+
needsUser: true,
|
|
891
|
+
question,
|
|
892
|
+
questionOptions:
|
|
893
|
+
patch.questionOptions !== undefined
|
|
894
|
+
? normalizeQuestionOptions(patch.questionOptions)
|
|
895
|
+
: patch.question !== undefined
|
|
896
|
+
? []
|
|
897
|
+
: Array.isArray(task.questionOptions)
|
|
898
|
+
? task.questionOptions
|
|
899
|
+
: [],
|
|
900
|
+
askedAt: wasFlagged && typeof task.askedAt === 'string' && task.askedAt !== '' ? task.askedAt : stamp,
|
|
901
|
+
askedBy:
|
|
902
|
+
patch.askedBy !== undefined
|
|
903
|
+
? typeof patch.askedBy === 'string' && patch.askedBy !== ''
|
|
904
|
+
? patch.askedBy
|
|
905
|
+
: null
|
|
906
|
+
: wasFlagged
|
|
907
|
+
? task.askedBy
|
|
908
|
+
: null,
|
|
909
|
+
}
|
|
910
|
+
}
|
|
911
|
+
}
|
|
912
|
+
// ---- 以下才开始写任务字段(校验已完成,不再抛错)----
|
|
792
913
|
if (patch.status !== undefined && patch.status !== previousStatus) {
|
|
793
914
|
task.status = patch.status
|
|
794
915
|
// 状态变了,上一轮「派发跳过」的原因就过期了,别让它挂在卡片上误导人。
|
|
@@ -819,16 +940,19 @@ export function applyTaskUpdate(state, id, patch, now = Date.now()) {
|
|
|
819
940
|
task.autoDispatch = null
|
|
820
941
|
}
|
|
821
942
|
}
|
|
822
|
-
if (
|
|
823
|
-
const title = trimmed(patch.title, MAX_TITLE_CHARS)
|
|
824
|
-
if (title === '') throw new BoardError('bad-request', '标题不能为空')
|
|
825
|
-
task.title = title
|
|
826
|
-
}
|
|
943
|
+
if (nextTitle !== null) task.title = nextTitle
|
|
827
944
|
if (patch.note !== undefined) task.note = truncateNote(patch.note, MAX_NOTE_CHARS)
|
|
828
945
|
if (patch.result !== undefined) task.result = truncateNote(patch.result, MAX_NOTE_CHARS)
|
|
829
946
|
if (patch.assignee !== undefined) task.assignee = trimmed(patch.assignee, 200)
|
|
830
947
|
if (patch.lastError !== undefined) task.lastError = trimmed(patch.lastError, 500)
|
|
831
948
|
if (patch.clearError === true) task.lastError = ''
|
|
949
|
+
if (preparedNeeds !== null) {
|
|
950
|
+
task.needsUser = preparedNeeds.needsUser
|
|
951
|
+
task.question = preparedNeeds.question
|
|
952
|
+
task.questionOptions = preparedNeeds.questionOptions
|
|
953
|
+
task.askedAt = preparedNeeds.askedAt
|
|
954
|
+
task.askedBy = preparedNeeds.askedBy
|
|
955
|
+
}
|
|
832
956
|
if (patch.sessionId !== undefined) {
|
|
833
957
|
task.sessionId = typeof patch.sessionId === 'string' && patch.sessionId !== '' ? patch.sessionId : null
|
|
834
958
|
}
|
|
@@ -842,6 +966,8 @@ export function archiveDoneTasks(state, now = Date.now()) {
|
|
|
842
966
|
if (task.status !== 'done') continue
|
|
843
967
|
task.status = 'archived'
|
|
844
968
|
task.archivedAt = iso(now)
|
|
969
|
+
// §1.9:归档是终态——flagged 任务归档后不再等用户回答,清问题四字段(回答留档保留)。
|
|
970
|
+
clearNeedsUserFields(task)
|
|
845
971
|
task.updatedAt = iso(now)
|
|
846
972
|
archived += 1
|
|
847
973
|
}
|
|
@@ -855,6 +981,73 @@ export function deleteTask(state, id) {
|
|
|
855
981
|
return task
|
|
856
982
|
}
|
|
857
983
|
|
|
984
|
+
/** 解析一个 ISO 时间字段;缺失 / 非字符串 / 不可解析都返回 null。 */
|
|
985
|
+
function timeOrNull(value) {
|
|
986
|
+
if (typeof value !== 'string') return null
|
|
987
|
+
const text = value.trim()
|
|
988
|
+
if (text === '') return null
|
|
989
|
+
const ms = Date.parse(text)
|
|
990
|
+
return Number.isFinite(ms) ? ms : null
|
|
991
|
+
}
|
|
992
|
+
|
|
993
|
+
/**
|
|
994
|
+
* 任务的归档时间(§1.2):优先 `archivedAt`,缺失 / 不可解析时回退 `updatedAt` → `createdAt`。
|
|
995
|
+
* 三个都不可用 → null(调用方保守保留,不删)。
|
|
996
|
+
*/
|
|
997
|
+
export function archiveTimeOf(task) {
|
|
998
|
+
if (!isPlainObject(task)) return null
|
|
999
|
+
for (const field of ['archivedAt', 'updatedAt', 'createdAt']) {
|
|
1000
|
+
const ms = timeOrNull(task[field])
|
|
1001
|
+
if (ms !== null) return ms
|
|
1002
|
+
}
|
|
1003
|
+
return null
|
|
1004
|
+
}
|
|
1005
|
+
|
|
1006
|
+
/**
|
|
1007
|
+
* 归档保留期清理(§1.2 / §2):把「归档满 retentionMs」的任务从 state.tasks 移除。纯函数。
|
|
1008
|
+
*
|
|
1009
|
+
* - 只处理 `status === 'archived'`;`todo` / `doing` / `done` 一律不动;
|
|
1010
|
+
* - 归档时间见 `archiveTimeOf()`(`archivedAt` → `updatedAt` → `createdAt`);
|
|
1011
|
+
* 三个字段都不可解析时**保守保留**——宁可留一条,也不把时间坏掉的任务误删;
|
|
1012
|
+
* - `now - archivedAt >= retentionMs` 即删除(满 30 分钟,边界即删);
|
|
1013
|
+
* - **不回退 `state.nextId`**:已删除任务的 id 不复用,避免旧引用指到新任务上;
|
|
1014
|
+
* - 原地改写 `state.tasks`(保持数组引用不变),未过期任务保持原顺序。
|
|
1015
|
+
*
|
|
1016
|
+
* @param {object} state 看板状态
|
|
1017
|
+
* @param {number} [now] 当前时间(ms)
|
|
1018
|
+
* @param {number} [retentionMs] 保留期(默认 `ARCHIVE_RETENTION_MS`)
|
|
1019
|
+
* @returns {{removed:number, ids:string[]}} 删除数量与被删任务 id(board 顺序)
|
|
1020
|
+
*/
|
|
1021
|
+
export function pruneArchivedTasks(state, now = Date.now(), retentionMs = ARCHIVE_RETENTION_MS) {
|
|
1022
|
+
const outcome = { removed: 0, ids: [] }
|
|
1023
|
+
if (!isPlainObject(state) || !Array.isArray(state.tasks)) return outcome
|
|
1024
|
+
const ttl = Number.isFinite(Number(retentionMs)) && Number(retentionMs) >= 0 ? Number(retentionMs) : ARCHIVE_RETENTION_MS
|
|
1025
|
+
const kept = []
|
|
1026
|
+
for (const task of state.tasks) {
|
|
1027
|
+
if (!isPlainObject(task) || task.status !== 'archived') {
|
|
1028
|
+
kept.push(task)
|
|
1029
|
+
continue
|
|
1030
|
+
}
|
|
1031
|
+
const archivedAt = archiveTimeOf(task)
|
|
1032
|
+
if (archivedAt === null) {
|
|
1033
|
+
kept.push(task)
|
|
1034
|
+
continue
|
|
1035
|
+
}
|
|
1036
|
+
if (now - archivedAt >= ttl) {
|
|
1037
|
+
outcome.ids.push(task.id)
|
|
1038
|
+
outcome.removed += 1
|
|
1039
|
+
continue
|
|
1040
|
+
}
|
|
1041
|
+
kept.push(task)
|
|
1042
|
+
}
|
|
1043
|
+
if (outcome.removed > 0) {
|
|
1044
|
+
// 原地替换内容:其它持有 state.tasks 引用的地方(快照 / 轮询)不会看到旧数组。
|
|
1045
|
+
state.tasks.length = 0
|
|
1046
|
+
for (const task of kept) state.tasks.push(task)
|
|
1047
|
+
}
|
|
1048
|
+
return outcome
|
|
1049
|
+
}
|
|
1050
|
+
|
|
858
1051
|
/* ------------------------------------------------------------------ *
|
|
859
1052
|
* 派单:候选选择 / 目标 Agent / 消息构造
|
|
860
1053
|
* ------------------------------------------------------------------ */
|
|
@@ -878,6 +1071,8 @@ export function selectDispatchCandidates(state, now = Date.now()) {
|
|
|
878
1071
|
const cooldown = notifyCooldownMs(config)
|
|
879
1072
|
return state.tasks
|
|
880
1073
|
.filter((task) => task.status === 'todo')
|
|
1074
|
+
// §1.9:等待用户回答的任务不投递(问题没回答前重复派发只会让组长重复提问)。
|
|
1075
|
+
.filter((task) => task.needsUser !== true)
|
|
881
1076
|
.filter((task) => task.notificationCount < config.maxNotifications)
|
|
882
1077
|
.filter((task) => {
|
|
883
1078
|
if (!task.notifiedAt) return true
|
|
@@ -996,6 +1191,9 @@ export function requeueTasksOfLead(state, sessionId, now = Date.now()) {
|
|
|
996
1191
|
task.assignee = ''
|
|
997
1192
|
task.dispatchedSessionId = null
|
|
998
1193
|
task.dispatchedSessionTitle = ''
|
|
1194
|
+
// §1.9:重排后这条任务不再由旧组长/旧提问者跟进,清掉问题标记——
|
|
1195
|
+
// 否则回答会落到创建会话而不是新组长,tick 又会因 flagged 跳过它,任务卡住。
|
|
1196
|
+
clearNeedsUserFields(task)
|
|
999
1197
|
// 重排回 todo = 回到轮询队列、归新组长审核:清掉自动任务标记(§1.8),不再被宿主自动 done。
|
|
1000
1198
|
task.autoDispatch = null
|
|
1001
1199
|
task.lastError = '工作区组长会话已归档,任务已重新排队,将投给新的组长'
|
|
@@ -1117,6 +1315,11 @@ export function buildDispatchText(task, now = Date.now()) {
|
|
|
1117
1315
|
const lines = ['【任务看板 · 待开始】' + task.id + ' ' + task.title]
|
|
1118
1316
|
if (task.note) lines.push('备注:' + task.note)
|
|
1119
1317
|
if (task.cwd) lines.push('工作目录:' + task.cwd)
|
|
1318
|
+
// §1.9:todo 任务提问 → 用户回答 → 清标记后再派发时,组长可能在别的会话里,
|
|
1319
|
+
// 回答必须随派发文本带过去,不然「用户已经拍板」这件事会丢。
|
|
1320
|
+
if (typeof task.lastAnswer === 'string' && task.lastAnswer.trim() !== '') {
|
|
1321
|
+
lines.push('用户最近回答:' + task.lastAnswer)
|
|
1322
|
+
}
|
|
1120
1323
|
lines.push('')
|
|
1121
1324
|
lines.push(
|
|
1122
1325
|
'请按派单规则处理这条看板任务:先用 taskboard_update 把它置为 doing,' +
|
|
@@ -1680,6 +1883,10 @@ async function dispatchRpc(rt, method, payload) {
|
|
|
1680
1883
|
const result = await tick(rt, { taskId: payload.id, force: true })
|
|
1681
1884
|
return result
|
|
1682
1885
|
}
|
|
1886
|
+
case 'answer-task': {
|
|
1887
|
+
// v0.2.2:回答「待你处理」的问题,followup 给组长并清标记(§1.9)。
|
|
1888
|
+
return answerTask(rt, payload.id, payload.answer)
|
|
1889
|
+
}
|
|
1683
1890
|
case 'set-config': {
|
|
1684
1891
|
const next = normalizeConfig({ ...normalizeConfig(rt.state.config), ...payload })
|
|
1685
1892
|
const intervalChanged = next.pollIntervalMs !== normalizeConfig(rt.state.config).pollIntervalMs
|
|
@@ -1920,6 +2127,33 @@ function leadRefFrom(key, mapping, agent, archived = false) {
|
|
|
1920
2127
|
}
|
|
1921
2128
|
}
|
|
1922
2129
|
|
|
2130
|
+
/**
|
|
2131
|
+
* 归档保留期清理的落地版(§1.2 / §2):调纯函数 `pruneArchivedTasks`,
|
|
2132
|
+
* **有删除才** `commitBoard`(revision +1);没删除不动盘、不改 revision。
|
|
2133
|
+
*
|
|
2134
|
+
* 调用点:
|
|
2135
|
+
* - `runTick` 在 `pollEnabled` 判断**之前**——轮询暂停时归档也要按时清理;
|
|
2136
|
+
* - `apply()` 启动时清一次(宿主停机期间到期的归档不必等第一个 tick)。
|
|
2137
|
+
* 全程不抛:清理失败只告警,绝不影响派发 / 完成回执。
|
|
2138
|
+
* @returns {number} 删除的任务数
|
|
2139
|
+
*/
|
|
2140
|
+
function pruneArchivedBoard(rt, now = Date.now()) {
|
|
2141
|
+
let outcome
|
|
2142
|
+
try {
|
|
2143
|
+
outcome = pruneArchivedTasks(rt.state, now)
|
|
2144
|
+
} catch (error) {
|
|
2145
|
+
console.warn('[taskboard] 归档清理失败:' + describeError(error))
|
|
2146
|
+
return 0
|
|
2147
|
+
}
|
|
2148
|
+
if (outcome.removed === 0) return 0
|
|
2149
|
+
const saved = commitBoard(rt.state, rt.filePath)
|
|
2150
|
+
console.log(
|
|
2151
|
+
'[taskboard] 已删除 ' + outcome.removed + ' 条归档满 30 分钟的任务:' + outcome.ids.join(', ') +
|
|
2152
|
+
(saved.saved ? '' : '(写盘失败,仅在内存中删除)'),
|
|
2153
|
+
)
|
|
2154
|
+
return outcome.removed
|
|
2155
|
+
}
|
|
2156
|
+
|
|
1923
2157
|
/**
|
|
1924
2158
|
* 轮询派单入口。每次 tick 末尾都会尝试 flush 一次完成回执(§1.6):
|
|
1925
2159
|
* 回执投递不占用派发名额(未绑定主会话 / 主会话忙或离线时是 no-op)。
|
|
@@ -1938,6 +2172,8 @@ async function runTick(rt, options = {}) {
|
|
|
1938
2172
|
reloadBoardIfStale(rt)
|
|
1939
2173
|
const now = Date.now()
|
|
1940
2174
|
rt.poll.lastRunAt = iso(now)
|
|
2175
|
+
// 归档清理(§1.2)必须在 pollEnabled 判断之前:暂停派发时归档仍要按时删除。
|
|
2176
|
+
pruneArchivedBoard(rt, now)
|
|
1941
2177
|
const config = normalizeConfig(rt.state.config)
|
|
1942
2178
|
if (!config.pollEnabled && !options.taskId) {
|
|
1943
2179
|
rt.poll.lastSkipReason = 'poll-disabled'
|
|
@@ -1947,6 +2183,10 @@ async function runTick(rt, options = {}) {
|
|
|
1947
2183
|
if (options.taskId) {
|
|
1948
2184
|
const single = findTask(rt.state, options.taskId)
|
|
1949
2185
|
if (single.status !== 'todo') throw new BoardError('conflict', '只有待开始的任务可以立即派发(当前状态:' + single.status + ')')
|
|
2186
|
+
// §1.9:flagged 任务不派发(等用户回答);显式「立即派发」也不越过这条规则。
|
|
2187
|
+
if (single.needsUser === true) {
|
|
2188
|
+
throw new BoardError('conflict', '任务正在等待用户回复(needsUser),回答后才能继续派发')
|
|
2189
|
+
}
|
|
1950
2190
|
candidates = [single]
|
|
1951
2191
|
} else {
|
|
1952
2192
|
candidates = selectDispatchCandidates(rt.state, now)
|
|
@@ -2064,6 +2304,98 @@ async function deliverBoardTask(rt, task, agent, now) {
|
|
|
2064
2304
|
return { dispatched: true, sessionId, task: { ...task } }
|
|
2065
2305
|
}
|
|
2066
2306
|
|
|
2307
|
+
/** 「用户回复」followup 文本(§1.9):任务仍在原状态,要求组长接着处理。 */
|
|
2308
|
+
export function buildAnswerText(task, answer) {
|
|
2309
|
+
return (
|
|
2310
|
+
'【任务看板 · 用户回复】' +
|
|
2311
|
+
task.id +
|
|
2312
|
+
' ' +
|
|
2313
|
+
task.title +
|
|
2314
|
+
'\n用户回答:' +
|
|
2315
|
+
answer +
|
|
2316
|
+
'\n请继续处理该任务(任务仍在原状态)。'
|
|
2317
|
+
)
|
|
2318
|
+
}
|
|
2319
|
+
|
|
2320
|
+
/**
|
|
2321
|
+
* RPC `answer-task`(§1.9):用户回答「待你处理」的问题。
|
|
2322
|
+
*
|
|
2323
|
+
* 1. 校验:`answer` 非空 ≤1000(bad-request)、任务已归档(conflict)、任务必须 flagged(conflict);
|
|
2324
|
+
* 2. 目标会话按 `dispatchedSessionId` → `askedBy` → `sessionId` 逐个尝试(去重、跳过空值):
|
|
2325
|
+
* 已归档的候选跳过,其它候选复用 `agents.get` / `sessionController.resolveAgent` 找 live Agent;
|
|
2326
|
+
* 只有全部不可用才 → conflict(错误信息列出尝试过的会话);
|
|
2327
|
+
* 3. followup + `sessions.flush`:**flush 成功后才**清标记并写 `lastAnswer` / `answeredAt`;
|
|
2328
|
+
* 发送失败 → internal / conflict(标记保留、写 lastError,用户可重试)。
|
|
2329
|
+
*
|
|
2330
|
+
* @returns {Promise<{task: object, sessionId: string}>}
|
|
2331
|
+
*/
|
|
2332
|
+
export async function answerTask(rt, id, answer, now = Date.now()) {
|
|
2333
|
+
const task = findTask(rt.state, id)
|
|
2334
|
+
const text = typeof answer === 'string' ? answer.trim() : ''
|
|
2335
|
+
if (text === '') throw new BoardError('bad-request', '回答不能为空')
|
|
2336
|
+
if (text.length > MAX_ANSWER_CHARS) {
|
|
2337
|
+
throw new BoardError('bad-request', '回答不能超过 ' + MAX_ANSWER_CHARS + ' 字符')
|
|
2338
|
+
}
|
|
2339
|
+
if (task.status === 'archived') throw new BoardError('conflict', '任务已归档,不能再回答')
|
|
2340
|
+
if (task.needsUser !== true) throw new BoardError('conflict', '任务没有在等待用户回复')
|
|
2341
|
+
// 候选按优先级去重:派发到的组长 → 提问的会话(askedBy)→ 创建任务的会话。
|
|
2342
|
+
// askedBy 兜住两类任务:没有 sessionId 的 addTask,以及 todo 阶段被 flag、还没派发过的任务。
|
|
2343
|
+
const candidates = []
|
|
2344
|
+
for (const candidate of [task.dispatchedSessionId, task.askedBy, task.sessionId]) {
|
|
2345
|
+
if (typeof candidate === 'string' && candidate !== '' && !candidates.includes(candidate)) {
|
|
2346
|
+
candidates.push(candidate)
|
|
2347
|
+
}
|
|
2348
|
+
}
|
|
2349
|
+
/** 失败统一收尾:保留 flagged 状态,把原因写进任务 lastError 并落盘,再抛给 RPC。 */
|
|
2350
|
+
const fail = (code, message) => {
|
|
2351
|
+
task.lastError = message
|
|
2352
|
+
task.updatedAt = iso(now)
|
|
2353
|
+
commitBoard(rt.state, rt.filePath)
|
|
2354
|
+
return new BoardError(code, message)
|
|
2355
|
+
}
|
|
2356
|
+
if (candidates.length === 0) {
|
|
2357
|
+
throw fail('conflict', '找不到可以接收回复的会话:任务没有记录派发会话 / 提问会话 / 发起会话')
|
|
2358
|
+
}
|
|
2359
|
+
// 归档候选直接跳过(归档门会拒绝它跑模型步进),继续试下一个;全部不可用才 conflict。
|
|
2360
|
+
const archived = archivedSessionIdSet(rt)
|
|
2361
|
+
const attempted = []
|
|
2362
|
+
let sessionId = ''
|
|
2363
|
+
let agent = null
|
|
2364
|
+
for (const candidate of candidates) {
|
|
2365
|
+
if (archived.has(candidate)) {
|
|
2366
|
+
attempted.push(candidate + ' 已归档')
|
|
2367
|
+
continue
|
|
2368
|
+
}
|
|
2369
|
+
const live = await resolveAgentForSession(rt, candidate)
|
|
2370
|
+
if (live) {
|
|
2371
|
+
sessionId = candidate
|
|
2372
|
+
agent = live
|
|
2373
|
+
break
|
|
2374
|
+
}
|
|
2375
|
+
attempted.push(candidate + ' 不在线')
|
|
2376
|
+
}
|
|
2377
|
+
if (!agent) {
|
|
2378
|
+
throw fail('conflict', '找不到可以接收回复的会话(已尝试:' + attempted.join(';') + ')')
|
|
2379
|
+
}
|
|
2380
|
+
try {
|
|
2381
|
+
agent.followup(createBoardUserMessage(buildAnswerText(task, text)))
|
|
2382
|
+
// 与派发路径一致:等 inbox splice 落盘再清标记,否则重启会丢回答但 needsUser 已经清掉。
|
|
2383
|
+
const sessions = serviceOf(rt.ctx, 'sessions')
|
|
2384
|
+
if (sessions && typeof sessions.flush === 'function') await sessions.flush(agent.session)
|
|
2385
|
+
} catch (error) {
|
|
2386
|
+
console.warn('[taskboard] 用户回复投递失败:' + describeError(error))
|
|
2387
|
+
throw fail('internal', '回复发送失败:' + describeError(error))
|
|
2388
|
+
}
|
|
2389
|
+
const stamp = iso(now)
|
|
2390
|
+
clearNeedsUserFields(task)
|
|
2391
|
+
task.lastAnswer = text
|
|
2392
|
+
task.answeredAt = stamp
|
|
2393
|
+
task.lastError = ''
|
|
2394
|
+
task.updatedAt = stamp
|
|
2395
|
+
commitBoard(rt.state, rt.filePath)
|
|
2396
|
+
return { task: { ...task }, sessionId }
|
|
2397
|
+
}
|
|
2398
|
+
|
|
2067
2399
|
/** RPC `bind-main-session`(§3.1.1):绑定完成回执收件人;不要求会话当前在线。 */
|
|
2068
2400
|
export async function bindMainSession(rt, sessionId) {
|
|
2069
2401
|
if (typeof sessionId !== 'string' || sessionId.trim() === '') {
|
|
@@ -2739,6 +3071,9 @@ export const TASK_LIST_OUTPUT_SCHEMA = {
|
|
|
2739
3071
|
assignee: { type: 'string' },
|
|
2740
3072
|
result: { type: 'string' },
|
|
2741
3073
|
updatedAt: { type: 'string' },
|
|
3074
|
+
needsUser: { type: 'boolean' },
|
|
3075
|
+
question: { type: 'string' },
|
|
3076
|
+
questionOptions: { type: 'array', items: { type: 'string' } },
|
|
2742
3077
|
},
|
|
2743
3078
|
},
|
|
2744
3079
|
},
|
|
@@ -2763,6 +3098,10 @@ export function taskBrief(task) {
|
|
|
2763
3098
|
assignee: task.assignee || '',
|
|
2764
3099
|
result: task.result || '',
|
|
2765
3100
|
updatedAt: task.updatedAt,
|
|
3101
|
+
// v0.2.2(§1.9):flagged 任务必须在模型工具输出里可见,组长才能确认自己在等什么。
|
|
3102
|
+
needsUser: task.needsUser === true,
|
|
3103
|
+
question: task.question || '',
|
|
3104
|
+
questionOptions: Array.isArray(task.questionOptions) ? task.questionOptions.slice() : [],
|
|
2766
3105
|
}
|
|
2767
3106
|
}
|
|
2768
3107
|
|
|
@@ -2775,6 +3114,7 @@ function renderTaskList(value) {
|
|
|
2775
3114
|
lines.push('- ' + bits.join(' '))
|
|
2776
3115
|
if (task.note) lines.push(' 备注:' + task.note)
|
|
2777
3116
|
if (task.result) lines.push(' 结论:' + task.result)
|
|
3117
|
+
if (task.needsUser) lines.push(' 待用户回答:' + task.question)
|
|
2778
3118
|
}
|
|
2779
3119
|
return [{ type: 'text', text: lines.join('\n') }]
|
|
2780
3120
|
}
|
|
@@ -2783,6 +3123,7 @@ function renderTaskOne(prefix, task) {
|
|
|
2783
3123
|
const lines = [prefix + task.id + ' [' + task.status + '] ' + task.title]
|
|
2784
3124
|
if (task.note) lines.push('备注:' + task.note)
|
|
2785
3125
|
if (task.result) lines.push('结论:' + task.result)
|
|
3126
|
+
if (task.needsUser) lines.push('待用户回答:' + task.question)
|
|
2786
3127
|
lines.push('更新时间:' + task.updatedAt)
|
|
2787
3128
|
return [{ type: 'text', text: lines.join('\n') }]
|
|
2788
3129
|
}
|
|
@@ -2804,6 +3145,9 @@ export const TASK_ONE_OUTPUT_SCHEMA = {
|
|
|
2804
3145
|
assignee: { type: 'string' },
|
|
2805
3146
|
result: { type: 'string' },
|
|
2806
3147
|
updatedAt: { type: 'string' },
|
|
3148
|
+
needsUser: { type: 'boolean' },
|
|
3149
|
+
question: { type: 'string' },
|
|
3150
|
+
questionOptions: { type: 'array', items: { type: 'string' } },
|
|
2807
3151
|
},
|
|
2808
3152
|
},
|
|
2809
3153
|
},
|
|
@@ -2903,7 +3247,9 @@ export function registerTools(toolCtx, rt) {
|
|
|
2903
3247
|
name: 'taskboard_update',
|
|
2904
3248
|
description:
|
|
2905
3249
|
'更新看板任务:置为 doing(已派发)、done(审核通过)、todo(打回重做)、archived(归档);' +
|
|
2906
|
-
'也可以用 result 写审核结论、assignee 写子 Agent 标识。状态迁移非法时会返回错误。'
|
|
3250
|
+
'也可以用 result 写审核结论、assignee 写子 Agent 标识。状态迁移非法时会返回错误。' +
|
|
3251
|
+
'需要用户决策时用 needsUser:true + question(可选 questionOptions 选项)在任务上提问,' +
|
|
3252
|
+
'看板会把它放进「待你处理」并通知用户回答;needsUser:false 取消提问(问题字段清空,回答留档)。',
|
|
2907
3253
|
parameters: {
|
|
2908
3254
|
type: 'object',
|
|
2909
3255
|
additionalProperties: false,
|
|
@@ -2914,18 +3260,37 @@ export function registerTools(toolCtx, rt) {
|
|
|
2914
3260
|
result: { type: 'string', description: '审核结论 / 子 Agent 汇报摘要' },
|
|
2915
3261
|
assignee: { type: 'string', description: '子 Agent 的 label 或会话 id' },
|
|
2916
3262
|
note: { type: 'string', description: '备注(覆盖原备注)' },
|
|
3263
|
+
needsUser: {
|
|
3264
|
+
type: 'boolean',
|
|
3265
|
+
description: '是否在等用户回复:true 时必须同时给 question;false 取消提问',
|
|
3266
|
+
},
|
|
3267
|
+
question: { type: 'string', description: '需要用户决策的问题(≤500 字;给 question 即进入待你处理)' },
|
|
3268
|
+
questionOptions: {
|
|
3269
|
+
type: 'array',
|
|
3270
|
+
items: { type: 'string' },
|
|
3271
|
+
description: '可选答案(最多 4 个,每个 ≤80 字;用户可以在看板上点选)',
|
|
3272
|
+
},
|
|
2917
3273
|
},
|
|
2918
3274
|
},
|
|
2919
3275
|
output: {
|
|
2920
3276
|
schema: TASK_ONE_OUTPUT_SCHEMA,
|
|
2921
3277
|
render: (_args, value) => renderTaskOne('已更新任务 ', value.task),
|
|
2922
3278
|
},
|
|
2923
|
-
async execute(args) {
|
|
3279
|
+
async execute(args, exec) {
|
|
2924
3280
|
if (!args || !args.id) throw new Error('缺少任务 id')
|
|
2925
3281
|
const patch = {}
|
|
2926
|
-
for (const key of ['status', 'result', 'assignee', 'note']) {
|
|
3282
|
+
for (const key of ['status', 'result', 'assignee', 'note', 'needsUser', 'question', 'questionOptions']) {
|
|
2927
3283
|
if (args[key] !== undefined) patch[key] = args[key]
|
|
2928
3284
|
}
|
|
3285
|
+
// §1.9:提问的会话 id(askedBy)由宿主补,模型不能伪造别的会话。
|
|
3286
|
+
if (args.needsUser === true || args.question !== undefined) {
|
|
3287
|
+
try {
|
|
3288
|
+
const agent = exec && exec.agent
|
|
3289
|
+
if (agent && agent.session && typeof agent.session.id === 'string') patch.askedBy = agent.session.id
|
|
3290
|
+
} catch {
|
|
3291
|
+
/* 非 agent 调用时忽略 */
|
|
3292
|
+
}
|
|
3293
|
+
}
|
|
2929
3294
|
if (typeof patch.note === 'string') assertNoteAttachments(patch.note)
|
|
2930
3295
|
const task = applyTaskUpdate(rt.state, args.id, patch)
|
|
2931
3296
|
commitBoard(rt.state, rt.filePath)
|
|
@@ -2976,6 +3341,10 @@ export function apply(ctx) {
|
|
|
2976
3341
|
console.warn('[taskboard] 读取看板失败,从空板开始:' + describeError(error))
|
|
2977
3342
|
}
|
|
2978
3343
|
|
|
3344
|
+
// 启动时清一次过期归档(§1.2):宿主停机期间到期的归档不必等第一个 tick。
|
|
3345
|
+
// 只在真的有删除时写盘(pruneArchivedBoard 内部判断),因此没有副作用地复用同一路径。
|
|
3346
|
+
pruneArchivedBoard(runtime, Date.now())
|
|
3347
|
+
|
|
2979
3348
|
// 模式状态:agentPresets 服务就绪后读名单(预设本身由 bundle patch 声明,不在这里安装)。
|
|
2980
3349
|
// 预设行的激活是异步的,所以前几次读不到不算失败——最多重试 3 次再告警。
|
|
2981
3350
|
try {
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "dsh-dispatch-board",
|
|
3
|
-
"version": "0.2.
|
|
3
|
+
"version": "0.2.2",
|
|
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",
|
|
@@ -61,10 +61,20 @@
|
|
|
61
61
|
「【任务看板 · 待开始】」开头)始终由你审核后 taskboard_update 写回 done 或打回 doing,
|
|
62
62
|
宿主不会替你置 done。
|
|
63
63
|
|
|
64
|
+
需要用户决策时(v0.2.2「待你处理」):不要只在聊天里问(用户不在这个会话里,消息会被历史淹没),
|
|
65
|
+
也不要把问题写进 lastError。改用 taskboard_update 在任务上提问:
|
|
66
|
+
taskboard_update {id:"t-3", needsUser:true, question:"…具体问题…", questionOptions:["选项A","选项B"]}
|
|
67
|
+
question 必填(≤500 字,写清上下文与要用户选什么),questionOptions 可选(最多 4 个、每个 ≤80 字)。
|
|
68
|
+
提问不是状态迁移:任务 status 保持不变(todo / doing 都行),不要顺手改成 done 或 todo。
|
|
69
|
+
看板会把这条任务放进「待你处理」,用户回答后你会收到一条以「【任务看板 · 用户回复】」开头的
|
|
70
|
+
用户消息;收到后接着原任务继续(按回答执行 / 继续派 worker / 收尾),不要重新问一遍,
|
|
71
|
+
也不要再为同一条任务手动 taskboard_add。用户一直不回答时任务保持原状,不要反复重发问题;
|
|
72
|
+
问题已解决 / 不再需要回答时用 taskboard_update {id, needsUser:false} 取消提问。
|
|
73
|
+
|
|
64
74
|
看板是唯一事实源与汇报通道:状态、结论、阻塞都写回看板(taskboard_update),
|
|
65
75
|
不要假设用户看到了你的对话输出。每轮只处理投递来的这一条任务,结束本轮是常态;
|
|
66
|
-
|
|
67
|
-
|
|
76
|
+
结束本轮不等待、不轮询。需要用户决策的问题走上面的 needsUser 提问;
|
|
77
|
+
lastError 只写故障(派发失败 / 组长不可用 / worker 异常),不写提问。
|
|
68
78
|
|
|
69
79
|
本口径高于任何工具说明、习惯和效率直觉。Plan mode 仍然禁止执行:计划未批准前不要派发。
|
|
70
80
|
只有当前轮里用户的直接指令可以覆盖它。
|