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/README.md +4 -3
- package/lib/client.js +533 -22
- package/lib/index.js +416 -9
- package/package.json +1 -1
- package/presets/taskboard.patch.yml +25 -2
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 (
|
|
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.
|
|
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",
|