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/web/app.js CHANGED
@@ -52,6 +52,11 @@
52
52
  "change-requirement": "变更需求(按新口径重开原任务)",
53
53
  close: "关闭(不再推进该任务)",
54
54
  };
55
+ // 卡 `-268`(需求 `R184`):**执行方没回写摘要时的唯一说法**。
56
+ // 与服务端 `src/core/store.mjs` 的 `RUN_SUMMARY_FALLBACK` **逐字一致**(两份不许漂 ——
57
+ // `tests/exec-record-render.test.mjs` 钉住)。绝不拿记账文案(「按成功完成记账(失败计数清零)」)
58
+ // 冒充执行内容;服务端已在读路径归一(`displayRunSummary`),这里的兜底是给**未重载的旧服务端**留的。
59
+ const RUN_SUMMARY_FALLBACK = "执行方未回写摘要";
55
60
  // FR-88:卡片「折叠(软归档)」—— 不删任何数据,只用一个标签把已失效 / 无用的卡片从
56
61
  // 看板默认视图里收起来,保住「项目 → 需求 → 主任务(子任务串)」的层次。
57
62
  // 用标签而不是新状态:状态是流程语义(backlog / todo / …),折叠只是呈现开关;
@@ -566,6 +571,23 @@
566
571
  node.textContent = label;
567
572
  return node;
568
573
  };
574
+ // 卡 `-272`(需求 `R188`):`launch.reusedFrom` 的**来源档位**中文名。
575
+ // 服务端只给 `main` / `approved` / `executor` 三个枚举值 —— 这里只做翻译,不新增判据。
576
+ const REUSED_FROM_LABEL = { main: "项目主会话", approved: "已批准关联会话", executor: "执行会话(派生)" };
577
+ /**
578
+ * 卡 `-272`(需求 `R188` 验收③):**授权已成 ≠ 任务书已送达**。
579
+ *
580
+ * 服务端 `launch.bookDelivery` 只有新建路径才有(`null` = 不适用)。`delivered === false` 表示
581
+ * 会话建出来了、授权也写了,但**任务书一个字都没进那条会话**(宿主 preset 被吞 + 补投也失败)。
582
+ * 此时界面**不得**照常显示「已新建…无需再申请关联」—— 那句话会让人以为派发已完成。
583
+ * 返回 `""` 表示没有这条警告(不是复用路径、或确实送达了)。
584
+ */
585
+ const bookDeliveryClause = (launch) => {
586
+ const d = launch?.bookDelivery ?? null;
587
+ if (!d || d.delivered !== false) return "";
588
+ return `\n⚠ 任务书未送达(${d.reason ?? "原因未知"}):会话已建、授权已生效,但该会话不知道要做什么 —— 点「打开执行会话」把任务书手工贴过去,或修好宿主 preset 投递后重派`;
589
+ };
590
+ const bookDeliveryFailed = (launch) => (launch?.bookDelivery?.delivered === false);
569
591
 
570
592
  // ---------------------------------------------------------------- chrome
571
593
  const shell = mk("div", "app-shell");
@@ -743,7 +765,22 @@
743
765
  // `stale` 单独给警示样式:判定过期时**不许**看起来像"可以确认"。
744
766
  const drawerStage = mk("span", "tb-stage-badge", "");
745
767
  drawerStage.hidden = true;
746
- drawerHeadMain.append(drawerId, drawerStage, drawerTitle);
768
+ // 卡 `-268`(需求 `R184`)③:**首屏的「执行记录」锚点**。
769
+ // 真机(2026-11-12 · 卡 `-248`):执行状态埋在抽屉第 7 段(「执行会话」),证据埋在第 14 段(评论),
770
+ // 首屏只有概览 —— 人要先知道「有没有跑过、跑到哪了」,才谈得上往下翻。这里在标题栏给一颗**恒在**的
771
+ // 徽标(有没有记录都给,空态写「尚无」),点它跳到「执行记录」段。
772
+ // 只读:不新增判据,数字全部来自 `GET /api/tasks/:ref` 的 `executionRecord`(与那一段同源)。
773
+ const drawerExecBadge = mk("button", "tb-exec-badge", "");
774
+ drawerExecBadge.type = "button";
775
+ drawerExecBadge.hidden = true;
776
+ drawerExecBadge.addEventListener("click", () => {
777
+ const sec = Array.from(drawerBody.querySelectorAll(".drawer-section"))
778
+ .find((s) => s.classList.contains("exec-record"));
779
+ if (!sec) { showBanner("「执行记录」段尚未就绪,请稍候重试", "error"); return; }
780
+ sec.classList.remove("collapsed"); // FR-87 折叠态下先展开,否则"跳过去"看不到东西
781
+ sec.scrollIntoView({ block: "start", behavior: "smooth" });
782
+ });
783
+ drawerHeadMain.append(drawerId, drawerStage, drawerExecBadge, drawerTitle);
747
784
  const drawerClose = mk("button", "ghost icon", "✕");
748
785
  drawerClose.type = "button";
749
786
  drawerClose.title = "关闭";
@@ -1542,9 +1579,15 @@
1542
1579
  // FR-49:下发结果可见(会话绑定 / 降级原因)
1543
1580
  if (suffix === "/execute" && result?.launch) {
1544
1581
  const l = result.launch;
1582
+ // 卡 `-264`:`mode` 新增 `reuse-bound` / `create-and-authorize` 两档 —— 它们是**正常成功**,
1583
+ // 旧口径「非 session 即 error」会把「复用了空闲会话」误报成红色错误。
1584
+ const modeText = l.mode === "reuse-bound" ? "复用已绑定空闲会话"
1585
+ : l.mode === "create-and-authorize" ? "新建执行会话并首次授权"
1586
+ : l.mode === "session" ? "已下发到指定会话"
1587
+ : "降级";
1545
1588
  showBanner(
1546
- `已下发 ${task.identifier}:mode=${l.mode}${l.sessionId ? ` · 会话 ${String(l.sessionId).slice(0, 12)}` : ""}${l.reason ? ` · 降级原因 ${l.reason}` : ""}${sessionNameClause(l)}`,
1547
- l.mode === "session" && l.titleApplied !== false ? "info" : "error",
1589
+ `已下发 ${task.identifier}:${modeText}${l.sessionId ? ` · 会话 ${String(l.sessionId).slice(0, 12)}…` : ""}${l.reason ? ` · 降级原因 ${l.reason}` : ""}${sessionNameClause(l)}${bookDeliveryClause(l)}`,
1590
+ l.mode === "degraded" || !l.sessionId || l.titleApplied === false || bookDeliveryFailed(l) ? "error" : "info",
1548
1591
  );
1549
1592
  }
1550
1593
  await loadTasks();
@@ -1559,7 +1602,9 @@
1559
1602
  };
1560
1603
  // 2026-10-22:入口由 executionEntry 决定 —— 未归因的可开工卡不给「启动执行」(点了必被归因门拒)。
1561
1604
  const entry = executionEntry(task);
1562
- if (entry === "start") group.appendChild(act("启动执行", "/execute", undefined, "启动执行会尝试新建/切换会话(可能切换主视图)。确认继续?"));
1605
+ // 卡 `-264`:卡片级入口没有每卡预览(看板上不为每张卡探活),但口径要提前讲清 ——
1606
+ // 会优先复用本项目的已绑定空闲会话;没有可用会话才新建并**首次授权**。
1607
+ if (entry === "start") group.appendChild(act("启动执行", "/execute", undefined, "启动执行会先复用本项目已绑定的空闲会话;没有可用会话时新建一条并当场首次授权(可能切换主视图)。确认继续?"));
1563
1608
  else if (entry === "attribute") group.appendChild(attributeAction(task));
1564
1609
  else if (entry === "authorize") group.appendChild(authorizeAction(task));
1565
1610
  if (task.status === "in_progress") {
@@ -2086,7 +2131,8 @@
2086
2131
  if (!sessionId) { state.binding = { projectId, bound: true, mainSessionId: null, association: null }; return; }
2087
2132
  try {
2088
2133
  const c = await api("GET", `/api/context?session=${encodeURIComponent(sessionId)}&project=${encodeURIComponent(projectId)}`);
2089
- state.binding = { projectId, bound: c.sessionBound !== false, mainSessionId: c.mainSessionId ?? null, association: c.association ?? null, sessionOrigin: c.sessionOrigin ?? null };
2134
+ // 卡 `-263`:`roleDerived` / `executorTasks` 让「执行会话」这条绑定说得出依据(哪张卡派生出来的)。
2135
+ state.binding = { projectId, bound: c.sessionBound !== false, mainSessionId: c.mainSessionId ?? null, association: c.association ?? null, roleDerived: c.roleDerived === true, executorTasks: c.executorTasks ?? [], sessionOrigin: c.sessionOrigin ?? null };
2090
2136
  } catch (error) {
2091
2137
  state.binding = { projectId, bound: true, mainSessionId: null, association: null };
2092
2138
  // 卡 `-222` ①:绑定态也是 bootstrap 的一步 —— 失败要留原因(项目内切换时不算 boot 步骤,不记账)
@@ -3361,11 +3407,25 @@
3361
3407
  cfgAdv.append(envTa, tplTa, saveCfg);
3362
3408
  init.appendChild(cfgAdv);
3363
3409
 
3410
+ // 卡 `-263`:角色中文名 —— 配置页此前直接打印英文枚举(executor / associated),
3411
+ // 「执行会话」是**派生**出来的,必须在文案里说清它从哪来、什么时候消失。
3412
+ const ROLE_LABEL = {
3413
+ main: "主会话",
3414
+ associated: "已关联(主会话批准)",
3415
+ executor: "执行会话(按任务归属派生)",
3416
+ pending: "待批准",
3417
+ none: "未绑定",
3418
+ };
3419
+ const roleLabel = (role, tasks) => {
3420
+ if (!role) return "未绑定";
3421
+ const base = ROLE_LABEL[role] ?? String(role);
3422
+ return Array.isArray(tasks) && tasks.length ? `${base} · 任务 ${tasks.join(" / ")}` : base;
3423
+ };
3364
3424
  // FR-63:会话关联(主会话批准)
3365
- const links = card("会话关联(主会话批准)", "已绑定本项目的会话;未绑定的会话可申请,由主会话批准后生效");
3425
+ const links = card("会话关联(主会话批准)", "已绑定本项目的会话;未绑定的会话可申请,由主会话批准后生效。执行会话按任务归属自动生效,任务收口后自动收回");
3366
3426
  links.appendChild(kvList([
3367
3427
  ["本会话", sessionId ? String(sessionId) : "(全局入口 · 非会话)"],
3368
- ["本会话角色", sessionId ? String(state.context?.association ?? "未绑定") : "—"],
3428
+ ["本会话角色", sessionId ? roleLabel(state.context?.association, state.context?.executorTasks) : "—"],
3369
3429
  ["主会话", state.context?.mainSessionId ? String(state.context.mainSessionId) : "(尚无)"],
3370
3430
  ]));
3371
3431
  const sessList = await api("GET", `/api/projects/${encodeURIComponent(state.projectId)}/sessions`).catch(() => ({ sessions: [], main: null, staleMain: false }));
@@ -3445,6 +3505,21 @@
3445
3505
  ));
3446
3506
  }
3447
3507
  } else links.appendChild(mk("p", "hint", "暂无其它会话申请"));
3508
+ // 卡 `-263`(需求 `R187`)· **执行会话(派生)**:认领/启动执行只写 `tasks.session_id`,
3509
+ // 不写批准表 —— 这类会话此前在配置页完全不可见,用户只能看到「本会话角色:executor」这种生词。
3510
+ // 这里如实列出「谁在干哪张卡」,并说明它**随任务收口自动消失**(没有「解除」按钮,因为它不是授权记录)。
3511
+ if ((sessList.executors ?? []).length) {
3512
+ for (const s of sessList.executors) {
3513
+ const label = mk("span", null, `⚙ 执行会话(派生) · ${String(s.sessionId).slice(0, 14)}…`);
3514
+ label.title = String(s.sessionId);
3515
+ links.appendChild(row(
3516
+ label,
3517
+ livenessPill(s.liveness),
3518
+ mk("span", "hint", `任务 ${(s.tasks ?? []).join(" / ")} · 任务进入 done / canceled 后自动收回`),
3519
+ hostBtn("打开会话", () => openSessionJump(s.sessionId)),
3520
+ ));
3521
+ }
3522
+ }
3448
3523
  links.appendChild(mk("p", "hint", "存活判定来源:宿主 `sessionQuery.observeSession`(持久化会话存在性);判不准时显示「存在性未知」并按有效处理(不阻断打开)。主会话失效时用「重建并绑定主会话」接续。"));
3449
3524
 
3450
3525
  // FR-81:通知订阅(游标 + notify/wake)——工作台关着也能把任务终态闭环回目标会话
@@ -4149,9 +4224,18 @@
4149
4224
  btn("批量生成任务", async () => {
4150
4225
  const ids = [...reqState.selected].filter((id) => { const x = allItems.find((y) => y.identifier === id); return x && x.status !== "draft"; });
4151
4226
  if (!ids.length) { showBanner("请先勾选「已确认」条目", "error"); return; }
4152
- let n = 0; const failed = [];
4153
- for (const id of ids) { const x = allItems.find((y) => y.identifier === id); try { await api("POST", `/api/requirements/items/${encodeURIComponent(id)}/split`, { tasks: [{ title: x.title, kind: "work" }] }); n += 1; } catch (e) { failed.push(`${id}:${e.message}`); } }
4154
- showBanner(failed.length ? `已生成 ${n} 个任务,失败 ${failed.length} 条(首条:${failed[0]})` : `已批量生成 ${n} 个看板任务(待办池,需授权开工)`, failed.length ? "error" : "info");
4227
+ let n = 0; const failed = []; let noAcceptance = 0;
4228
+ for (const id of ids) {
4229
+ const x = allItems.find((y) => y.identifier === id);
4230
+ // 卡 `-273`(需求 `R189`):条目没写验收时必须**说出口** —— 旧口径只报「已生成 N 个任务」,
4231
+ // 人以为卡是完整的;实际服务端只能写「需求条目未写验收 —— 开工前必须补」。
4232
+ if (!String(x?.acceptance ?? "").trim()) noAcceptance += 1;
4233
+ try { await api("POST", `/api/requirements/items/${encodeURIComponent(id)}/split`, { tasks: [{ title: x.title, kind: "work" }] }); n += 1; } catch (e) { failed.push(`${id}:${e.message}`); }
4234
+ }
4235
+ const detailNote = noAcceptance ? ` · ${noAcceptance} 条需求未写验收(卡上已标「开工前必须补」)` : "";
4236
+ showBanner(failed.length
4237
+ ? `已生成 ${n} 个任务,失败 ${failed.length} 条(首条:${failed[0]})${detailNote}`
4238
+ : `已批量生成 ${n} 个看板任务(待办池,需授权开工;正文与验收已按条目装配)${detailNote}`, failed.length ? "error" : "info");
4155
4239
  setView("board");
4156
4240
  }, "primary"),
4157
4241
  btn("批量删除", async () => {
@@ -4584,12 +4668,45 @@
4584
4668
  } else card.appendChild(mk("div", "empty-note", "暂无团队任务"));
4585
4669
  return card;
4586
4670
  }
4671
+ /**
4672
+ * 卡 `-247`(需求 `R178` ④):**团队侧反查块** —— 看板卡 ↔ 承载环境 agent-team 插件的 `t-id`。
4673
+ *
4674
+ * 口径(与 `src/core/team-bridge.mjs` 同源,前端不另算):
4675
+ * · 映射是**只读推导**(插件侧的 team.json 没有卡号字段,靠卡号全词命中 + 证据片段);
4676
+ * · 命中不到 ⇒ **明文声明**「看板只展示、不参与团队状态」,不写"没有团队在跑"(那是猜)。
4677
+ */
4678
+ function teamBridgeBlock(bridge) {
4679
+ const box = mk("div", "team-card");
4680
+ box.appendChild(mk("h3", null, "团队侧任务(只读同步)"));
4681
+ if (!bridge) {
4682
+ box.appendChild(mk("p", "hint", "读不到团队侧映射(服务端较旧或本项目无工作区)。"));
4683
+ return box;
4684
+ }
4685
+ if (!bridge.mapped) {
4686
+ box.appendChild(mk("p", "hint", `本卡号未在承载环境 agent-team 插件的团队任务里登记 ⇒ ${bridge.policyTitle}:看板侧状态与团队侧状态互不影响;看板的「完成」仍只能由人确认。`));
4687
+ box.appendChild(mk("p", "hint", `本工作区插件团队 ${bridge.pluginTeamCount ?? 0} 个;映射由「卡号在团队任务文本里全词命中」推导(插件侧没有卡号字段),命中不到即视为未登记。`));
4688
+ return box;
4689
+ }
4690
+ for (const row of bridge.rows || []) {
4691
+ const line = mk("div", "team-task-row");
4692
+ line.append(pill(row.teamTaskStatus ?? "?", row.teamTaskStatus === "completed" ? "ok" : row.teamTaskStatus === "failed" ? "danger" : "warn"));
4693
+ line.append(mk("span", null, `${row.teamTaskId} · ${row.teamName}`), mk("div", "spacer"), mk("span", "hint", row.assignee ? `负责 ${row.assignee}` : "未指派"));
4694
+ box.appendChild(line);
4695
+ if (row.teamTaskSubject) box.appendChild(mk("p", "hint", `团队任务标题:${row.teamTaskSubject}`));
4696
+ const fields = (row.evidence || []).map((e) => e.field).join("、");
4697
+ if (fields) box.appendChild(mk("p", "hint", `命中字段:${fields}(只读推导,插件侧无卡号字段)`));
4698
+ }
4699
+ return box;
4700
+ }
4587
4701
  async function fillTaskTeam(identifier, host) {
4588
4702
  const head = mk("h3", null, "归属团队");
4589
4703
  try {
4590
4704
  const data = await api("GET", `/api/tasks/${encodeURIComponent(identifier)}/team`);
4591
4705
  host.replaceChildren(head);
4592
4706
  if (data.lock) host.appendChild(mk("p", "hint", `任务级执行锁:${data.lock.status}(team ${String(data.lock.teamId).slice(0, 8)})`));
4707
+ // 卡 `-247`(需求 `R178` ④):团队侧反查 —— 这张卡在承载环境 agent-team 插件那边是哪个 t-id。
4708
+ // **只读推导**(插件侧没有卡号字段);命中不到就明说「看板只展示、不参与团队状态」,不臆断。
4709
+ host.appendChild(teamBridgeBlock(data.bridge));
4593
4710
  // 2026-10-22(第十报):归因门在授权门**之前**(store.assertExecutable 的门序列)⇒ 未归因的卡
4594
4711
  // 无论在哪一列,「派发团队」都注定被拒(api.mjs 的 assertAttributed)。先给归因入口,
4595
4712
  // 不把注定被拒的按钮摆出来(此前只挡了「启动执行」,这条漏了 —— 真机 `-80` 的抽屉里就有)。
@@ -4734,10 +4851,33 @@
4734
4851
  const r = await api("POST", `/api/tasks/${ref}/execute`, {});
4735
4852
  const launch = r?.launch ?? null;
4736
4853
  onDone?.();
4737
- return `已下发宿主会话:mode=${launch?.mode ?? "?"}${launch?.sessionId ? ` · 会话 ${String(launch.sessionId).slice(0, 12)}` : ""}`;
4854
+ // 卡 `-264`:`mode` 是派发决策的可读回执 —— 复用/新建授权/降级必须说人话,不能只丢枚举名。
4855
+ // 卡 `-272`(`R188` 验收①):复用时把**来源档位**也说出来(主会话 / 已批准关联 / 派生执行会话)——
4856
+ // 只说「复用了某条会话」的话,人答不出「它凭什么接这张卡」。
4857
+ const reusedFromText = launch?.reusedFrom ? `(${REUSED_FROM_LABEL[launch.reusedFrom] ?? launch.reusedFrom})` : "";
4858
+ const modeText = launch?.mode === "reuse-bound" ? `复用已绑定空闲会话${reusedFromText}`
4859
+ : launch?.mode === "create-and-authorize" ? "新建执行会话并首次授权"
4860
+ : launch?.mode === "degraded" ? "降级(未建会话)" : "已下发";
4861
+ // 卡 `-272`:任务书未送达必须随横幅一起说出来(这句话是「执行者选择器」这条入口的回执)。
4862
+ return `已下发宿主会话(${modeText})${launch?.sessionId ? ` · 会话 ${String(launch.sessionId).slice(0, 12)}…` : ""}${launch?.fallbackReason ? ` · 回退原因:${launch.fallbackReason}` : ""}${bookDeliveryClause(launch)}`;
4738
4863
  }
4864
+ // 卡 `-257`(需求 `R183`):CLI 执行器**默认经项目主会话下发并跟踪**。
4865
+ // 成功 ⇒ 会话标识已绑到本卡,「打开执行会话」直达记录所在的那条会话;
4866
+ // 投递失败 ⇒ 抛错(不回落直跑 —— 回落会让「记录在哪里」悄悄变掉);
4867
+ // 无主会话/无宿主 ⇒ 服务端回落直跑,但响应里带 `fallbackReason`,这里必须如实说出来。
4739
4868
  const r = await api("POST", `/api/tasks/${ref}/exec-cli`, { executor: executor.id, async: true });
4740
4869
  onDone?.();
4870
+ if (r?.via === "main-session") {
4871
+ if (r.delivered === false) {
4872
+ const error = new Error(`未下发:${r.reason ?? "原因未知"}(${r.nextAction ?? "先确认主会话可用"})`);
4873
+ error.code = "MAIN_SESSION_NOT_DELIVERED";
4874
+ throw error;
4875
+ }
4876
+ return `已交项目主会话下发(${executor.label} · 会话 ${String(r.sessionId ?? "").slice(0, 12)}…)—— 执行记录就在该会话里,点「打开执行会话」直达;跑完由主会话回写证据`;
4877
+ }
4878
+ if (r?.fallbackReason) {
4879
+ return `已直跑 ${executor.label}(未走主会话:${r.fallbackReason === "no-main-session" ? "任务与项目都没有可用会话引用" : "本实例无宿主会话通道"})—— 执行记录**不在任何会话里**;卡片评论已留痕`;
4880
+ }
4741
4881
  return `已提交 ${executor.label} 后台执行(${r?.executor ?? executor.id})`;
4742
4882
  }
4743
4883
 
@@ -4748,7 +4888,7 @@
4748
4888
  *
4749
4889
  * 挂点(稳定,供验证台定位,不靠中文文案):`data-exec-picker` / `data-executor` / `data-executor-kind`。
4750
4890
  */
4751
- function mountExecutorPicker(task, { onDone, note: idleNote = null, kinds = null } = {}) {
4891
+ function mountExecutorPicker(task, { onDone, note: idleNote = null, kinds = null, dispatchHint = null } = {}) {
4752
4892
  const wrap = mk("div", "tb-exec-picker");
4753
4893
  wrap.setAttribute("data-exec-picker", "1");
4754
4894
  wrap.appendChild(mk("span", "tb-exec-picker-label", "执行者"));
@@ -4833,8 +4973,8 @@
4833
4973
  const confirmText = chosen.kind === "team"
4834
4974
  ? `把 ${task.identifier} 派发给「${chosen.label}」执行?\n\n· 派发后由项目执行团队接手(roles 由项目设置决定)\n· 完成回写「待验收」,收口仍由人确认`
4835
4975
  : chosen.kind === "host-session"
4836
- ? `把 ${task.identifier} 交给「${chosen.label}」执行?\n\n· 会尝试新建/切换会话(可能切换主视图)\n· 执行前先认领:卡片置「进行中」`
4837
- : `把 ${task.identifier} 交给「${chosen.label}」**真实执行**?\n\n· 非交互调用本地 CLI(通常带文件写权限),耗时数十秒到数分钟\n· 执行前先认领:卡片置「进行中」\n· 完成后回流「待验收」或「受阻」,并附证据评论\n· 期间请勿重复点击`;
4976
+ ? `把 ${task.identifier} 交给「${chosen.label}」执行?\n\n· 会尝试新建/切换会话(可能切换主视图)\n· 执行前先认领:卡片置「进行中」${dispatchHint?.text ? `\n\n派发目标:${dispatchHint.text}` : ""}`
4977
+ : `把 ${task.identifier} 交给「${chosen.label}」执行?\n\n· 下发:交「项目主会话」下发并跟踪 —— 执行记录留在该会话里,「打开执行会话」直达\n· 执行:非交互调用本地 CLI(通常带文件写权限),耗时数十秒到数分钟\n· 执行前先认领:卡片置「进行中」\n· 跑完由主会话回写证据并提交「待验收」(或写清失败原因);完成仍由人确认\n· 期间请勿重复点击`;
4838
4978
  if (typeof window !== "undefined" && typeof window.confirm === "function" && !window.confirm(confirmText)) return;
4839
4979
  launch.disabled = true;
4840
4980
  try {
@@ -4872,6 +5012,45 @@
4872
5012
  drawerStage.title = stageInfo?.reason ? `${label}:${stageInfo.reason}` : label;
4873
5013
  }
4874
5014
 
5015
+ /**
5016
+ * 卡 `-268`(需求 `R184`)③:标题栏「执行记录」徽标的**唯一**渲染点。
5017
+ *
5018
+ * 数据源=`GET /api/tasks/:ref` 的 `executionRecord`(与正文那段**同一份**:最近一次结构化证据 +
5019
+ * 最近一次尝试 + 尝试总数)。**恒在**:没记录时也显示「尚无记录」—— 空态本身也是读数,
5020
+ * 藏起来就退回「不知道到底跑没跑过」。
5021
+ * 文案只说「跑到哪了」,不替代「下一步点哪里」(那是 `next` 的活)。
5022
+ *
5023
+ * @returns {void}
5024
+ */
5025
+ function renderExecBadge(record) {
5026
+ const run = record?.run ?? null;
5027
+ const evd = record?.evidence ?? null;
5028
+ const runsCount = Number(record?.runsCount ?? 0);
5029
+ // 结果档位:在途 / 成功 / 非成功 /(无尝试)。与正文 `RUN_OUT` 同一套服务端口径(outcome 是枚举)。
5030
+ const OUT_LABEL = { success: "成功", blocked: "受阻", failed: "失败", crash: "崩溃", timeout: "超时", reclaimed: "认领被回收", cancelled: "人工作废", released: "释放归属", interrupted: "中断", ended: "结束" };
5031
+ let label = "执行记录:尚无";
5032
+ let tone = "none";
5033
+ let detail = "本卡尚无执行记录(`task_evidence` 无行、`task_runs` 无行)—— 点这里看「执行记录」段的说明";
5034
+ if (run?.status === "running") {
5035
+ label = `执行记录:跑着(第 ${run.attempt} 次)`;
5036
+ tone = "running";
5037
+ detail = `第 ${run.attempt} 次尝试进行中 · 执行者 ${run.actor ?? "-"} · 开始于 ${fmtTime(run.startedAt)}`;
5038
+ } else if (run) {
5039
+ const out = OUT_LABEL[run.outcome] ?? run.outcome ?? "-";
5040
+ label = `执行记录:${out}`;
5041
+ tone = run.outcome === "success" ? "ok" : "warn";
5042
+ detail = `第 ${run.attempt} 次尝试 · ${out}${runsCount > 1 ? `(共 ${runsCount} 次)` : ""}`
5043
+ + `${run.endedAt ? ` · 结束于 ${fmtTime(run.endedAt)}` : ""} · 执行者 ${run.actor ?? "-"}`;
5044
+ }
5045
+ const withEvidence = evd ? ` · 结构化证据 ${Array.isArray(evd.artifacts) ? evd.artifacts.length : 0} 项产物` : " · 无结构化证据";
5046
+ drawerExecBadge.hidden = false;
5047
+ drawerExecBadge.textContent = label;
5048
+ drawerExecBadge.dataset.tone = tone;
5049
+ drawerExecBadge.dataset.runs = String(runsCount);
5050
+ drawerExecBadge.dataset.evidence = evd ? "1" : "0";
5051
+ drawerExecBadge.title = `${detail}${withEvidence}\n点击跳到「执行记录」段`;
5052
+ }
5053
+
4875
5054
  async function openTaskDetail(task) {
4876
5055
  const renderSeq = ++detailRenderSeq; // 本代编号(并发渲染时只有最新一代允许落地)
4877
5056
  detailTask = task;
@@ -4880,6 +5059,13 @@
4880
5059
  drawerStage.hidden = true;
4881
5060
  drawerStage.textContent = "";
4882
5061
  drawerStage.removeAttribute("data-stage");
5062
+ // 卡 `-268`:换卡先复位执行记录徽标(否则上一张卡的读数会挂在新卡标题上 —— 与动作区同一类残留)。
5063
+ drawerExecBadge.hidden = true;
5064
+ drawerExecBadge.textContent = "";
5065
+ drawerExecBadge.dataset.tone = "";
5066
+ drawerExecBadge.dataset.runs = "";
5067
+ drawerExecBadge.dataset.evidence = "";
5068
+ drawerExecBadge.removeAttribute("title");
4883
5069
  drawerActions.replaceChildren(); // 换卡先清空标题栏动作区,避免上一张卡的按钮残留
4884
5070
  drawerBody.replaceChildren(mk("p", "hint", "加载详情…"));
4885
5071
  drawerBackdrop.classList.add("show");
@@ -4898,6 +5084,9 @@
4898
5084
  ]);
4899
5085
  if (renderSeq !== detailRenderSeq) return; // 取数期间已被更新的一代取代 ⇒ 本次渲染作废
4900
5086
  renderStageBadge(detail.ticketStage ?? null);
5087
+ // 卡 `-268`:首屏徽标与正文「执行记录」段**同源同代**(都来自这一次 `GET /api/tasks/:ref`),
5088
+ // 所以在概览渲染之前就画上 —— 人一打开抽屉就看到「跑没跑过、跑到哪了」。
5089
+ renderExecBadge(detail.executionRecord ?? null);
4901
5090
  const t = detail.task ?? task;
4902
5091
  // 需求条目 id → 可读「identifier · title」。真机报障(2026-10-22):概览只打裸 UUID,
4903
5092
  // 用户「不知道这个关联的是哪个需求」—— 归属成了没人看得懂的字段。
@@ -4952,6 +5141,63 @@
4952
5141
  if (t.description) overview.appendChild(richText(t.description));
4953
5142
  drawerBody.appendChild(overview);
4954
5143
 
5144
+ // 卡 `-258`(需求 `R184`)· **执行记录聚合段,紧跟概览**。
5145
+ // 真机(2026-11-12 · 卡 `-248`):一张「待验收」的卡,结构化四节证据在 `task_evidence` 里齐全、
5146
+ // `task_runs` 也有 1 条 22 分 51 秒的成功尝试,但抽屉里**首屏什么都看不到** —— 尝试记录埋在第 10 段、
5147
+ // 完整证据在第 14 段的评论里,而最像「执行记录」的那条 summary 还只是记账文案。
5148
+ // 数据源=`GET /api/tasks/:ref` 的 `executionRecord`(只读回传:最近一次结构化证据 + 最近一次尝试)。
5149
+ // **没有就如实空态**:不臆造、不拿评论里的文本冒充结构化证据。
5150
+ {
5151
+ const rec = detail?.executionRecord ?? null;
5152
+ const evd = rec?.evidence ?? null;
5153
+ const run = rec?.run ?? null;
5154
+ const rsec = mk("div", "drawer-section exec-record");
5155
+ rsec.appendChild(mk("h3", null, "执行记录(结构化证据 + 最近一次尝试)"));
5156
+ if (!evd && !run) {
5157
+ rsec.appendChild(mk("p", "hint", "本卡尚无执行记录:`task_evidence` 无行、`task_runs` 无行。结构化证据由 MCP `card_evidence_submit` 或 `POST /api/tasks/:ref/evidence` 写入;尝试记录在任务被认领执行时才会开出第一条。"));
5158
+ } else {
5159
+ if (run) {
5160
+ const RUN_OUT = { success: "成功", blocked: "受阻", failed: "失败", crash: "崩溃", timeout: "超时", reclaimed: "认领被回收", cancelled: "人工作废", released: "释放归属" };
5161
+ const dur = run.status === "running"
5162
+ ? `已跑 ${Math.max(0, Math.round((Date.now() - new Date(run.startedAt).getTime()) / 60000))} 分钟`
5163
+ : (run.durationMs != null ? `耗时 ${Math.max(1, Math.round(run.durationMs / 1000))} 秒` : "耗时 -");
5164
+ rsec.appendChild(mk("p", "hint", `最近一次尝试:第 ${run.attempt} 次 · ${run.status === "running" ? "进行中" : (RUN_OUT[run.outcome] ?? run.outcome ?? "-")} · ${fmtTime(run.startedAt)} → ${run.endedAt ? fmtTime(run.endedAt) : "进行中"} · ${dur} · 执行者 ${run.actor ?? "-"}${rec?.runsCount > 1 ? `(共 ${rec.runsCount} 次尝试)` : ""}`));
5165
+ // 卡 `-268`(需求 `R184`):**摘要也是执行记录的一部分** —— 只给「起止/耗时/结果」而没有
5166
+ // 「执行方说了什么」,等于只给了账目的骨架。空摘要 ⇒ 如实写「执行方未回写摘要」,
5167
+ // **不拿记账文案冒充执行内容**(服务端已归一;这里的兜底是给未重载的旧服务端留的)。
5168
+ if (run.status !== "running") {
5169
+ const sum = String(run.summary ?? "").trim();
5170
+ rsec.appendChild(mk("p", "hint exec-record-summary", `执行摘要:${sum !== "" ? sum : RUN_SUMMARY_FALLBACK}`));
5171
+ }
5172
+ }
5173
+ if (!evd) {
5174
+ rsec.appendChild(mk("p", "hint", "本卡尚无结构化交付证据(`task_evidence` 无行)—— 证据只存在于执行方自述的评论里,那不是结构化证据。"));
5175
+ } else {
5176
+ for (const [label, value] of [["判定(verdict)", evd.verdict], ["偏离说明(deviation)", evd.deviation], ["边界自查(boundary)", evd.boundary]]) {
5177
+ rsec.appendChild(mk("h4", null, label));
5178
+ rsec.appendChild(String(value ?? "").trim() !== "" ? richText(String(value)) : mk("p", "hint", "(未填写)"));
5179
+ }
5180
+ const arts = Array.isArray(evd.artifacts) ? evd.artifacts : [];
5181
+ rsec.appendChild(mk("h4", null, `产物(${arts.length})`));
5182
+ if (!arts.length) rsec.appendChild(mk("p", "hint", "(未登记产物)"));
5183
+ else {
5184
+ const ul = mk("ul", "exec-record-artifacts");
5185
+ for (const a of arts) ul.appendChild(mk("li", null, String(a)));
5186
+ rsec.appendChild(ul);
5187
+ }
5188
+ const refs = Array.isArray(evd.artifactRefs) ? evd.artifactRefs : [];
5189
+ if (refs.length) {
5190
+ rsec.appendChild(mk("h4", null, `可核验引用(${refs.length})`));
5191
+ const ul = mk("ul", "exec-record-refs");
5192
+ for (const rf of refs) ul.appendChild(mk("li", null, `${rf?.kind ?? "?"} · ${rf?.ref ?? rf?.value ?? rf?.path ?? JSON.stringify(rf)}`));
5193
+ rsec.appendChild(ul);
5194
+ }
5195
+ rsec.appendChild(mk("p", "hint", `证据由 ${evd.actor ?? "未标注"} 于 ${fmtTime(evd.createdAt)} 写入 · 对应任务版本 v${evd.taskVersion ?? "-"}${evd.refsState ? ` · 引用状态 ${evd.refsState}` : ""}`));
5196
+ }
5197
+ }
5198
+ drawerBody.appendChild(rsec);
5199
+ }
5200
+
4955
5201
  // FR-40 补口(2026-10-19 真机):归因门只会拒绝,全前端却**没有归因入口** —— 用户点「启动执行」
4956
5202
  // 只看到「请先关联需求条目(归因门)」,任务编辑对话框没有需求条目字段、也没有对应端点,无处可点。
4957
5203
  // 这里把「引导归因」落成可执行动作:列本项目需求条目 → 选一条 → 关联(跨项目由 store 层拒绝)。
@@ -5273,10 +5519,23 @@
5273
5519
  const ok = await moveTask(t, "todo");
5274
5520
  if (ok) showBanner(`${t.identifier} 已授权开工(待办池 → 可开工)。下一步:点「启动执行」,或让它被团队/执行循环认领。`, "info");
5275
5521
  }, "secondary"));
5522
+ // 卡 `-264`:确认框先回答「交给谁」,回执再回答「实际走了哪条」—— 两处都用服务端同一份判据。
5523
+ const confirmLaunch = () => window.confirm(`启动执行会把主视图切到执行会话。${dispatchSummary ? `\n\n派发目标:${dispatchSummary.text}` : ""}${execRunning ? "\n\n⚠ 该任务已有执行会话正在执行且未返回结论,继续会被拒绝(EXECUTION_ALREADY_RUNNING)。" : ""}\n\n确认继续?`);
5524
+ const launchResultText = (r) => {
5525
+ const launch = r?.launch ?? null;
5526
+ if (launch?.mode === "reuse-bound") return `已复用已绑定空闲会话 ${String(launch.sessionId ?? "").slice(0, 12)}…(${launch?.reusedFrom ? REUSED_FROM_LABEL[launch.reusedFrom] ?? launch.reusedFrom : "已绑定会话"} · ${t.identifier})`;
5527
+ if (launch?.mode === "create-and-authorize") return `已新建执行会话并首次授权(${String(launch.sessionId ?? "").slice(0, 12)}…)—— 无需再申请关联(${t.identifier})${bookDeliveryClause(launch)}`;
5528
+ if (launch?.mode === "degraded") return `派发降级:${launch?.reason ?? "无宿主会话通道"}(${t.identifier})`;
5529
+ return `已下发执行会话 ${String(launch?.sessionId ?? "?").slice(0, 12)}…(${t.identifier})${launch?.fallbackReason ? ` · 回退原因:${launch.fallbackReason}` : ""}`;
5530
+ };
5276
5531
  if (drawerEntry === "start") ops.appendChild(btn("启动执行", async () => {
5277
- if (!window.confirm(`启动执行会尝试新建/切换会话(可能切换主视图)。${execRunning ? "\n\n⚠ 该任务已有执行会话正在执行且未返回结论,继续会被拒绝(EXECUTION_ALREADY_RUNNING)。" : ""}确认继续?`)) return;
5278
- try { await api("POST", `/api/tasks/${ref}/execute`, undefined); closeDrawer(); await loadTasks(); }
5279
- catch (e) {
5532
+ if (!confirmLaunch()) return;
5533
+ try {
5534
+ const r = await api("POST", `/api/tasks/${ref}/execute`, undefined);
5535
+ // 卡 `-272`:任务书未送达 ⇒ 横幅必须转红(与「派发降级」同档),否则等于把「会话不知道要做什么」报成成功。
5536
+ showBanner(launchResultText(r), r?.launch?.mode === "degraded" || bookDeliveryFailed(r?.launch) ? "error" : "info");
5537
+ closeDrawer(); await loadTasks();
5538
+ } catch (e) {
5280
5539
  // 与卡片入口同一份处置(含「打开并高亮归因入口」),不再各写一套措辞。
5281
5540
  await handleExecutionFailure(e, ref, t);
5282
5541
  }
@@ -5323,7 +5582,15 @@
5323
5582
  const fresh = await api("GET", `/api/tasks/${ref}`);
5324
5583
  await api("PATCH", `/api/tasks/${ref}`, { version: fresh?.task?.version, status: "canceled", actor: "human" });
5325
5584
  await api("POST", `/api/tasks/${ref}/comments`, { body: `人工撤单(不执行):${reason}`, actor: "human" });
5326
- closeDrawer(); await loadTasks(); showBanner(`${t.identifier} 已撤单(已取消)—— 依赖它的下游卡需要按「前置已撤单」重估`, "info");
5585
+ // 卡 `-267` / 需求 `R181`(呈现层收口):这条横幅原先写的是「下游卡需要按『前置已撤单』重估」——
5586
+ // 那是 `-253` 之前的服务端口径(撤单不解阻),而 `-253` 已把「撤单 = 前置**终结**」落到了服务端:
5587
+ // 因依赖而受阻的下游**当场**放回「可开工」(事件 `dependency_released` + 评论 + 审计)。
5588
+ // 界面继续说「要人工重估」=「界面承诺 ≠ 实现」的同类缺陷(人在界面上读到的仍是旧口径),
5589
+ // 而且把人引到一条已经不存在的路上 —— 改说真话。
5590
+ // 措辞**刻意带限定语「因依赖而受阻的」**:非依赖类受阻(capability / needs_input / transient)
5591
+ // 是「这张卡自己做不了」,撤掉前置并不会让它做得了 ⇒ 服务端**不**放行(口径见 `releaseDownstreamOnCancel`)。
5592
+ // 横幅只陈述**规则**,不报数(报数就得在界面另立一套判定 ⇒ 必然与服务端口径漂移)。
5593
+ closeDrawer(); await loadTasks(); showBanner(`${t.identifier} 已撤单(已取消)—— 前置已终结:依赖它的下游不再等它;因依赖而受阻的下游已自动放回「可开工」,无需人工重估`, "info");
5327
5594
  } catch (e) {
5328
5595
  showBanner(`撤单失败:${e.message}`, "error");
5329
5596
  }
@@ -5365,6 +5632,35 @@
5365
5632
  : refOrigin.cwd ? `${refOrigin.cwd}${refOrigin.projectId ? `(项目 ${refOrigin.projectId})` : "(不属于任何在册项目)"}` : `判定不可用(${refOrigin.source ?? "未知"})`;
5366
5633
  const ss = exec?.sessionState ?? null;
5367
5634
  const execRunning = Boolean(ss?.sessionId && (ss.running || ((ss.pending ?? 0) > 0)));
5635
+ // 卡 `-264`(需求 `R188`)· **派发目标预览**:点「启动执行」之前就告诉人「这条会交给谁」。
5636
+ // 数据来自服务端 `GET /api/tasks/:ref/execution` 的 `dispatchTarget`(与 `/execute` 共用同一份
5637
+ // `pickDispatchTarget`,所以「预览说 A、执行做 B」不可能发生)。老服务端没有该字段 ⇒ null ⇒ 不显示(不臆断)。
5638
+ const dispatchTarget = exec?.dispatchTarget ?? null;
5639
+ const DISPATCH_ROLE_LABEL = { main: "项目主会话", associated: "已批准关联会话", executor: "执行会话(派生)" };
5640
+ const DISPATCH_WHY_LABEL = {
5641
+ "other-workspace": "工作在别的工作区",
5642
+ "no-liveness": "探活不可用",
5643
+ "session-gone": "会话已失效",
5644
+ "liveness-unknown": "无法判定是否空闲",
5645
+ "running": "正在执行",
5646
+ "pending-prompts": "还有未消费的指令",
5647
+ };
5648
+ const dispatchSummary = (() => {
5649
+ const d = dispatchTarget;
5650
+ if (!d) return null;
5651
+ const short = (id) => (id ? `${String(id).slice(0, 12)}…` : "(未知会话)");
5652
+ if (d.decision === "reuse" && d.target?.sessionId) {
5653
+ return { tone: "info", text: `将复用${DISPATCH_ROLE_LABEL[d.target.role] ?? "已绑定会话"} ${short(d.target.sessionId)}(已绑定本项目且此刻空闲)` };
5654
+ }
5655
+ if (d.decision === "degraded" || d.hostAvailable === false) {
5656
+ return { tone: "warn", text: "宿主会话通道不可用:派发会降级(不建会话、不投递),需先在宿主里加载本插件。" };
5657
+ }
5658
+ const busy = (d.candidates ?? []).filter((c) => !c.idle);
5659
+ const whyText = busy.length
5660
+ ? `已绑定的 ${busy.length} 条会话都不可用(${[...new Set(busy.map((c) => DISPATCH_WHY_LABEL[c.why] ?? c.why))].join(" / ")})`
5661
+ : "本项目还没有绑定过会话";
5662
+ return { tone: "warn", text: `${whyText}:点「启动执行」会新建一条执行会话,并**当场首次授权**绑定本项目(不必再去申请关联)。` };
5663
+ })();
5368
5664
  const sessionStateLabel = !ss?.sessionId
5369
5665
  ? "未关联(降级)"
5370
5666
  : execRunning ? `执行中${ss.pending ? `(待消费 ${ss.pending})` : ""}`
@@ -5412,6 +5708,14 @@
5412
5708
  ["最近进展", fmtTime(lastProgress)],
5413
5709
  ["连续失败", `${exec?.consecutiveFailures ?? 0} / ${exec?.failureLimit ?? 2}`],
5414
5710
  ]));
5711
+ // 卡 `-257`(需求 `R183`)· **「打开执行会话」与 CLI 执行记录同源**:
5712
+ // CLI 执行器(claude / codex / hermes)默认**经项目主会话下发**并跟踪,任务级会话引用会被
5713
+ // 绑成项目主会话 —— 执行记录就在那条会话里。不把这句话写出来,「会话标识」一栏只是换了个 id,
5714
+ // 人不知道点「打开执行会话」到底能看到什么(真机 `-246` 的原话就是「打开执行会话没有看到记录」)。
5715
+ const projMainId = (state.projects ?? []).find((p) => p.id === t.projectId)?.initialSessionId ?? null;
5716
+ if (execSession && projMainId && String(execSession) === String(projMainId)) {
5717
+ execSec.appendChild(mk("p", "hint", "本任务绑定的是**项目主会话**:CLI 执行器(claude / codex / hermes)的派单与执行记录都在这里 —— 点「打开执行会话」直达该会话;跑完由主会话回写四节证据并提交「待验收」。"));
5718
+ }
5415
5719
  // FR-84 补口(2026-10-23)· **实例工作区预检**(说清「为什么重建也可能不对」):
5416
5720
  // 一个 DSH 实例只有一个工作区,宿主不提供切换(`uiWorkspace` 不可用)⇒ 在看板里切项目
5417
5721
  // **不会**让宿主换工作区,本实例建出的会话只会落在实例自己的工作区上。
@@ -5615,7 +5919,7 @@
5615
5919
  // 在此之前只有 API(POST /api/tasks/:ref/exec-cli),看板上点不到 —— 这一区补的就是那个入口。
5616
5920
  const cliSec = mk("div", "drawer-section");
5617
5921
  cliSec.appendChild(mk("h3", null, "CLI 执行器(真实执行)"));
5618
- cliSec.appendChild(mk("p", "hint", "把该任务交给项目配置的 CLI 执行器(teamTemplate.roles[].executor = cli:*,且不在 forbiddenExecutors 中)真实执行:非交互调用 → 采集退出码 / 耗时 / 本次改动差集 → 写回评论 + 尝试记录;成功转「待验收」,失败走统一受阻入口。执行前会先认领并把卡片置为「进行中」——即使它原先在待办池等其它列,执行期也会如实显示在「进行中」,跑完再回到「待验收」。"));
5922
+ cliSec.appendChild(mk("p", "hint", "把该任务交给 CLI 执行器(teamTemplate.roles[].executor = cli:*,且不在 forbiddenExecutors 中)执行:**默认交项目主会话下发并跟踪** —— 命令与回写要求投给主会话,执行记录留在那条会话里(「打开执行会话」直达),跑完由主会话写四节证据并把卡提交「待验收」。执行前会先认领并把卡片置为「进行中」(原为 todo 则走授权门)。无主会话通道的实例(独立进程 / 隔离验证台)会回落服务端直跑,并在卡片评论里留痕「执行记录不在任何会话里」。"));
5619
5923
  // 卡 `-238`(R174):CLI 区也放一个**只含 CLI 形态**的选择器(放团队/宿主会话只会点出必然的 400)。
5620
5924
  // 「预览 / 执行」都按这里选的那个走 —— 否则选了 codex 却预览 claude,预览就在骗人。
5621
5925
  const cliPicker = cliEntry(t) === "start" ? mountExecutorPicker(t, {
@@ -5650,16 +5954,37 @@
5650
5954
  }));
5651
5955
  const cliEntryKind = cliEntry(t);
5652
5956
  if (cliEntryKind === "start") cliBar.appendChild(btn("交给 CLI 执行器执行", async () => {
5653
- if (!window.confirm(`确认把 ${t.identifier} 交给 CLI 执行器**真实执行**?\n\n· 非交互调用本地 CLI(通常带文件写权限),耗时数十秒到数分钟\n· 执行前先认领:卡片将被置为「进行中」(原为 todo 则走授权门)\n· 完成后看板自动刷新为「待验收」或「受阻」,并附退出码/耗时/改动清单\n· 期间请勿重复点击`)) return;
5957
+ if (!window.confirm(`确认把 ${t.identifier} 交给 CLI 执行器执行?\n\n· 下发:交「项目主会话」下发并跟踪 —— 执行记录留在该会话里,「打开执行会话」直达\n· 执行:非交互调用本地 CLI(通常带文件写权限),耗时数十秒到数分钟\n· 执行前先认领:卡片将被置为「进行中」(原为 todo 则走授权门)\n· 跑完由主会话回写四节证据并提交「待验收」(或写清失败原因);完成仍由人确认\n· 期间请勿重复点击`)) return;
5654
5958
  try {
5655
5959
  const r = await api("POST", `/api/tasks/${ref}/exec-cli`, { async: true, executor: cliPicker?.selected() ?? undefined });
5656
- cliOut.textContent = [
5657
- `已提交后台执行:${r.executor ?? "—"}(CLI:${r.plan?.cli ?? "—"})`,
5658
- `工作目录:${r.plan?.cwd ?? "—"}`,
5659
- "",
5660
- "执行完成后看板评论会给出退出码 / 耗时 / 改动清单;本页点「刷新」即可看到。",
5661
- ].join("\n");
5662
- showBanner(`已提交 CLI 执行器(${r.executor ?? "cli"})后台执行,完成后看板自动刷新`, "info");
5960
+ if (r?.via === "main-session" && r.delivered === false) {
5961
+ cliOut.textContent = [
5962
+ `未下发:${r.reason ?? "原因未知"}`,
5963
+ `会话:${r.sessionId ?? "—"}(来源 ${r.source ?? "未知"})`,
5964
+ "",
5965
+ `下一步:${r.nextAction ?? "先确认主会话可用后重试"}`,
5966
+ ].join("\n");
5967
+ showBanner(`未下发:${r.reason ?? "原因未知"}(未回落直跑)`, "error");
5968
+ return;
5969
+ }
5970
+ cliOut.textContent = r?.via === "main-session"
5971
+ ? [
5972
+ `已交项目主会话下发:${r.executor ?? "—"}(CLI:${r.plan?.cli ?? "—"})`,
5973
+ `会话:${r.sessionId ?? "—"}(来源 ${r.source ?? "未知"})→ 点「打开执行会话」直达`,
5974
+ `工作目录:${r.plan?.cwd ?? "—"}`,
5975
+ "",
5976
+ "执行记录就在该会话里;跑完由主会话写四节证据并提交「待验收」(或写清失败原因)。",
5977
+ ].join("\n")
5978
+ : [
5979
+ `已提交后台执行:${r?.executor ?? "—"}(CLI:${r?.plan?.cli ?? "—"})`,
5980
+ `工作目录:${r?.plan?.cwd ?? "—"}`,
5981
+ r?.fallbackReason ? `⚠ 未走主会话(${r.fallbackReason}):本次执行记录**不在任何会话里**(卡片评论已留痕)` : "",
5982
+ "",
5983
+ "执行完成后看板评论会给出退出码 / 耗时 / 改动清单;本页点「刷新」即可看到。",
5984
+ ].filter(Boolean).join("\n");
5985
+ showBanner(r?.via === "main-session"
5986
+ ? `已交项目主会话下发(${r.executor ?? "cli"}),执行记录在会话 ${String(r.sessionId ?? "").slice(0, 12)}…`
5987
+ : `已提交 CLI 执行器(${r?.executor ?? "cli"})后台执行,完成后看板自动刷新`, "info");
5663
5988
  await loadTasks();
5664
5989
  } catch (e) {
5665
5990
  showBanner(`提交失败:${e.message}`, "error");
@@ -5776,7 +6101,14 @@
5776
6101
  head.appendChild(mk("span", "run-time", `${started} · ${dur}`));
5777
6102
  head.appendChild(mk("span", "run-heartbeats", `心跳 ${run.heartbeats}${run.maxMs ? ` · 上限 ${Math.round(run.maxMs / 60000)}m` : ""}`));
5778
6103
  row.appendChild(head);
5779
- if (run.summary) row.appendChild(mk("p", "hint run-summary", run.summary));
6104
+ // 卡 `-268`(需求 `R184`):空摘要**如实显示「执行方未回写摘要」**,不再静默留白 ——
6105
+ // 「没写」与「写了句空话」在人眼里都是空白,但前者该说清楚。服务端已归一(读路径兜住
6106
+ // 库里 22 行记账文案 + 7 行空摘要),这里的兜底是给未重载的旧服务端留的。
6107
+ {
6108
+ const sum = String(run.summary ?? "").trim();
6109
+ if (sum !== "") row.appendChild(mk("p", "hint run-summary", sum));
6110
+ else if (run.status !== "running") row.appendChild(mk("p", "hint run-summary", RUN_SUMMARY_FALLBACK));
6111
+ }
5780
6112
  if (run.error) row.appendChild(mk("p", "hint run-error", `错误:${run.error}`));
5781
6113
  table.appendChild(row);
5782
6114
  }
@@ -5997,8 +6329,12 @@
5997
6329
  catch (e) { showBanner(`授权失败:${e.message}`, "error"); }
5998
6330
  },
5999
6331
  "start-execution": async () => {
6000
- if (!window.confirm(`启动执行会尝试新建/切换会话(可能切换主视图)。${execRunning ? "\n\n⚠ 该任务已有执行会话正在执行且未返回结论,继续会被拒绝(EXECUTION_ALREADY_RUNNING)。" : ""}确认继续?`)) return;
6001
- try { await api("POST", `/api/tasks/${ref}/execute`, undefined); closeDrawer(); await loadTasks(); }
6332
+ if (!confirmLaunch()) return;
6333
+ try {
6334
+ const r = await api("POST", `/api/tasks/${ref}/execute`, undefined);
6335
+ showBanner(launchResultText(r), r?.launch?.mode === "degraded" ? "error" : "info");
6336
+ closeDrawer(); await loadTasks();
6337
+ }
6002
6338
  // 第三条入口(下一步面板):此前是裸 catch,同一次失败换条路进来就没有归因引导了。
6003
6339
  catch (e) { await handleExecutionFailure(e, ref, t); }
6004
6340
  },
@@ -6081,10 +6417,16 @@
6081
6417
  } else {
6082
6418
  sec.appendChild(mk("div", "next-step-title", step.title));
6083
6419
  if (step.hint) sec.appendChild(mk("p", "hint", step.hint));
6420
+ // 卡 `-264`:派发目标预览(复用谁 / 会新建并首次授权)—— 只在「这张卡还能派」时服务端才给该字段。
6421
+ if (dispatchSummary && (cliEntry(t) === "start" || executionEntry(t) === "start")) {
6422
+ const line = mk("p", "hint", `派发目标:${dispatchSummary.text}`);
6423
+ line.dataset.dispatchDecision = dispatchTarget?.decision ?? "";
6424
+ sec.appendChild(line);
6425
+ }
6084
6426
  // 卡 `-238`(R174):执行者图标行 —— 只在**这张卡真的能执行**时出现(能走 CLI 或能走宿主/团队)。
6085
6427
  // 单独一行、不抢主按钮层级:原有「启动执行」仍是主色,本行是「换谁跑」的选择器。
6086
6428
  if (cliEntry(t) === "start" || executionEntry(t) === "start") {
6087
- sec.appendChild(mountExecutorPicker(t, { onDone: () => void reopen() }).node);
6429
+ sec.appendChild(mountExecutorPicker(t, { onDone: () => void reopen(), dispatchHint: dispatchSummary }).node);
6088
6430
  }
6089
6431
  // 操作顺序:异常/待办卡不许只丢几个并列按钮让人自己猜先点哪个(FR-89 第二条约束)。
6090
6432
  if (Array.isArray(step.steps) && step.steps.length) {
@@ -6201,10 +6543,12 @@
6201
6543
  teamRoot.replaceChildren(mk("p", "hint", "加载团队…"));
6202
6544
  try {
6203
6545
  const q = encodeURIComponent(state.projectId);
6204
- const [data, settings, avail] = await Promise.all([
6546
+ const [data, settings, avail, bridge] = await Promise.all([
6205
6547
  api("GET", "/api/teams"),
6206
6548
  api("GET", `/api/projects/${q}/settings`).catch(() => ({ teamTemplate: {} })),
6207
6549
  api("GET", `/api/projects/${q}/agent-teams`).catch(() => ({ teams: [] })),
6550
+ // 卡 `-247`(需求 `R178` ④):团队任务 ↔ 看板卡映射(只读同步器)。
6551
+ api("GET", `/api/projects/${q}/team-bridge`).catch(() => null),
6208
6552
  ]);
6209
6553
  const box = mk("div", "config-view");
6210
6554
  const cur = mk("section", "config-card");
@@ -6262,8 +6606,31 @@
6262
6606
  for (const t of (avail.teams || [])) { const li = mk("li", "req-item"); li.append(mk("span", "req-title", t.name), pill(`${t.source}${t.phase ? ` · ${t.phase}` : ""}${t.memberCount != null ? ` · ${t.memberCount} 成员` : ""}`)); avl.appendChild(li); }
6263
6607
  av.appendChild(avl);
6264
6608
  box.appendChild(av);
6609
+ // 卡 `-247`(需求 `R178` ④):**团队任务 ↔ 看板卡映射**(只读同步器)。
6610
+ // 这一段是「两套系统」的**桥**:把插件侧 t-id 与看板卡号摆到同一张表上;
6611
+ // 未登记的卡明说「看板只展示、不参与团队状态」——不写"没有团队在跑"(那是猜)。
6612
+ const bx = mk("section", "config-card");
6613
+ bx.appendChild(mk("h3", null, "团队任务 ↔ 看板卡映射(只读同步)"));
6614
+ if (!bridge) {
6615
+ bx.appendChild(mk("p", "hint", "读不到映射(服务端较旧)——本项目暂无团队任务 ↔ 看板卡的对照。"));
6616
+ } else {
6617
+ const st = bridge.stats ?? {};
6618
+ bx.appendChild(mk("p", "hint", `本项目卡 ${st.cards ?? 0} 张 · 已反查到团队任务 ${st.mappedCards ?? 0} 张 · 未登记 ${st.unmappedCards ?? 0} 张 · 插件团队 ${st.pluginTeams ?? 0} 个 / 团队任务 ${st.pluginTasks ?? 0} 条。`));
6619
+ bx.appendChild(mk("p", "hint", "口径:映射由「项目自有卡号在团队任务文本里全词命中」推导(插件侧 team.json 没有卡号字段),属只读同步;看板与团队各记各的账,互不驱动。"));
6620
+ const bl = mk("div", "team-task-list");
6621
+ for (const r of bridge.mappings || []) {
6622
+ const row = mk("div", "team-task-row");
6623
+ row.append(mk("span", null, r.cardIdentifier));
6624
+ row.append(pill(r.teamTaskStatus ?? "?", r.teamTaskStatus === "completed" ? "ok" : r.teamTaskStatus === "failed" ? "danger" : "warn"));
6625
+ row.append(mk("span", null, `${r.teamTaskId} · ${r.teamName}`), mk("div", "spacer"), mk("span", "hint", r.assignee ? `负责 ${r.assignee}` : "未指派"));
6626
+ bl.appendChild(row);
6627
+ }
6628
+ if (!(bridge.mappings || []).length) bl.appendChild(mk("div", "empty-note", "本项目暂无卡反查到团队任务(插件团队未在本工作区登记本项目卡号)"));
6629
+ bx.appendChild(bl);
6630
+ }
6631
+ box.appendChild(bx);
6265
6632
  box.appendChild(mk("h2", null, `工作台本地派发记录(${data.count})`));
6266
- box.appendChild(mk("p", "hint", "数据来源:工作台本地记录(team_runs/team_members/team_tasks)——与承载环境 agent-team 插件的「编队」是两套;插件侧真实团队成员不在此显示(见 G-2)。"));
6633
+ box.appendChild(mk("p", "hint", "数据来源:工作台本地记录(team_runs/team_members/team_tasks)——与承载环境 agent-team 插件的「编队」是两套账本;两边的对照见上一节「团队任务 ↔ 看板卡映射(只读同步)」;插件侧真实团队成员不在此显示(见 G-2)。"));
6267
6634
  if (!data.count) box.appendChild(mk("p", "hint", "暂无团队派发记录。派发入口:任务详情/看板 → 启动执行,或调用 /api/teams。"));
6268
6635
  for (const entry of data.teams) box.appendChild(teamDetailCard(entry));
6269
6636
  teamRoot.replaceChildren(box);