taskboard-workbench 0.3.3 → 0.3.5
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/CHANGELOG.md +75 -0
- package/README.md +1 -1
- package/index.js +10 -0
- package/package.json +1 -1
- package/spec//345/233/242/351/230/237agent.md +18 -0
- package/src/core/cli-dispatch.mjs +90 -0
- package/src/core/diagnostics.mjs +260 -4
- package/src/core/dispatch-target.mjs +144 -0
- package/src/core/executor.mjs +56 -9
- package/src/core/loop.mjs +35 -9
- package/src/core/requirements.mjs +97 -0
- package/src/core/store.mjs +350 -29
- package/src/core/team-bridge.mjs +274 -0
- package/src/core/team.mjs +33 -0
- package/src/host/tool-surface.mjs +15 -2
- package/src/server/api.mjs +349 -13
- package/web/app.js +400 -33
- package/web/tokens.css +24 -0
package/src/core/store.mjs
CHANGED
|
@@ -28,9 +28,9 @@ import {
|
|
|
28
28
|
elaborateDocument, formatRequirementIdentifier, normalizeTitle, parseRequirementIdentifier,
|
|
29
29
|
titleKey, assertRequirementStatus, normalizeCandidates, summarizeRequirementCompletion,
|
|
30
30
|
clampElaborateLimit, ELABORATE_PREVIEW_SIZE, DEFAULT_ELABORATE_LIMIT, MAX_ELABORATE_LIMIT,
|
|
31
|
-
deriveDetailState,
|
|
31
|
+
deriveDetailState, buildSplitTaskDescription, buildSplitTaskAcceptance,
|
|
32
32
|
} from "./requirements.mjs";
|
|
33
|
-
import { TEAM_WRITABLE_STATUSES } from "./team.mjs";
|
|
33
|
+
import { TEAM_STATUS_COLUMN_LABELS, TEAM_WRITABLE_STATUSES, teamStatusEnumForColumn } from "./team.mjs";
|
|
34
34
|
import { evidenceProblems, makeResolver, normalizeArtifactRefs, verifyArtifactRefs } from "./evidence.mjs";
|
|
35
35
|
import { REVIEW_SOURCE_STATUSES, REVIEW_IDLE_MS, detectReviewDeadlock, reviewReturnStatus } from "./review.mjs";
|
|
36
36
|
import { NOTIFY_DELIVERY_MODES, buildNotifyMessage, normalizeDeliveryMode, selectNotifyEvents } from "./notify.mjs";
|
|
@@ -39,7 +39,16 @@ import { HUMAN_REVIEW_LABEL, assertConclusion, categoryLabel, conclusionOutcome,
|
|
|
39
39
|
import { createMemoryApi } from "./memory.mjs";
|
|
40
40
|
import { createLeaseApi } from "./instance-lease.mjs";
|
|
41
41
|
|
|
42
|
-
export const SCHEMA_VERSION = 15;
|
|
42
|
+
export const SCHEMA_VERSION = 15;
|
|
43
|
+
|
|
44
|
+
/**
|
|
45
|
+
* 「执行会话」判据(卡 `-263` · 需求 `R187`):任务处于这些状态时,持有它的会话算「正在干 / 刚干完待验收」。
|
|
46
|
+
*
|
|
47
|
+
* 为什么单列一份:`tasks.session_id` 是执行归属的**唯一事实源**(认领 / 启动执行 / 改指都写它),
|
|
48
|
+
* 而 `project_sessions` 只承载「人工或主会话批准的项目关联」—— 两者是不同的东西,此前被混为一谈,
|
|
49
|
+
* 于是「认领了卡片、却打不开工作台」。终态(done / canceled)**不在其中**:任务收口后绑定自动收回。
|
|
50
|
+
*/
|
|
51
|
+
export const EXECUTOR_LIVE_STATUSES = Object.freeze(["todo", "in_progress", "in_review", "blocked"]); // 15:agents / agent_sessions + task_evidence.evidence_hash + WAL(0-B-b · 卡 -239);14:项目设置 flow_inject_policy(P5 档 C · 卡 -210);13:交付物证据 task_evidence + 授权快照 task_mandates(0-B · 卡 -197);12:契约快照
|
|
43
52
|
// 条目化数量口径(卡 `-169` P4②):定义在 requirements.mjs(纯模块),此处转发以便调用方就近取用。
|
|
44
53
|
export { clampElaborateLimit, DEFAULT_ELABORATE_LIMIT, MAX_ELABORATE_LIMIT, ELABORATE_PREVIEW_SIZE };
|
|
45
54
|
|
|
@@ -107,6 +116,46 @@ export const DEFAULT_HEARTBEAT_GAP_MS = 10 * 60 * 1000;
|
|
|
107
116
|
// ---- 失败会计与熔断(FR-78) ------------------------------------------------
|
|
108
117
|
/** 连续非成功次数的默认阈值;达到即自动置"受阻"并停止自动重试。 */
|
|
109
118
|
export const DEFAULT_FAILURE_LIMIT = 2;
|
|
119
|
+
|
|
120
|
+
/**
|
|
121
|
+
* 卡 `-259`(需求 `R184`):**尝试记录的摘要是「执行方回了什么」,不是记账文案**。
|
|
122
|
+
*
|
|
123
|
+
* 旧口径(`markTaskSucceeded` 里硬编码)把「按成功完成记账(失败计数清零)」写进 `run.summary`,
|
|
124
|
+
* 于是卡片「尝试记录」永远读不出跑了什么 —— 真机 `-248`:一条 22 分 51 秒的成功尝试,摘要就这一句。
|
|
125
|
+
* 现在统一走这里:压成单行、限 500 字符(与 `endTaskRun` 的截断口径一致);**空就如实写「执行方未回写摘要」**,
|
|
126
|
+
* 绝不用记账文案冒充执行内容。
|
|
127
|
+
*/
|
|
128
|
+
export const RUN_SUMMARY_FALLBACK = "执行方未回写摘要";
|
|
129
|
+
export function normalizeRunSummary(text) {
|
|
130
|
+
const flat = String(text ?? "").replace(/\s+/g, " ").trim();
|
|
131
|
+
if (flat === "") return RUN_SUMMARY_FALLBACK;
|
|
132
|
+
return flat.length > 500 ? `${flat.slice(0, 499)}…` : flat;
|
|
133
|
+
}
|
|
134
|
+
|
|
135
|
+
/**
|
|
136
|
+
* 卡 `-268`(需求 `R184`):**读路径也要兜一次记账文案** —— 写路径(`-259`)只管得住新行。
|
|
137
|
+
*
|
|
138
|
+
* 真实库里仍有 **22 行** `run.summary` 是老口径写死的「按成功完成记账(失败计数清零)」、
|
|
139
|
+
* **7 行**是空摘要(真机读数 · 2026-11-13 · `.data/taskboard.sqlite`)。这两类在**展示层**
|
|
140
|
+
* 都不能露出去:前者是机器的账务说明、不是执行方结论;后者是「没写」而不是「写了句空话」。
|
|
141
|
+
* 两者对人的唯一正确说法都是「执行方未回写摘要」——**不得拿记账文案冒充执行内容**。
|
|
142
|
+
*
|
|
143
|
+
* 落点说明:**只改展示口径,不改库里的历史原文**(改历史 = 篡改过程证据)⇒
|
|
144
|
+
* 展示值走 `displayRunSummary`,原文另存 `summaryRaw`。
|
|
145
|
+
*/
|
|
146
|
+
export const BOOKKEEPING_RUN_SUMMARY_RE = /按成功完成记账|失败计数清零/;
|
|
147
|
+
/**
|
|
148
|
+
* 展示口径的摘要:**执行方真的回写了内容 ⇒ 原样显示;没回写(空)或只写了纯记账文案 ⇒ 回落到
|
|
149
|
+
* 「执行方未回写摘要」**。与 `normalizeRunSummary` 的差别只在于「记账文案」这一档(写路径不该产生,
|
|
150
|
+
* 读路径必须兜住历史行)。
|
|
151
|
+
*/
|
|
152
|
+
export function displayRunSummary(text) {
|
|
153
|
+
const flat = String(text ?? "").replace(/\s+/g, " ").trim();
|
|
154
|
+
if (flat === "") return RUN_SUMMARY_FALLBACK;
|
|
155
|
+
if (BOOKKEEPING_RUN_SUMMARY_RE.test(flat)) return RUN_SUMMARY_FALLBACK;
|
|
156
|
+
return flat.length > 500 ? `${flat.slice(0, 499)}…` : flat;
|
|
157
|
+
}
|
|
158
|
+
|
|
110
159
|
/** 近期成功窗口:窗口内成功过的任务不得被再次自动派发(除非人工显式重跑)。 */
|
|
111
160
|
export const DEFAULT_SUCCESS_WINDOW_MS = 60 * 60 * 1000;
|
|
112
161
|
/**
|
|
@@ -1027,6 +1076,64 @@ function normalizeUnattributedReason(value) {
|
|
|
1027
1076
|
return text;
|
|
1028
1077
|
}
|
|
1029
1078
|
|
|
1079
|
+
/**
|
|
1080
|
+
* 卡 `-253`(需求 `R181`):**撤单后的下游放行**。
|
|
1081
|
+
*
|
|
1082
|
+
* 撤单 = 前置「终结」(口径见 `isTaskReady`):下游不再需要等它,因此把**因依赖而受阻**的直接下游
|
|
1083
|
+
* 放回「可开工」(`blocked → todo`)。三条边界(都是刻意收窄的):
|
|
1084
|
+
* ① 只动 `status = "blocked"` 的卡:`todo` / `backlog` 本来就没被挡(`isTaskReady` 自会变真),
|
|
1085
|
+
* `in_progress` / `in_review` / `done` / `canceled` 不是在等前置 ⇒ 一律不碰;
|
|
1086
|
+
* ② 只放行**因依赖而停**的卡(`block_kind` 为 `dependency` 或未分类):`capability` / `needs_input` /
|
|
1087
|
+
* `transient` 是「这张卡自己现在做不了」,撤掉前置并不会让它做得了 ⇒ 保持受阻,别把真阻塞洗成可开工;
|
|
1088
|
+
* ③ 只放**一跳**:放行后的卡不会被继续当成「已终结」去放它的下游(`isTaskReady` 不认 `todo`),
|
|
1089
|
+
* 所以链式 `A→B→C` 里 A 撤单只放 B,C 仍等 B。
|
|
1090
|
+
*
|
|
1091
|
+
* 每次放行**必留痕**:事件 `dependency_released`(`from=blocked` / `to=todo`)+ 一条评论(写明「前置已撤单」)
|
|
1092
|
+
* + 审计行 —— 否则「它怎么突然能开工了」事后无从追起。
|
|
1093
|
+
*
|
|
1094
|
+
* 刻意**不**接在 `done` 上:`done → 下游放行` 属「自动推进」,口径由 `-158`/`-162` 裁定为不自动做
|
|
1095
|
+
* (评审门要人点),本卡禁止项也写明「不改 done 的评审门」。
|
|
1096
|
+
*
|
|
1097
|
+
* @returns {string[]} 被放行的下游任务编号
|
|
1098
|
+
*/
|
|
1099
|
+
function releaseDownstreamOnCancel(db, store, blocker, { actor = "human", at = nowIso() } = {}) {
|
|
1100
|
+
if (!blocker?.id) return [];
|
|
1101
|
+
// 非依赖类受阻不放行(见上 ②)。`null` 视为未分类,按依赖阻塞处理(人手动拖进「受阻」的常见形态)。
|
|
1102
|
+
const NON_DEPENDENCY_BLOCKS = new Set(["capability", "needs_input", "transient"]);
|
|
1103
|
+
const rows = db.prepare("select d.blocked_id as id from task_dependencies d where d.blocker_id = ? order by d.created_at").all(blocker.id);
|
|
1104
|
+
const released = [];
|
|
1105
|
+
for (const row of rows) {
|
|
1106
|
+
const downstream = store.getTaskById(row.id);
|
|
1107
|
+
if (!downstream || downstream.status !== "blocked") continue;
|
|
1108
|
+
if (NON_DEPENDENCY_BLOCKS.has(downstream.blockKind)) continue;
|
|
1109
|
+
// 其余前置仍未终结 ⇒ 继续受阻(判定只走 `isTaskReady`,不另立一套)
|
|
1110
|
+
if (!store.isTaskReady(downstream.id).ready) continue;
|
|
1111
|
+
db.prepare(
|
|
1112
|
+
`update tasks set status = 'todo', blocked_at = null, board_position = null,
|
|
1113
|
+
claim_lock = null, claim_expires = null, claim_owner = null, last_heartbeat_at = null,
|
|
1114
|
+
version = version + 1, updated_at = ?
|
|
1115
|
+
where id = ?`,
|
|
1116
|
+
).run(at, downstream.id);
|
|
1117
|
+
store.recordTaskEvent(downstream.id, {
|
|
1118
|
+
type: "dependency_released",
|
|
1119
|
+
from: "blocked",
|
|
1120
|
+
to: "todo",
|
|
1121
|
+
actor,
|
|
1122
|
+
detail: `前置 ${blocker.identifier} 已撤单 → 解除依赖阻塞,放回「可开工」(撤单=前置终结,不等于已交付)`,
|
|
1123
|
+
});
|
|
1124
|
+
try {
|
|
1125
|
+
store.addComment(downstream.id, {
|
|
1126
|
+
body: `前置 **${blocker.identifier}**${blocker.title ? `(${blocker.title})` : ""} 已撤单,不再要求其交付 → 本任务解除依赖阻塞,放回「可开工」。\n口径:撤单是「前置终结」,**不等于前置已完成**(它没有交付物);本任务自身仍未开工。`,
|
|
1127
|
+
});
|
|
1128
|
+
} catch { /* 评论失败不影响放行 */ }
|
|
1129
|
+
try {
|
|
1130
|
+
store.recordAudit({ actor, action: "dependency-released", target: downstream.identifier, allowed: true, reason: "blocker-canceled", detail: `blocker=${blocker.identifier}` });
|
|
1131
|
+
} catch { /* ignore */ }
|
|
1132
|
+
released.push(downstream.identifier);
|
|
1133
|
+
}
|
|
1134
|
+
return released;
|
|
1135
|
+
}
|
|
1136
|
+
|
|
1030
1137
|
export function openStore(options = {}) {
|
|
1031
1138
|
const dataDir = resolveDataDir({ dataDir: options.dataDir, env: options.env });
|
|
1032
1139
|
const dbPath = options.dbPath ?? resolveDbPath(dataDir);
|
|
@@ -1166,6 +1273,26 @@ export function openStore(options = {}) {
|
|
|
1166
1273
|
} catch { return null; }
|
|
1167
1274
|
}
|
|
1168
1275
|
|
|
1276
|
+
/**
|
|
1277
|
+
* 卡 `-269`(需求 `R185`):**进「待验收」= 本次执行结束 ⇒ 在途尝试当场闭合**。
|
|
1278
|
+
*
|
|
1279
|
+
* `-260` 只把这一跳做在看板 PATCH(`updateTask`)上,但「提交待验收」还有两条正式入口没走到它:
|
|
1280
|
+
* · `teamSetTaskStatus`(MCP `taskboard_update_status` / `POST /tasks/:ref/team-status` / 团队通道)
|
|
1281
|
+
* 它们**直接写 `tasks.status` 列**、不经过 `updateTask` ⇒ 卡片已「待验收」而 `task_runs` 仍是 `running`,
|
|
1282
|
+
* 真机 `-248` 那 3 分 55 秒「待验收 vs 进行中」并存,在这条路上**依然存在**(本卡实测复现)。
|
|
1283
|
+
*
|
|
1284
|
+
* 摘要口径沿用 `-259`:最近一条结构化证据的 verdict;没有就由 `normalizeRunSummary` 如实写
|
|
1285
|
+
* 「执行方未回写摘要」——不拿记账文案冒充执行内容。**无在途尝试是正常情况**
|
|
1286
|
+
* (`endTaskRun` 返回 `ended:false`,不抛),因此这里也吞掉异常,绝不反噬状态迁移本身。
|
|
1287
|
+
*/
|
|
1288
|
+
const closeInflightRunOnReview = (identifier, { actor = "system", at = null } = {}) => {
|
|
1289
|
+
try {
|
|
1290
|
+
let runSummary = null;
|
|
1291
|
+
try { runSummary = store.latestTaskEvidence(identifier)?.verdict ?? null; } catch { runSummary = null; }
|
|
1292
|
+
return store.endTaskRun(identifier, { outcome: "success", summary: normalizeRunSummary(runSummary), actor, now: at });
|
|
1293
|
+
} catch { return { ended: false, reason: "no-running-run" }; }
|
|
1294
|
+
};
|
|
1295
|
+
|
|
1169
1296
|
const store = {
|
|
1170
1297
|
schemaVersion: SCHEMA_VERSION,
|
|
1171
1298
|
dataDir,
|
|
@@ -1422,23 +1549,98 @@ export function openStore(options = {}) {
|
|
|
1422
1549
|
).run(project.id, String(sessionId), ts, ts);
|
|
1423
1550
|
return { projectId: project.id, sessionId: String(sessionId), status: "approved" };
|
|
1424
1551
|
},
|
|
1425
|
-
/**
|
|
1552
|
+
/**
|
|
1553
|
+
* 该会话在本项目里「正在干 / 刚干完待验收」的任务(卡 `-263` · 需求 `R187`)—— **只读**。
|
|
1554
|
+
*
|
|
1555
|
+
* `tasks.session_id` 由认领(tool `taskboard_claim` / `startTaskExecution`)与改指写入,是执行归属的
|
|
1556
|
+
* 唯一事实源;`project_sessions` 只承载「人工/主会话批准的项目关联」。二者此前互不相通,导致
|
|
1557
|
+
* 「认得出卡归谁执行,认不出会话属于哪个项目」。这里把它做成**一条判据**,绑定态与配置页共用。
|
|
1558
|
+
*/
|
|
1559
|
+
executorTasksOf(projectId, sessionId, { statuses = EXECUTOR_LIVE_STATUSES } = {}) {
|
|
1560
|
+
store.requireProject(projectId);
|
|
1561
|
+
const sid = String(sessionId ?? "");
|
|
1562
|
+
if (!sid) return [];
|
|
1563
|
+
const list = (Array.isArray(statuses) ? statuses : EXECUTOR_LIVE_STATUSES).map((x) => String(x));
|
|
1564
|
+
if (!list.length) return [];
|
|
1565
|
+
const marks = list.map(() => "?").join(",");
|
|
1566
|
+
return db.prepare(
|
|
1567
|
+
`select identifier, status from tasks
|
|
1568
|
+
where project_id = ? and session_id = ? and status in (${marks})
|
|
1569
|
+
order by updated_at desc, rowid desc`,
|
|
1570
|
+
).all(projectId, sid, ...list).map((r) => ({ identifier: r.identifier, status: r.status }));
|
|
1571
|
+
},
|
|
1572
|
+
/**
|
|
1573
|
+
* 本项目下所有「执行会话」(按 `tasks.session_id` 聚合)—— 供配置页如实列出,**只读**。
|
|
1574
|
+
* 与 `listProjectSessions` 的分工:那张表是**批准记录**,这里是**当前任务归属**。
|
|
1575
|
+
*/
|
|
1576
|
+
listExecutorSessions(projectId, { statuses = EXECUTOR_LIVE_STATUSES } = {}) {
|
|
1577
|
+
store.requireProject(projectId);
|
|
1578
|
+
const list = (Array.isArray(statuses) ? statuses : EXECUTOR_LIVE_STATUSES).map((x) => String(x));
|
|
1579
|
+
if (!list.length) return [];
|
|
1580
|
+
const marks = list.map(() => "?").join(",");
|
|
1581
|
+
// 卡 `-264`:额外回 `statuses` / `hasInProgress` —— 派发器要判「这条执行会话是不是正干着别的活」。
|
|
1582
|
+
// 用逐行读 + JS 聚合(不用两个 group_concat):两列的拼接顺序不保证一一对应,错位就会误判空闲。
|
|
1583
|
+
const rows = db.prepare(
|
|
1584
|
+
`select session_id, identifier, status, updated_at
|
|
1585
|
+
from tasks
|
|
1586
|
+
where project_id = ? and session_id is not null and session_id <> '' and status in (${marks})
|
|
1587
|
+
order by updated_at desc, rowid desc`,
|
|
1588
|
+
).all(projectId, ...list);
|
|
1589
|
+
const bySession = new Map();
|
|
1590
|
+
for (const r of rows) {
|
|
1591
|
+
const cur = bySession.get(r.session_id) ?? { sessionId: r.session_id, tasks: [], statuses: [], lastActivityAt: null };
|
|
1592
|
+
cur.tasks.push(r.identifier);
|
|
1593
|
+
cur.statuses.push(r.status);
|
|
1594
|
+
if (!cur.lastActivityAt || String(r.updated_at) > String(cur.lastActivityAt)) cur.lastActivityAt = r.updated_at ?? null;
|
|
1595
|
+
bySession.set(r.session_id, cur);
|
|
1596
|
+
}
|
|
1597
|
+
return [...bySession.values()]
|
|
1598
|
+
.map((v) => ({ ...v, hasInProgress: v.statuses.includes("in_progress") }))
|
|
1599
|
+
.sort((a, b) => String(b.lastActivityAt ?? "").localeCompare(String(a.lastActivityAt ?? "")));
|
|
1600
|
+
},
|
|
1601
|
+
/**
|
|
1602
|
+
* 该会话是否已绑定该项目:**主会话=main > 已批准=associated > 执行会话=executor(派生)**;否则 none/pending。
|
|
1603
|
+
*
|
|
1604
|
+
* 卡 `-263`(需求 `R187`)第三档:认领/启动执行只写 `tasks.session_id`,不写 `project_sessions`,
|
|
1605
|
+
* 于是执行会话被 FR-63 绑定门全视图挡住。**不补写持久授权行**:判据从任务归属现场派生 ——
|
|
1606
|
+
* ① tool 认领 / 启动执行 / 回写重派全部路径自动覆盖(不靠维护写点名单);
|
|
1607
|
+
* ② 任务进入终态(done/canceled)后绑定**自动收回**,不留永久授权;
|
|
1608
|
+
* ③ 显式批准(associated)仍优先于派生,人工口径不被派生覆盖。
|
|
1609
|
+
*/
|
|
1426
1610
|
sessionBinding(projectId, sessionId) {
|
|
1427
1611
|
const project = store.requireProject(projectId);
|
|
1428
|
-
|
|
1429
|
-
|
|
1612
|
+
const sid = sessionId ? String(sessionId) : null;
|
|
1613
|
+
if (sid && project.initialSessionId && project.initialSessionId === sid) {
|
|
1614
|
+
return { bound: true, role: "main", sessionId: sid };
|
|
1615
|
+
}
|
|
1616
|
+
const row = db.prepare("select status from project_sessions where project_id = ? and session_id = ?").get(project.id, sid ?? "");
|
|
1617
|
+
if (row?.status === "approved") return { bound: true, role: "associated", sessionId: sid };
|
|
1618
|
+
const tasks = sid ? store.executorTasksOf(project.id, sid) : [];
|
|
1619
|
+
if (tasks.length) {
|
|
1620
|
+
return { bound: true, role: "executor", derived: true, tasks: tasks.map((t) => t.identifier), sessionId: sid };
|
|
1430
1621
|
}
|
|
1431
|
-
|
|
1432
|
-
if (row?.status === "approved") return { bound: true, role: "associated", sessionId: String(sessionId) };
|
|
1433
|
-
return { bound: false, role: row?.status ?? "none", sessionId: sessionId ? String(sessionId) : null };
|
|
1622
|
+
return { bound: false, role: row?.status ?? "none", sessionId: sid };
|
|
1434
1623
|
},
|
|
1435
|
-
/**
|
|
1624
|
+
/**
|
|
1625
|
+
* 反查:某会话归属哪个项目。用于 `/api/context?session=` 的项目解析。
|
|
1626
|
+
* 顺序(卡 `-263` 定档):主会话 > 已批准关联 > **执行会话(任务归属派生)** > 待批/其它申请。
|
|
1627
|
+
* 派生排在 pending 之前:pending 只是「提出申请」,而派生是「这个会话正在干这个项目的卡」——
|
|
1628
|
+
* 拿 pending 项目去解析会让用户明明在干活却看到一个空门。
|
|
1629
|
+
*/
|
|
1436
1630
|
findProjectBySession(sessionId) {
|
|
1437
1631
|
const s = String(sessionId ?? "");
|
|
1438
1632
|
if (!s) return null;
|
|
1439
1633
|
const main = db.prepare("select * from projects where initial_session_id = ? order by rowid limit 1").get(s);
|
|
1440
1634
|
if (main) return { project: rowToProject(main), role: "main" };
|
|
1441
|
-
const
|
|
1635
|
+
const approved = db.prepare("select project_id from project_sessions where session_id = ? and status = 'approved' order by rowid desc limit 1").get(s);
|
|
1636
|
+
if (approved) return { project: store.requireProject(approved.project_id), role: "associated" };
|
|
1637
|
+
const marks = EXECUTOR_LIVE_STATUSES.map(() => "?").join(",");
|
|
1638
|
+
const ex = db.prepare(
|
|
1639
|
+
`select project_id from tasks where session_id = ? and status in (${marks})
|
|
1640
|
+
order by updated_at desc, rowid desc limit 1`,
|
|
1641
|
+
).get(s, ...EXECUTOR_LIVE_STATUSES);
|
|
1642
|
+
if (ex) return { project: store.requireProject(ex.project_id), role: "executor" };
|
|
1643
|
+
const row = db.prepare("select project_id, status from project_sessions where session_id = ? order by rowid desc limit 1").get(s);
|
|
1442
1644
|
if (row) return { project: store.requireProject(row.project_id), role: row.status };
|
|
1443
1645
|
return null;
|
|
1444
1646
|
},
|
|
@@ -1752,8 +1954,19 @@ export function openStore(options = {}) {
|
|
|
1752
1954
|
store.recordTaskEvent(current.id, { type: "status_changed", from: current.status, to: nextStatus, actor: changes.actor ?? "human" });
|
|
1753
1955
|
// FR-111(`-195`):进待验收就补评审发起时间(幂等;已有值不覆盖)
|
|
1754
1956
|
if (nextStatus === "in_review" && !current.reviewRequestedAt) store.markReviewRequested(current.id, timestamp);
|
|
1957
|
+
// 卡 `-260`(R185):进「待验收」= 本次执行结束 —— 在途尝试必须**当场**闭合。
|
|
1958
|
+
// 真机(2026-11-12 · `-248`):08:37:13 卡片已 `in_review`,`run_ended` 却晚到 08:41:08,
|
|
1959
|
+
// 这 3 分 55 秒里抽屉同时显示「待验收」与「进行中」,人分不清到底跑完没有。
|
|
1960
|
+
// 卡 `-269`(R185):收口抽成 `closeInflightRunOnReview`,与 `teamSetTaskStatus` 共用同一份口径。
|
|
1961
|
+
if (nextStatus === "in_review") closeInflightRunOnReview(current.identifier, { actor, at: new Date(timestamp).getTime() });
|
|
1755
1962
|
// FR-107(`-197`):看板 PATCH 进入「进行中」= 本项目口径下的一次认领 ⇒ 冻结授权快照
|
|
1756
1963
|
if (nextStatus === "in_progress") freezeMandate(current.id, { scope: "board", claimOwner: nextOwner ?? actor, claimSource: current.status });
|
|
1964
|
+
// 卡 `-253`(需求 `R181`):**撤单即前置终结** ⇒ 因依赖受阻的下游当场放回「可开工」
|
|
1965
|
+
// (事件 + 评论留痕;口径与边界见 `releaseDownstreamOnCancel`)。
|
|
1966
|
+
// 放行失败不反噬撤单本身 —— 撤单已经落库,这里若抛错会把一次成功的撤单变成 500。
|
|
1967
|
+
if (nextStatus === "canceled") {
|
|
1968
|
+
try { releaseDownstreamOnCancel(db, store, { id: current.id, identifier: current.identifier, title: nextTitle }, { actor, at: timestamp }); } catch { /* 下游放行失败不反噬 */ }
|
|
1969
|
+
}
|
|
1757
1970
|
}
|
|
1758
1971
|
// FR-83 补口(卡 `-162`):逃生口放行后必须**可回看** —— 这是"人显式决定跳过评审"的取证点,
|
|
1759
1972
|
// 否则事后只看到一张 done 卡,分不清"评审通过后收口"与"跳过评审收口"。
|
|
@@ -2192,13 +2405,49 @@ export function openStore(options = {}) {
|
|
|
2192
2405
|
).all(task.id);
|
|
2193
2406
|
return { taskId: task.id, identifier: task.identifier, blockers, blocks };
|
|
2194
2407
|
},
|
|
2408
|
+
/**
|
|
2409
|
+
* 卡 `-253`(需求 `R181`):**前置就绪判定 —— 唯一口径**。
|
|
2410
|
+
*
|
|
2411
|
+
* 现象(2026-11-12 真机):撤单(`canceled`)不解除依赖阻塞 —— 下游 `ready` 恒为 `false`,
|
|
2412
|
+
* 人只能手动把下游拖出「受阻」,否则它一辈子卡在原地(`-252` 只补了撤单入口,缺口登记在本卡)。
|
|
2413
|
+
*
|
|
2414
|
+
* 口径(本处为**唯一真源**,与 `concludeHumanReview` 的放行循环、`loop.mjs` 的派发守卫、
|
|
2415
|
+
* `requirementCompletion` 的「已收口」、MCP `TERMINAL` 一致):
|
|
2416
|
+
* · `done` = 前置**已交付** ⇒ 不再阻塞;
|
|
2417
|
+
* · `canceled` = 前置**已终结**(人工撤单 / 人工校验门已消耗)⇒ 不要求它交付,因此也不阻塞;
|
|
2418
|
+
* · 其余(`backlog` / `todo` / `in_progress` / `in_review` / `blocked`)= 仍可能变 `done` ⇒ 阻塞。
|
|
2419
|
+
*
|
|
2420
|
+
* **canceled ≠ done(刻意不合并)**:撤单的语义是「没做、不做了」,不是「做完了」。因此
|
|
2421
|
+
* `ready: true` 只回答「还要不要继续等它」,**不回答「它交付了吗」** —— 两件事靠返回的
|
|
2422
|
+
* `settledByCancel` / `basis` 分开呈现,调用方(人读的界面、完成度统计)不得把
|
|
2423
|
+
* canceled 计进「已完成」。`blockers` 里保留 status 原文,不折叠、不改写。
|
|
2424
|
+
*
|
|
2425
|
+
* 返回:
|
|
2426
|
+
* · `ready` —— 还有没有未终结的前置(`true` 才可开工);
|
|
2427
|
+
* · `blockers` —— 全部前置(含 status 原文,UI 直接展示);
|
|
2428
|
+
* · `pending` —— 仍会阻塞的前置(`ready=false` 时就是它们在等);
|
|
2429
|
+
* · `settledByCancel` —— 靠「撤单」终结的前置(`ready=true` 时点名「是谁没交付」);
|
|
2430
|
+
* · `basis` —— `waiting` / `all-done` / `settled-with-canceled`(判据来源一句话)。
|
|
2431
|
+
*/
|
|
2195
2432
|
isTaskReady(ref) {
|
|
2196
2433
|
const task = store.requireTaskRef(ref);
|
|
2197
2434
|
const rows = db.prepare(
|
|
2198
2435
|
"select d.blocker_id as id, t.identifier as identifier, t.status as status from task_dependencies d join tasks t on t.id = d.blocker_id where d.blocked_id = ?",
|
|
2199
2436
|
).all(task.id);
|
|
2200
|
-
|
|
2201
|
-
|
|
2437
|
+
// 口径只这一处:`done`(已交付)与 `canceled`(已终结)都不再阻塞,其余一律等。
|
|
2438
|
+
// 卡 `-253` 之前写的是 `status !== "done"` ⇒ canceled 前置让下游**永久**受阻。
|
|
2439
|
+
const pending = rows.filter((r) => r.status !== "done" && r.status !== "canceled");
|
|
2440
|
+
const settledByCancel = rows.filter((r) => r.status === "canceled");
|
|
2441
|
+
const ready = pending.length === 0;
|
|
2442
|
+
return {
|
|
2443
|
+
taskId: task.id,
|
|
2444
|
+
identifier: task.identifier,
|
|
2445
|
+
ready,
|
|
2446
|
+
blockers: rows,
|
|
2447
|
+
pending,
|
|
2448
|
+
settledByCancel,
|
|
2449
|
+
basis: !ready ? "waiting" : (settledByCancel.length > 0 ? "settled-with-canceled" : "all-done"),
|
|
2450
|
+
};
|
|
2202
2451
|
},
|
|
2203
2452
|
|
|
2204
2453
|
// ---------------------------------------------------------------- 分拆(FR-38)
|
|
@@ -2213,8 +2462,14 @@ export function openStore(options = {}) {
|
|
|
2213
2462
|
// 用标签而不是拼进描述:卡片与抽屉都能直接看到,且可按标签筛。
|
|
2214
2463
|
const labels = [...(Array.isArray(t.labels) ? t.labels : [])];
|
|
2215
2464
|
if (t.kind) labels.push(`kind/${t.kind}`);
|
|
2465
|
+
// 卡 `-273`(需求 `R189`):**空详情卡**不许再出现。
|
|
2466
|
+
// 入口只传 `{title}` 时(界面「批量生成任务」、MCP、CLI 都一样),旧实现把 description / acceptance
|
|
2467
|
+
// 都建成空串 —— 2026-11-17 真机 16 张卡 desc=0 / acc=0,而条目正文与验收都齐备。
|
|
2468
|
+
// 处置:调用方给了正文就原样用;没给就按规范 07 七块**兜底装配**(只摘条目的原文,不臆造)。
|
|
2469
|
+
const description = String(t.description ?? "").trim() || buildSplitTaskDescription(item, t.title);
|
|
2470
|
+
const acceptance = String(t.acceptance ?? "").trim() || buildSplitTaskAcceptance(item);
|
|
2216
2471
|
const task = store.createTask({
|
|
2217
|
-
projectId: item.projectId, title: t.title, description
|
|
2472
|
+
projectId: item.projectId, title: t.title, description, acceptance,
|
|
2218
2473
|
owner: t.owner, priority: t.priority, labels, status: "backlog",
|
|
2219
2474
|
});
|
|
2220
2475
|
const linked = store.associateRequirementTask(item.id, task.id);
|
|
@@ -2419,7 +2674,7 @@ export function openStore(options = {}) {
|
|
|
2419
2674
|
* 任务不在认领态 / 认领已过期 → 返回 false(对齐 hermes `heartbeat_worker`)。
|
|
2420
2675
|
* **缺心跳本身不计为失败**,因此这里不碰 consecutive_failures。
|
|
2421
2676
|
*/
|
|
2422
|
-
heartbeatTask(ref, { lock = null, note = null, now = null } = {}) {
|
|
2677
|
+
heartbeatTask(ref, { lock = null, note = null, now = null, silent = false } = {}) {
|
|
2423
2678
|
const task = store.requireTaskRef(ref);
|
|
2424
2679
|
const at = new Date(now ?? Date.now()).toISOString();
|
|
2425
2680
|
const args = [at, at, task.id, at];
|
|
@@ -2428,10 +2683,45 @@ export function openStore(options = {}) {
|
|
|
2428
2683
|
const res = db.prepare(sql).run(...args);
|
|
2429
2684
|
if (res.changes !== 1) return { ok: false, reason: "not-claimed-or-expired" };
|
|
2430
2685
|
// FR-82:心跳同时计入当前尝试(heartbeats / last_heartbeat_at)
|
|
2431
|
-
store.heartbeatTaskRun(task.identifier, { now: now ?? Date.now() });
|
|
2686
|
+
store.heartbeatTaskRun(task.identifier, { now: now ?? Date.now(), silent });
|
|
2432
2687
|
if (note) { try { store.addComment(task.id, { body: `心跳:${note}` }); } catch { /* ignore */ } }
|
|
2433
2688
|
return { ok: true, at };
|
|
2434
2689
|
},
|
|
2690
|
+
/**
|
|
2691
|
+
* 卡 `-260`(需求 `R185`):**经主会话下发的执行也要有心跳**。
|
|
2692
|
+
*
|
|
2693
|
+
* 真机(2026-11-12 · `-248`):`-257` 之后 CLI 执行器默认交项目主会话下发,服务端只投一条 prompt
|
|
2694
|
+
* 就返回 —— **没有任何本地进程**,于是 `run_heartbeat` 从来不打,一条 22 分 51 秒的成功尝试
|
|
2695
|
+
* `heartbeats` 恒为 1(只有认领那一拍)。看门狗因此判不了活,人也在抽屉里看不到任何进度。
|
|
2696
|
+
*
|
|
2697
|
+
* 口径(**只报可观测事实,不臆造**):只有当该次尝试绑定的会话在宿主 `agents` 注册表里
|
|
2698
|
+
* **running 或有待消费消息**时才打 —— 会话空闲就一拍都不打,绝不为了「看起来在跑」而刷心跳。
|
|
2699
|
+
*
|
|
2700
|
+
* 每拍只更新计数/时间戳,**不写 `heartbeat` 事件**(`silent:true`),否则事件流会被 40 条噪音淹掉。
|
|
2701
|
+
*/
|
|
2702
|
+
heartbeatDispatchedRuns({ now = null } = {}) {
|
|
2703
|
+
const rows = db.prepare(
|
|
2704
|
+
`select t.id as task_id, t.identifier, t.status, r.session_id
|
|
2705
|
+
from task_runs r join tasks t on t.id = r.task_id
|
|
2706
|
+
where r.status = 'running'`,
|
|
2707
|
+
).all();
|
|
2708
|
+
const beat = [];
|
|
2709
|
+
for (const row of rows) {
|
|
2710
|
+
if (String(row.status) !== "in_progress") continue; // 已进待验收/已完成的不该再「在跑」
|
|
2711
|
+
const sid = row.session_id;
|
|
2712
|
+
if (!sid) continue; // 没有会话可观测 ⇒ 不臆造
|
|
2713
|
+
let state = null;
|
|
2714
|
+
try { state = store.taskSessionState({ id: row.task_id, sessionId: sid }); } catch { state = null; }
|
|
2715
|
+
const alive = state?.running === true || Number(state?.pending ?? 0) > 0;
|
|
2716
|
+
if (!alive) continue;
|
|
2717
|
+
try {
|
|
2718
|
+
const ok = store.heartbeatTask(row.identifier, { now, silent: true });
|
|
2719
|
+
if (!ok?.ok) store.heartbeatTaskRun(row.identifier, { now, silent: true });
|
|
2720
|
+
beat.push(row.identifier);
|
|
2721
|
+
} catch { /* 单卡心跳失败不影响其它卡 */ }
|
|
2722
|
+
}
|
|
2723
|
+
return beat;
|
|
2724
|
+
},
|
|
2435
2725
|
/** 认领状态只读查询(FR-77):是否被认领 / 是否过期 / 心跳年龄(秒)。 */
|
|
2436
2726
|
taskClaimState(ref, { now = null, heartbeatGapMs = DEFAULT_HEARTBEAT_GAP_MS } = {}) {
|
|
2437
2727
|
const task = ref && typeof ref === "object" && ref.id ? ref : store.requireTaskRef(ref);
|
|
@@ -2567,7 +2857,7 @@ export function openStore(options = {}) {
|
|
|
2567
2857
|
return { tripped, failures, effectiveLimit, limitSource, quota, task: store.getTaskById(task.id) };
|
|
2568
2858
|
},
|
|
2569
2859
|
/** 成功即清零(FR-78);成功 = 产出已提交待验收(含团队回报完成)。 */
|
|
2570
|
-
markTaskSucceeded(ref, { now = null } = {}) {
|
|
2860
|
+
markTaskSucceeded(ref, { now = null, summary = null } = {}) {
|
|
2571
2861
|
const task = store.requireTaskRef(ref);
|
|
2572
2862
|
const at = new Date(now ?? Date.now()).toISOString();
|
|
2573
2863
|
// FR-80:复发计数/阻断类型/人工兜底标记**只在成功时清零**
|
|
@@ -2577,7 +2867,9 @@ export function openStore(options = {}) {
|
|
|
2577
2867
|
db.prepare("update tasks set labels = ? where id = ?").run(JSON.stringify(labels), task.id);
|
|
2578
2868
|
} catch { /* ignore */ }
|
|
2579
2869
|
// FR-82:成功 = 本次尝试的终态;事件流追加("完成"仍需人确认,这一步只记成功会计)
|
|
2580
|
-
|
|
2870
|
+
// 卡 `-259`(R184):摘要承载**执行方结论**(调用方给什么记什么);没给就如实写「执行方未回写摘要」。
|
|
2871
|
+
// 记账这件事本身仍由下面的 `consecutive_failures = 0` 落库 + `run_ended` 事件承担,信息不丢。
|
|
2872
|
+
store.endTaskRun(task.identifier, { outcome: "success", summary: normalizeRunSummary(summary), actor: "system", now: now ?? Date.now() });
|
|
2581
2873
|
return store.getTaskById(task.id);
|
|
2582
2874
|
},
|
|
2583
2875
|
/**
|
|
@@ -2675,9 +2967,10 @@ export function openStore(options = {}) {
|
|
|
2675
2967
|
db.prepare("update team_tasks set status = 'failed', updated_at = ? where task_id = ? and status in ('open','running')").run(nowIso(), task.id);
|
|
2676
2968
|
return r.task;
|
|
2677
2969
|
},
|
|
2678
|
-
submitTaskForReview(ref, { comment = "" } = {}) {
|
|
2970
|
+
submitTaskForReview(ref, { comment = "", summary = null } = {}) {
|
|
2679
2971
|
// FR-83:提交待验收 = 请求评审(从这里进评审一等流程)
|
|
2680
|
-
|
|
2972
|
+
// 卡 `-259`(R184):`summary` 一路透传,最终落到 `run.summary`(执行方结论,不是记账文案)
|
|
2973
|
+
return store.requestReview(ref, { comment, summary, actor: "team" }).task;
|
|
2681
2974
|
},
|
|
2682
2975
|
// ---------------- 评审流程(FR-83) ----------------
|
|
2683
2976
|
/**
|
|
@@ -2707,7 +3000,7 @@ export function openStore(options = {}) {
|
|
|
2707
3000
|
* 请求评审(FR-83 的一等流程):进「待验收」+ **指派评审者** + 记下**来源列**(返工退回哪一列)。
|
|
2708
3001
|
* 释放实现认领(FR-77);执行成功照 FR-78 记账;事件流写 `review_requested`。
|
|
2709
3002
|
*/
|
|
2710
|
-
requestReview(ref, { reviewer = null, dependsOn = null, comment = "", actor = "team", now = null } = {}) {
|
|
3003
|
+
requestReview(ref, { reviewer = null, dependsOn = null, comment = "", summary = null, actor = "team", now = null } = {}) {
|
|
2711
3004
|
const task = store.requireTaskRef(ref);
|
|
2712
3005
|
const at = new Date(now ?? Date.now()).toISOString();
|
|
2713
3006
|
// 卡 `-244`(R178):显式传了的优先;没传就按项目团队模板补一个评审角色,
|
|
@@ -2725,7 +3018,16 @@ export function openStore(options = {}) {
|
|
|
2725
3018
|
version = version + 1, updated_at = ? where id = ?`,
|
|
2726
3019
|
).run(assigned, at, source, dependsOn, dependsOn, at, task.id);
|
|
2727
3020
|
if (comment) store.addComment(task.id, { body: comment });
|
|
2728
|
-
|
|
3021
|
+
// 卡 `-259`(R184):摘要优先级 = 调用方显式给 > 本次评论首行 > 最近一条结构化证据的 verdict 首句。
|
|
3022
|
+
// 三级都没有 ⇒ 交给 `normalizeRunSummary` 写「执行方未回写摘要」(不伪造)。
|
|
3023
|
+
let runSummary = summary;
|
|
3024
|
+
if (!runSummary && String(comment ?? "").trim() !== "") {
|
|
3025
|
+
runSummary = String(comment).split("\n").map((line) => line.trim()).find((line) => line !== "") ?? null;
|
|
3026
|
+
}
|
|
3027
|
+
if (!runSummary) {
|
|
3028
|
+
try { runSummary = store.latestTaskEvidence(task.identifier)?.verdict ?? null; } catch { runSummary = null; }
|
|
3029
|
+
}
|
|
3030
|
+
store.markTaskSucceeded(task.identifier, { summary: runSummary }); // FR-78:产出已提交待验收 = 本次执行成功
|
|
2729
3031
|
// 卡 `-245`(R178):已经在「待验收」再点一次,是同态迁移 —— 不写空转事件
|
|
2730
3032
|
// (真机 8 卡攒了 16 条 `in_review→in_review`,纯日志噪音)。`review_requested` 照写,动作本身要留痕。
|
|
2731
3033
|
if (task.status !== "in_review") {
|
|
@@ -3107,14 +3409,16 @@ export function openStore(options = {}) {
|
|
|
3107
3409
|
return { started: true, run: rowToRun(db.prepare("select * from task_runs where id = ?").get(id)) };
|
|
3108
3410
|
},
|
|
3109
3411
|
/** 尝试心跳(FR-82 的 heartbeats 计数;与 FR-77 的认领心跳同源,缺心跳本身不算失败)。 */
|
|
3110
|
-
heartbeatTaskRun(ref, { now = null, maxMs = null } = {}) {
|
|
3412
|
+
heartbeatTaskRun(ref, { now = null, maxMs = null, silent = false } = {}) {
|
|
3111
3413
|
const task = ref && typeof ref === "object" && ref.id ? ref : store.requireTaskRef(ref);
|
|
3112
3414
|
const run = store.getCurrentRun(task);
|
|
3113
3415
|
if (!run) return { ok: false, reason: "no-running-run" };
|
|
3114
3416
|
const at = new Date(now ?? Date.now()).toISOString();
|
|
3115
3417
|
db.prepare("update task_runs set heartbeats = heartbeats + 1, last_heartbeat_at = ?, updated_at = ? where id = ? and status = 'running'").run(at, at, run.id);
|
|
3116
3418
|
if (maxMs != null) db.prepare("update task_runs set max_ms = ? where id = ?").run(Number(maxMs), run.id);
|
|
3117
|
-
|
|
3419
|
+
// 卡 `-260`(R185):批量心跳(`heartbeatDispatchedRuns`)每 30s 一拍,不能每拍都往事件流里
|
|
3420
|
+
// 塞一条 `heartbeat` —— 20 分钟的执行会攒下 40 条纯噪音。`silent:true` 只更新计数与时间戳。
|
|
3421
|
+
if (!silent) store.recordTaskEvent(task.id, { type: "heartbeat", to: "running", detail: `第 ${run.attempt} 次尝试心跳`, now });
|
|
3118
3422
|
return { ok: true, runId: run.id, attempt: run.attempt, at };
|
|
3119
3423
|
},
|
|
3120
3424
|
/**
|
|
@@ -3620,9 +3924,9 @@ export function openStore(options = {}) {
|
|
|
3620
3924
|
for (const row of downstream) {
|
|
3621
3925
|
const t = store.getTaskById(row.id);
|
|
3622
3926
|
if (!t || (t.status !== "blocked" && t.status !== "todo")) continue;
|
|
3623
|
-
//
|
|
3624
|
-
|
|
3625
|
-
if (!
|
|
3927
|
+
// 就绪判定只走 `isTaskReady`(唯一口径:done / canceled 都不阻塞)。卡 `-253` 之前这里
|
|
3928
|
+
// 另写了一套 `done || canceled`,与 `isTaskReady` 重复且容易漂移。
|
|
3929
|
+
if (!store.isTaskReady(t.id).ready) continue;
|
|
3626
3930
|
db.prepare(
|
|
3627
3931
|
`update tasks set status = 'todo', blocked_at = null, claim_lock = null, claim_expires = null,
|
|
3628
3932
|
claim_owner = null, last_heartbeat_at = null, version = version + 1, updated_at = ?
|
|
@@ -3661,7 +3965,15 @@ export function openStore(options = {}) {
|
|
|
3661
3965
|
store.recordAudit({ actor, action: "set-status", target: t.identifier, allowed: false, reason: "human-review-not-executable", detail: `requested ${status}` });
|
|
3662
3966
|
throw new TbError("HUMAN_REVIEW_NOT_EXECUTABLE", `任务 ${t.identifier} 是人工校验任务:执行侧不得改其状态`, { identifier: t.identifier });
|
|
3663
3967
|
}
|
|
3664
|
-
if (!TEAM_WRITABLE_STATUSES.includes(status))
|
|
3968
|
+
if (!TEAM_WRITABLE_STATUSES.includes(status)) {
|
|
3969
|
+
// 卡 `-262`(需求 `R186`):旧文案只说「不允许」,不列合法值 —— 传中文时读起来像「这个状态不允许」,
|
|
3970
|
+
// 而不是「你填错语言了」。现在把合法枚举与中文列名一次说清(仍拒绝,不做静默映射)。
|
|
3971
|
+
// 卡 `-261`:若这次填的**正是某个看板列名**,再点名它对应的枚举 —— 少一次「读报错 → 猜语言 → 重试」的往返;
|
|
3972
|
+
// 认不得的值**不给猜测**(只列全部合法值),免得把「已取消/已完成」这类别的列名猜成某个枚举。
|
|
3973
|
+
const column = teamStatusEnumForColumn(status);
|
|
3974
|
+
const hint = column ? `。你传的「${status}」是看板列名,对应的 status 枚举是 ${column}。` : "";
|
|
3975
|
+
throw invalidField("status", `执行侧不允许写入 ${status}:status 只接受英文枚举 ${TEAM_WRITABLE_STATUSES.join(" / ")}(中文只是看板列名:${TEAM_WRITABLE_STATUSES.map((s) => `${s}=${TEAM_STATUS_COLUMN_LABELS[s]}`).join(" / ")})${hint}`);
|
|
3976
|
+
}
|
|
3665
3977
|
// 状态离开"进行中"即释放认领(FR-77)
|
|
3666
3978
|
const clearClaim = status === "in_progress" ? "" : ", claim_lock = null, claim_expires = null, claim_owner = null, last_heartbeat_at = null";
|
|
3667
3979
|
db.prepare(`update tasks set status = ?${clearClaim}, version = version + 1, updated_at = ? where id = ?`).run(status, nowIso(), t.id);
|
|
@@ -3671,8 +3983,16 @@ export function openStore(options = {}) {
|
|
|
3671
3983
|
// 而诊断 / 看护 / 通知 / M1 度量**全部**建在事件流上 —— 漏 26% 等于度量基础不可信。
|
|
3672
3984
|
// 只在实际变化时发(同状态重复写不产生假事件)。
|
|
3673
3985
|
if (t.status !== status) store.recordTaskEvent(t.id, { type: "status_changed", from: t.status, to: status, actor });
|
|
3986
|
+
// 卡 `-253`(需求 `R181`):团队通道撤单同样是「前置终结」⇒ 放行因依赖受阻的下游。
|
|
3987
|
+
if (status === "canceled" && t.status !== status) {
|
|
3988
|
+
try { releaseDownstreamOnCancel(db, store, t, { actor, at: nowIso() }); } catch { /* 下游放行失败不反噬撤单本身 */ }
|
|
3989
|
+
}
|
|
3674
3990
|
// FR-111(`-195`):执行侧 / 团队通道置待验收同样补评审发起时间
|
|
3675
3991
|
if (status === "in_review" && t.status !== status && !t.reviewRequestedAt) store.markReviewRequested(t.id);
|
|
3992
|
+
// 卡 `-269`(R185):**这条入口同样要当场闭尝试**。`-260` 只补了看板 PATCH(`updateTask`),
|
|
3993
|
+
// 而 MCP `taskboard_update_status` / `POST /tasks/:ref/team-status` / 团队通道走的是这里、
|
|
3994
|
+
// 直接写状态列 ⇒ 卡片已「待验收」而在途尝试仍是 `running`(本卡实测复现了同一分叉)。
|
|
3995
|
+
if (status === "in_review" && t.status !== status) closeInflightRunOnReview(t.identifier, { actor, at: Date.now() });
|
|
3676
3996
|
// FR-107(`-197`):执行侧 / 团队通道进入「进行中」同样是一次认领 ⇒ 冻结授权快照
|
|
3677
3997
|
if (status === "in_progress" && t.status !== status) freezeMandate(t.id, { scope: "team", claimOwner: t.claimOwner ?? actor, claimSource: t.status });
|
|
3678
3998
|
return store.getTaskById(t.id);
|
|
@@ -3707,7 +4027,8 @@ export function openStore(options = {}) {
|
|
|
3707
4027
|
db.prepare("update team_tasks set status = 'completed', updated_at = ? where id = ?").run(nowIso(), teamTaskId);
|
|
3708
4028
|
if (row.kind === "review" && reviewPassed !== true) store.blockDownstream(t.id, "review-not-passed");
|
|
3709
4029
|
store.addComment(t.id, { body: `团队回报:完成 → 提交待验收${ev}` }); // 自动登记反馈
|
|
3710
|
-
|
|
4030
|
+
// 卡 `-259`(R184):团队回报的 evidence 就是这次尝试的结论,带进摘要
|
|
4031
|
+
store.markTaskSucceeded(t.identifier, { summary: evidence || "团队回报完成" }); // FR-78:成功即清零失败计数
|
|
3711
4032
|
} else if (outcome === "failed") {
|
|
3712
4033
|
// FR-80:团队回报失败也走统一受阻入口(transient)
|
|
3713
4034
|
db.prepare("update tasks set status = 'blocked', version = version + 1, updated_at = ? where id = ?").run(nowIso(), t.id);
|