agent-tune-kit 2.4.0__tar.gz → 2.4.1__tar.gz

{agent_tune_kit-2.4.0 → agent_tune_kit-2.4.1}/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-tune-kit",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "description": "Local Codex plugin for batch Agent evaluation and session trace tuning with evidence-backed issues, focused changes, verification and offline review.",
   "author": {
     "name": "hustyichi",

{agent_tune_kit-2.4.0 → agent_tune_kit-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agent-tune-kit
-Version: 2.4.0
+Version: 2.4.1
 Summary: Local Codex plugin for iterative Agent tuning with guided Skills, reusable runner templates, versioned results, and static validation.
 Project-URL: Homepage, https://github.com/hustyichi/agent-tune-kit
 Project-URL: Repository, https://github.com/hustyichi/agent-tune-kit

{agent_tune_kit-2.4.0 → agent_tune_kit-2.4.1}/agent_tune_kit/__init__.py

@@ -1,3 +1,3 @@
 """Agent Tune Kit package."""
 
-__version__ = "2.4.0"
+__version__ = "2.4.1"

{agent_tune_kit-2.4.0 → agent_tune_kit-2.4.1}/agent_tune_kit/visualize/assets/trace/app.js

@@ -423,7 +423,7 @@
     const issue = item.record;
     openDrawer(`${issue.id} · ${issue.title || "问题详情"}`, "issue");
     const tabs = el("nav", undefined, "stage-tabs"); tabs.setAttribute("aria-label", "问题处理阶段");
-    for (const [key, label] of [["issue", "问题与片段"], ["diagnoses", "诊断与方案"], ["changes", "修改候选"], ["verifications", "实际验证"]]) {
+    for (const [key, label] of [["issue", "问题详情"], ["diagnoses", "诊断与方案"], ["changes", "修改候选"], ["verifications", "实际验证"]]) {
       const tab = button(label, () => showIssue(item, key), key === stage ? "active" : "");
       tab.setAttribute("aria-pressed", String(key === stage)); tabs.append(tab);
     }
@@ -439,17 +439,6 @@
       }
       const segments = issue.segments || [];
       if (!segments.length) $("drawer-content").append(el("p", "该问题尚未圈定片段，可查看已记录的关联证据。", "muted"));
-      if (segments.length) {
-        const box = section("关联片段");
-        segments.forEach((segment, index) => {
-          const row = el("div", undefined, "detail-section");
-          const title = `${segment.id || `S${index + 1}`} · ${segment.summary || "未命名片段"}`;
-          row.append(button(title, () => startIssue(item, item.fragments.findIndex(part => part.id === segment.id || (!part.id && index === item.fragments.indexOf(part))))));
-          appendReferences(row, segment.evidence || []);
-          box.append(row);
-        });
-        $("drawer-content").append(box);
-      }
       if ((issue.evidence || []).length) {
         const evidence = section(segments.length ? "额外证据" : "关联证据");
         appendReferences(evidence, issue.evidence);
@@ -631,16 +620,31 @@
         return (left.at ?? Infinity) - (right.at ?? Infinity) || left.track - right.track || a - b;
       });
     }
-    return candidates.filter(i => {
+    const rows = candidates.filter(i => {
       const n = currentCapture.nodes[i];
       if ((track !== null && n.track !== track) || (type && n.type !== type)) return false;
-      if (mode === "error" && !eventState(n).failed) return false;
       if (query) {
         if (!searchable.has(n)) searchable.set(n, pretty(n).toLocaleLowerCase());
         return searchable.get(n).includes(query);
       }
       return true;
     });
+    // The failure switch shows its count before it is chosen, so count within every other active scope and filter.
+    const failed = rows.filter(i => eventState(currentCapture.nodes[i]).failed);
+    return {rows: mode === "error" ? failed : rows, total: rows.length, failed: failed.length};
+  }
+  function syncRecordMode(failed) {
+    const only = $("record-mode").value === "error";
+    $("record-all").setAttribute("aria-pressed", String(!only));
+    $("record-failed").setAttribute("aria-pressed", String(only));
+    $("record-failed-count").textContent = String(failed);
+    // Keep an active switch usable at zero so the selection stays visible; otherwise zero means nothing to look at.
+    $("record-failed").disabled = !only && failed === 0;
+    $("record-failed").title = failed || only ? `只看执行失败的事件（${failed} 条）` : "当前范围没有执行失败的事件";
+  }
+  function setRecordMode(mode) {
+    $("record-mode").value = mode;
+    renderTraces();
   }
   function eventState(n) {
     const out = n.output, input = n.input;
@@ -859,7 +863,7 @@
       if (state.failed) {
         row.classList.add("is-error");
         const icon = el("span", "⚠", "event-error-icon");
-        icon.setAttribute("role", "img"); icon.setAttribute("aria-label", "执行异常"); icon.title = "执行异常";
+        icon.setAttribute("role", "img"); icon.setAttribute("aria-label", "执行失败"); icon.title = "执行失败";
         label.append(icon);
       }
       label.append(el("span", name, "node-name"));
@@ -963,9 +967,12 @@
     $("summary").textContent = notes.join(" · ");
     $("session-stats").textContent = `${native.length} Trace · ${order.length} 条事件 · ${data.issues.length} 问题`;
     scroller.parentElement.classList.toggle("single", tracks.length === 1 || displayedScope !== null);
-    streamRows = filteredRows();
+    const filtered = filteredRows();
+    streamRows = filtered.rows;
+    syncRecordMode(filtered.failed);
     displayRows = buildDisplayRows(streamRows);
-    $("trace-count").textContent = `${streamRows.length} 条`;
+    $("trace-count").textContent = $("record-mode").value === "error"
+      ? `失败 ${streamRows.length} / ${filtered.total} 条` : `${streamRows.length} 条`;
     if (eventFocus) $("trace-count").textContent = streamRows.length === eventFocus.indices.length
       ? `${streamRows.length} 条事件` : `${streamRows.length} / ${eventFocus.indices.length} 条事件`;
     const related = new Set((investigation?.item.fragments || []).filter(p => p.capture_id === currentCapture?.id).flatMap(p => p.anchors));
@@ -1289,7 +1296,9 @@
   if (currentCapture) $("capture-filter").value = currentCapture.id;
   $("capture-filter").onchange = () => { investigation = null; scopeBefore = null; railFilter = null; chooseCapture(); renderIssueRail(); renderTraces(); };
   $("trace-filter").onchange = () => focusTrace(scope());
-  for (const id of ["trace-search","type-filter","record-mode"]) $(id).addEventListener(id === "trace-search" ? "input" : "change", () => renderTraces());
+  for (const id of ["trace-search","type-filter"]) $(id).addEventListener(id === "trace-search" ? "input" : "change", () => renderTraces());
+  $("record-all").onclick = () => setRecordMode("");
+  $("record-failed").onclick = () => setRecordMode("error");
   $("issue-search").oninput = () => { railFilter = null; renderIssueRail(); };
   const collapsed = localStorage.getItem(RAIL_KEY) === "1";
   document.body.classList.toggle("rail-collapsed", collapsed);

{agent_tune_kit-2.4.0 → agent_tune_kit-2.4.1}/agent_tune_kit/visualize/assets/trace/page.html

@@ -60,9 +60,8 @@
       </section>
       <section class="record-panel" aria-labelledby="records-title">
         <div class="records-heading">
-          <div class="records-title"><h2 id="records-title">事件</h2><span id="event-range" class="muted" hidden></span><span id="trace-count" class="muted" aria-live="polite"></span><button id="event-reset" type="button" hidden>返回全部</button></div>
+          <div class="records-title"><h2 id="records-title">事件</h2><div class="record-mode" role="group" aria-label="事件范围"><input id="record-mode" type="hidden" value=""><button id="record-all" type="button" aria-pressed="true">全部</button><button id="record-failed" type="button" aria-pressed="false"><span class="record-failed-icon" aria-hidden="true">⚠</span>失败 <span id="record-failed-count" class="record-failed-count">0</span></button></div><span id="event-range" class="muted" hidden></span><span id="trace-count" class="muted" aria-live="polite"></span><button id="event-reset" type="button" hidden>返回全部</button></div>
           <div class="toolbar record-filters">
-            <label><span class="sr-only">事件范围</span><select id="record-mode"><option value="">全部事件</option><option value="error">仅看异常</option></select></label>
             <label><span class="sr-only">类型</span><select id="type-filter"></select></label>
             <label class="search-label"><span class="sr-only">搜索事件</span><input id="trace-search" type="search" placeholder="搜索事件或输入输出"></label>
           </div>

{agent_tune_kit-2.4.0 → agent_tune_kit-2.4.1}/agent_tune_kit/visualize/assets/trace/styles.css

@@ -153,13 +153,24 @@ body.rail-collapsed .rail-list { padding-inline: 4px }
 .toolbar { flex-wrap: wrap; gap: 8px }
 .record-filters { gap: 8px; max-width: 100% }
 .record-filters label { display: block; min-width: 0 }
-#record-mode { width: 104px }
+/* Failure-only viewing is a visible two-state switch next to the title, not a dropdown, so the failure count shows
+   before anyone filters. */
+.record-mode { display: inline-flex; flex-shrink: 0; border: 1px solid var(--line); border-radius: 6px; overflow: hidden; background: white }
+.record-mode button { display: inline-flex; align-items: center; gap: 4px; min-height: 26px; padding: 2px 10px; border: 0; border-radius: 0; background: transparent; color: var(--muted); font-size: 12px; white-space: nowrap }
+.record-mode button + button { border-left: 1px solid var(--line) }
+.record-mode button:hover:not(:disabled) { background: var(--tint) }
+.record-mode button[aria-pressed=true] { background: var(--tint); color: var(--accent); font-weight: 600 }
+.record-mode #record-failed[aria-pressed=true] { background: #fff2f1; color: #b12c21; box-shadow: inset 0 -2px #c0392b }
+.record-failed-icon, .record-failed-count { color: #b12c21 }
+.record-failed-count { font-weight: 600; font-variant-numeric: tabular-nums }
+.record-mode button:disabled { opacity: 1; color: #9aa8b2 }
+.record-mode button:disabled :is(.record-failed-icon, .record-failed-count) { color: inherit; font-weight: 400 }
 #type-filter { width: 142px }
 #trace-search { width: 208px }
 .toolbar select:has(option:checked:not([value=""])) { border-color: #deb493; color: var(--accent) }
 @container (max-width: 650px) {
   .record-filters { display: grid; width: 100%; grid-template-columns: repeat(2,minmax(0,1fr)) }
-  .record-filters :is(#record-mode,#type-filter,#trace-search) { width: 100% }
+  .record-filters :is(#type-filter,#trace-search) { width: 100% }
   .record-filters .search-label { grid-column: 1/-1 }
 }
 .stream { overflow: hidden; max-height: 100vh; max-height: 100dvh }

{agent_tune_kit-2.4.0 → agent_tune_kit-2.4.1}/agent_tune_kit/visualize/assets/traces/app.js

@@ -74,8 +74,13 @@
 
   // --- small building blocks ------------------------------------------------------------------------------------
   const countBy = issues => { const counts = new Map(); for (const issue of issues) counts.set(issue.progress, (counts.get(issue.progress) || 0) + 1); return counts; };
-  const topProgress = counts => [...counts].sort((a, b) => b[1] - a[1] || ORDER.get(a[0]) - ORDER.get(b[0])).slice(0, 2).map(([key, n]) => `${LABEL.get(key)} ${n}`).join(" · ");
   const flag = (text, bad) => el("span", text, bad ? "flag bad" : "flag");
+  // Cards do not repeat routine progress (the state filter and drawers carry it); they only flag the same results the
+  // session attention notes call out: failed verification and inconclusive verdicts.
+  const attentionFlags = counts => [
+    ...(counts.get("fail") ? [flag(`验证失败 ${counts.get("fail")}`, true)] : []),
+    ...(counts.get("inconclusive") ? [flag(`无法判断 ${counts.get("inconclusive")}`)] : []),
+  ];
   const copyText = async text => {
     try { await navigator.clipboard.writeText(text); return true; } catch { /* file:// pages may refuse; fall back below */ }
     try {
@@ -262,7 +267,7 @@
     if (matched.length) {
       const counts = countBy(matched);
       const row = el("div", undefined, "card-count");
-      row.append(el("strong", `${matched.length} 个问题`), el("span", topProgress(counts), "muted"));
+      row.append(el("strong", `${matched.length} 个问题`), ...attentionFlags(counts));
       card.append(row);
     } else card.append(el("div", "无保留问题（不代表会话正确）", "card-count muted"));
     const perCategory = new Map(); let none = 0;
@@ -308,9 +313,9 @@
     card.append(head, el("div", info ? info.definition : "分类词表中没有这条分类，按分类 ID 显示。", "card-definition"));
     const counts = countBy(items.map(item => item.issue));
     const row = el("div", undefined, "card-count");
-    row.append(el("strong", `${new Set(items.map(item => item.s.dir)).size} 个会话 · ${items.length} 个问题`), el("span", latestOf(items) < 0 ? "发生时间未记录" : `最近发生 ${when(latestOf(items))}`, "muted"));
+    row.append(el("strong", `${new Set(items.map(item => item.s.dir)).size} 个会话 · ${items.length} 个问题`), el("span", latestOf(items) < 0 ? "发生时间未记录" : `最近发生 ${when(latestOf(items))}`, "muted"), ...attentionFlags(counts));
     card.append(projectLine(items.map(({issue}) => issue)));
-    card.append(row, el("div", topProgress(counts), "card-meta"));
+    card.append(row);
     return card;
   }
   // The distinct projects behind a group of issues; each offered name narrows the issue view to that project.

{agent_tune_kit-2.4.0 → agent_tune_kit-2.4.1}/agent_tune_kit/visualize/trace.py

@@ -251,7 +251,9 @@ def build_trace_data(project_root, *, session_id, source=None):
         display_refs = list(record.get("evidence", []))
         for segment in record.get("segments", []):
             display_refs.extend(segment.get("evidence", []))
-        evidence = [references[_reference_key(ref)] for ref in display_refs if _reference_key(ref) in references]
+        # Shared evidence keeps one display index so it cannot reappear as an unclaimed point.
+        display_keys = dict.fromkeys(_reference_key(ref) for ref in display_refs)
+        evidence = [references[key] for key in display_keys if key in references]
         # Fragment refs index into this combined list (top-level + segment evidence).
         item["evidence"] = evidence
         segments = record.get("segments") or []

{agent_tune_kit-2.4.0 → agent_tune_kit-2.4.1}/docs/trace-dashboard-design.md

@@ -149,7 +149,7 @@
 | 会话卡片、分类卡片 | 与 `.issue-card` 相同：白底、`--line` 边框、8px 圆角；悬停时 `--tint` 底色和 `#e4b89b` 边框；选中时左侧 3px `--brand` 内描边 |
 | ID 文本 | `.issue-id-text`：`--accent` 色、等宽、12px 粗体 |
 | 分类标签 | `.seg-chip` 配色：`#fff8f1` 底、`--accent` 文字、4px 圆角 |
-| 进度条 | 不使用（2026-11-11 确认）：页签顶部不展示通用进度条或概况指标块，会话卡片和分类卡片也不展示进度条，处理分布只用文字表达 |
+| 进度条 | 不使用（2026-11-11 确认）：页签顶部不展示通用进度条或概况指标块，会话卡片和分类卡片也不展示进度条或常规进度文字，只用提醒标记写验证失败和无法判断 |
 | 提醒 | 与 `.warning` 相同的黄底边框；卡片内使用紧凑版 |
 | 抽屉 | 同一 `.drawer`：右侧覆盖、非模态、默认 480px、可拖宽；窄屏从底部弹出；`Esc` 关闭。大盘的抽屉是进入会话页前的预览（2026-11-10 起）：点击页面空白处、再次点击当前卡片或按 `Esc` 关闭，点击其他卡片直接切换；点击抽屉内、筛选、搜索、页签和链接不关闭；出现时有 0.18 秒滑入，系统要求减少动效时不播放。单会话页抽屉不变 |
 | 抽屉中的问题列表 | 行样式参照 `.trace-row`：40px 行高、`#edf0f3` 分隔线、悬停 `#f5f9fa`；进度用 `.progress-dot` |
@@ -172,7 +172,7 @@
 
 - **维度切换**：默认显示会话维度，当前维度写入 URL hash。
 - **顶栏统计**（2026-11-11 确认）：只写会话数、问题数；所有会话环境相同时追加“环境 <environment>”。不写获取方式（`source.type`，如 `local` 本地导入），也不写页面生成时间。
-- **页签内容**（2026-11-11 确认）：不展示四块概况指标或通用进度条。会话页只在存在无法判断、验证失败或记录读取失败时显示按会话去重的关注提示；问题页保留紧凑的处理状态筛选。下方卡片、卡片内文字形式的问题分布及详情抽屉保留。
+- **页签内容**（2026-11-11 确认）：不展示四块概况指标或通用进度条。会话页只在存在无法判断、验证失败或记录读取失败时显示按会话去重的关注提示；问题页保留紧凑的处理状态筛选。下方卡片及详情抽屉保留。卡片不重复常规进度（待诊断、已诊断、验证通过等），只在存在验证失败或无法判断时在数量行末加提醒标记，口径与会话页关注提示一致（2026-11-11 确认）。按状态查看用处理状态筛选，单个问题的进度在抽屉列表中显示。
 - **筛选**：搜索（Session ID、Issue ID、标题、分类名）和来源在两个维度间共享。处理状态和关联项目仅作用于问题页，切回时恢复选择；状态选项包含“全部”和数量不为 0 的状态，再次点击已选状态或选择“全部”取消状态筛选。项目有多个来源时才显示来源/环境下拉框。
 - **数量口径**：状态选项数量按搜索、来源及关联项目范围统计，便于切换状态；分类卡片、排序、未分类通栏及抽屉中的匹配数量按全部当前筛选计算。只有筛选生效时显示结果数量和“清除筛选”，该按钮清除当前维度生效的筛选。
 
@@ -183,7 +183,7 @@
 │ SES_…830912             ⧉    │ │ cb27cb0f-…              ⧉    │
 │ 发生于 11-06 12:55           │ │ 发生于 11-09 15:01           │
 │                              │ │                              │
-│ 11 个问题  已诊断 8 · 待诊断 3 │ │ 3 个问题  待诊断 2 · 无法判断 1│
+│ 11 个问题                    │ │ 3 个问题  [无法判断 1]        │
 │                              │ │ ⚠ 预览需刷新                  │
 │ 未分类 11                    │ │ 未分类 3                     │
 └──────────────────────────────┘ └──────────────────────────────┘
@@ -196,7 +196,7 @@
 | 会话身份 | 缩短的 Session ID，悬停显示全称，可复制 |
 | 发生时间 | 会话本身的开始时间：保留轨迹中最早的事件时间，悬停显示开始至结束；无可用事件时间时写“发生时间未记录”。不显示导入、检测、诊断、修复等处理时间，后者只用于判断预览是否需刷新。无时区的事件时间按运行 ATK 的机器时区解释，与单会话页一致 |
 | 来源 | 仅在存在多个来源时显示，写“环境 <environment>”；环境重名时追加实例，与来源下拉框同样的标签 |
-| 问题数与处理分布 | 问题数后用文字写数量最多的两档实际进度，不展示进度条 |
+| 问题数与提醒 | 只写问题数；存在验证失败或无法判断时行末加“验证失败 N”（红色）或“无法判断 N”（黄色）标记。不展示进度条或常规进度 |
 | 主要分类 | 最多 3 个分类标签及数量，其余显示为 `+N`；点击标签切到问题维度并定位该分类 |
 | 提醒 | 仅在需要处理时出现：预览需刷新、记录读取失败 |
 
@@ -234,14 +234,14 @@
 │ Shell 路径/参数传递导致反复重试     │ │ 宣称完成但验收证据不足            │
 │ 工具调用因相对路径、stdin 或变量…  │ │ 交付结论缺少同条件的行为验证…     │
 │ 4 个会话 · 4 个问题 最近发生 11-09│ │ 3 个会话 · 5 个问题 最近发生 11-09│
-│ 已诊断 2 · 待诊断 2                │ │ 已诊断 3 · 待诊断 2                │
+│                                  │ │ [验证失败 1]                     │
 └──────────────────────────────────┘ └──────────────────────────────────┘
 ┌ 未分类 · 37 个问题 · 相关会话下次检测时补充 ──────────────────────────────┐
 ```
 
 （示意。Magic 现有问题在补分类前都在“未分类”中。）
 
-- 分类卡片：分类名、一行定义（超出截断）、会话数与问题数、最近发生时间（所含会话中最晚的开始时间）、数量最多的两档进度文字。已弃用的分类加“已弃用”标记，排在正常分类之后。
+- 分类卡片：分类名、一行定义（超出截断）、会话数与问题数、最近发生时间（所含会话中最晚的开始时间），以及与会话卡片相同的验证失败／无法判断提醒。已弃用的分类加“已弃用”标记，排在正常分类之后。
 - 排序：按筛选后涉及的会话数倒序，相同时依次按问题数、最近发生时间。
 - “未分类”是最后一条通栏，不与正常分类混排。
 

{agent_tune_kit-2.4.0 → agent_tune_kit-2.4.1}/docs/trace-swimlane-design.md

@@ -64,7 +64,11 @@
 - 默认按会话时间连续列出全部事件。被任意 Issue 引用的行，末尾显示窄标签（如 `001`），不单独占列。
 - 点击聚合刻痕后，列表只展示该刻痕包含的事件，标题显示所属 Trace、所选时段和事件数；无时间事件显示“时间未知”。列表仍可搜索和筛选，计数显示命中数与组内总数。所选事件集合固定，窗口缩放不会改变成员。
 - “返回全部”恢复进入前的选中事件、滚动位置和筛选；原先有筛选时标为“返回筛选结果”，从问题定位进入时标为“返回问题片段”或“返回问题上下文”。连续点击另一聚合刻痕只替换当前集合，返回目标保持不变。切换 Trace 或快照清除该集合。
-- 聚焦 Trace 后标题显示“事件 · T2”及当前事件数。事件工具栏仅保留事件范围、类型和搜索，只筛选列表；Trace 切换位于泳道上方。
+- 聚焦 Trace 后标题显示“事件 · T2”及当前事件数。事件工具栏仅保留类型和搜索，只筛选列表；Trace 切换位于泳道上方。
+- 事件范围（2026-11-11 确认）：不用下拉框，在“事件”标题旁放分段切换 `全部 | ⚠ 失败 N`，用词与状态列的“失败”一致，判定口径与失败行标红相同。
+  - N 按当前 Trace 聚焦、聚合刻痕事件集合、类型和搜索统计，不含切换本身，选择前即可看到。
+  - N 为 0 且未选中时保留显示但不可点击，表明当前范围没有失败事件；已选中时始终可点，便于看清和取消。
+  - 选中时计数写“失败 N / M 条”，M 为同一范围内的事件总数。它与类型、搜索同属列表筛选：进入问题定位或聚合刻痕时清除，退出时按进入前状态恢复。
 - 选中 Issue 后：
   - 恢复完整会话范围，呈现跨 Trace 的所有问题片段；退出问题定位后恢复原来的 Trace 聚焦状态。
   - 范围内行加左侧色条，并插入段头行，显示片段摘要、事件数和时长。
@@ -97,9 +101,10 @@
 
 **问题详情**（从问题栏打开）：
 
-- 顺序：描述与片段 → 诊断 → 修正 / 改动 → 验证。
+- 顺序：问题详情 → 诊断与方案 → 修改候选 → 实际验证。
 - 正文中的 `ISSUE-001/S2` 是可点击链接，点击后主区定位该片段，抽屉保持打开。
 - 从问题证据进入事件后可返回原问题；问题入口保留在问题栏与片段导航中。
+- “问题详情”展示问题描述、关联项目与保留理由，不重复列出全部关联片段。片段从左栏和主区导航；主区“片段证据（N）”按需在抽屉展示本段引用。无法放入片段的额外证据，以及无片段旧问题的关联证据，仍在问题详情中可访问。
 
 ### 导航与状态
 

{agent_tune_kit-2.4.0 → agent_tune_kit-2.4.1}/docs/trace-tuning.md

@@ -222,6 +222,8 @@ CLI validation assigns stable `S1`, `S2`, … identifiers within the Issue, reje
 
 Detection should write one segment per distinct location, using the smallest scope that still explains the problem, and must split across Traces. Diagnosis, change and verification records stay under the Issue; their Markdown may cite `ISSUE-001/S2` so the preview can link back to that segment.
 
+Segments are ordered by their scoped observations' start times. For a final answer, scope the actual result/message event after confirming its content, rather than the enclosing Agent turn: that turn starts before the answer exists, even when its `output` contains the answer. Keep the enclosing turn as context when needed. Shared evidence may belong to multiple segments; the preview uses one display reference for it and does not add another standalone fragment.
+
 Issue IDs are stable within the session. Omitting an old issue during new detection does not resolve it. Exclusion/correction needs a reason while preserving history. Detection coverage includes zero findings, checked/unread nodes, partial work and interruptions; an empty issue list does not prove correctness. Re-capture creates new unanalyzed material rather than rewriting previous coverage.
 
 Diagnoses are immutable Markdown and include an issue snapshot (including segments when present). Adopted diagnoses bind path and digest. Change `target_issues` may list several issues and `diagnoses` maps each target issue to its adopted reference. Save a shared modification once under its owner issue; the other issues explicitly reference that owner-relative change path. Completed candidates are frozen; a new diagnosis/candidate is a new record.
@@ -297,7 +299,7 @@ Explicit visualization opens the browser by default. Options include `--source`,
 
 In session mode, `$atk-visualize-trace` also runs `atk visualize traces --overwrite --no-open --json` after successful preview generation, using the same archive project root, to refresh `.atk/traces/index.html` without opening another page. This also applies to a custom preview output path. The standalone `atk visualize trace` command only generates the preview. If dashboard refresh fails, the Skill delivers the preview and reports the dashboard as unavailable or stale.
 
-The page opens on the complete session. The UI consistently calls each observation an event (**事件**) across lanes, lists, details, counts and filters; native types and archive fields are unchanged. Selecting a grouped time mark focuses its exact events in the existing list, with the Trace, time range (or **时间未知**) and event count in the heading. It opens no drawer until an event row is selected. Search and type filters apply within this fixed group, whose membership survives resizing. **返回全部** restores the prior selection, filters and scroll position; its label becomes **返回筛选结果**, **返回问题片段** or **返回问题上下文** when returning to that context. Selecting another group preserves the original return destination; switching Trace or capture clears the group. Layout: a collapsible issue rail on the left, a compact swimlane chart above the event list in the center, and an overlay drawer on the right for event or Issue detail. Each Trace has one lane on the session clock with no permanent issue tracks. Scroll the event list to read all events in chronological order, including concurrent Traces. Select a lane heading or a time mark to find its events. Use **聚焦** to focus both the swimlane and event list on one Trace, with the time axis fitted to that Trace. While focused, switch Traces from the title above the swimlane; **返回完整会话** restores the prior filters, selected event, and scroll position. The event heading identifies the focused Trace, and its toolbar filters only the event list. Opening an Issue restores the complete session scope so its fragments across Traces remain accessible; exiting restores the previous view. A single Trace opens at full scale without focus controls. Child lanes require an explicit subtask identity. Undated events remain accessible. Search and type filters are optional.
+The page opens on the complete session. The UI consistently calls each observation an event (**事件**) across lanes, lists, details, counts and filters; native types and archive fields are unchanged. Selecting a grouped time mark focuses its exact events in the existing list, with the Trace, time range (or **时间未知**) and event count in the heading. It opens no drawer until an event row is selected. Search and type filters apply within this fixed group, whose membership survives resizing. **返回全部** restores the prior selection, filters and scroll position; its label becomes **返回筛选结果**, **返回问题片段** or **返回问题上下文** when returning to that context. Selecting another group preserves the original return destination; switching Trace or capture clears the group. Layout: a collapsible issue rail on the left, a compact swimlane chart above the event list in the center, and an overlay drawer on the right for event or Issue detail. Each Trace has one lane on the session clock with no permanent issue tracks. Scroll the event list to read all events in chronological order, including concurrent Traces. Select a lane heading or a time mark to find its events. Use **聚焦** to focus both the swimlane and event list on one Trace, with the time axis fitted to that Trace. While focused, switch Traces from the title above the swimlane; **返回完整会话** restores the prior filters, selected event, and scroll position. The event heading identifies the focused Trace, and its toolbar filters only the event list. Opening an Issue restores the complete session scope so its fragments across Traces remain accessible; exiting restores the previous view. A single Trace opens at full scale without focus controls. Child lanes require an explicit subtask identity. Undated events remain accessible. Search and type filters are optional. Next to the event heading, a two-part **全部 | ⚠ 失败 N** switch shows events whose execution failed. N counts failures within the current Trace, grouped events, type filter and search, so you can see it before choosing. With no failures it stays visible but disabled. While it is on, the count reads **失败 N / M 条**.
 
 Select an Issue title, **定位**, or a segment in the left rail to focus that Issue's fragments automatically. Recorded segments overlay as bands on their own Trace rows; the event list inserts segment headers and folds unrelated events, including interleaved concurrent Traces. Counts distinguish fragment events, folded events and locally expanded context. Each folded group can be expanded separately. **查看完整上下文** shows all events while retaining the Issue and its highlights; **返回问题片段** folds context again. **退出问题定位** restores the prior filters and scroll position. Cross-Trace retries stay as separate segments with the idle gap preserved. Issues without `segments` explicitly say “该问题尚未圈定片段” and navigate to existing evidence nodes or archived references; the page does not invent ranges. Row badges mark events cited by any Issue. Above the rail's issue cards, a single-choice **关联项目** row lists **全部** and the projects this session's issues link to, with issue counts that follow the rail search. It follows the dashboard's rules, carries `#project=<id>` both ways, and is hidden when no project is linked or one project holds every issue. The rail has no processing-state selector; each card shows its progress, and the search also matches progress labels and project names.
 
@@ -309,6 +311,8 @@ The diagnosis tab shows the latest structured diagnosis under Issue description,
 
 In a local preview, a diagnosis link such as `[Project setup](src/project.py#L42)` opens a file resolved against the project root at generation time. ATK checks that the file exists under that root and excludes hidden paths. Older absolute `path:line` links use the same checks. Unresolved paths have a copy control. The line fragment marks the cited line, and scrolling to it depends on the file viewer.
 
+The **问题详情** tab shows the description, linked projects and selection reason without repeating the full segment directory. Navigate segments in the rail or center, then use **片段证据（N）** to inspect the selected segment's references in the drawer. Extra evidence and legacy issues without segments keep their evidence links in Issue detail.
+
 ### Actual progress
 
 The preview, its issue filter and the dashboard all show actual progress derived from saved records. The declared issue `status` is ignored, except that `excluded` always shows **已排除**. Otherwise the first matching rule applies:
@@ -335,11 +339,11 @@ atk visualize traces --overwrite --no-open --json
 
 The dashboard is `.atk/traces/index.html`, one offline page covering every archived session in the project. To open it, ask `$atk-visualize-trace` for the dashboard or run the command without `--no-open`. Initialization does not create it. Options are `--project-root`, authorized `--overwrite`, `--open` and `--no-open`. The JSON summary reports session, issue and category counts, progress counts, stale previews, warnings and whether a browser opened. Failure keeps the previous page and does not undo the stage.
 
-- **会话** (default) shows one card per session with when the session ran, its issue count with its two largest progress levels, and category tags. The run time is the earliest event time in the retained trace (hover for start and end), using the same timezone rules as the session page; cards are ordered by it, newest first, with unknown times last. Import and processing times are not shown. The header gives the session and issue totals and, when every session shares one, the environment; how material was obtained (for example local import) is not shown. Cards name their environment only when sessions come from more than one source. Sessions with unreadable records, no retained issues or a missing or stale preview stay visible with that state. No retained issues does not mean the session was correct.
-- **问题** shows one card per category, with session and issue counts and its two largest progress levels as text. Uncategorized issues are grouped in one strip at the bottom; they are categorized when their session is detected again.
-- Neither view has overview metric blocks or progress bars, on the page or on cards. The session view shows compact attention notes for inconclusive or failed verification results and unreadable records, counting each affected session once per note. The issue view has a **关联项目** row and processing-state buttons, each including **全部**, above the category cards.
+- **会话** (default) shows one card per session with when the session ran, its issue count and category tags. The run time is the earliest event time in the retained trace (hover for start and end), using the same timezone rules as the session page; cards are ordered by it, newest first, with unknown times last. Import and processing times are not shown. The header gives the session and issue totals and, when every session shares one, the environment; how material was obtained (for example local import) is not shown. Cards name their environment only when sessions come from more than one source. Sessions with unreadable records, no retained issues or a missing or stale preview stay visible with that state. No retained issues does not mean the session was correct.
+- **问题** shows one card per category, with session and issue counts and its latest session run time. Uncategorized issues are grouped in one strip at the bottom; they are categorized when their session is detected again.
+- Neither view has overview metric blocks or progress bars, on the page or on cards. Cards do not repeat routine progress such as pending, diagnosed or passed; session and category cards flag only **验证失败 N** and **无法判断 N**, matching the attention notes. Use the processing-state filter or a drawer to see each issue's progress. The session view shows compact attention notes for inconclusive or failed verification results and unreadable records, counting each affected session once per note. The issue view has a **关联项目** row and processing-state buttons, each including **全部**, above the category cards.
 - **关联项目** is a single choice: **全部** or one project. It lists only projects that at least one issue links to, each with its issue count and session count, ordered by count; a registered project without linked issues is not offered, and there is no empty-association choice. Counts follow source and search but not the project or processing-state choice, so an issue linked to several projects counts once in each and the counts must not be added up. Choosing the current project again returns to **全部**. The row is hidden when no project is linked, or when one project holds every issue. Project names on category cards choose that project as well. A linked ID missing from the registry stays offered, marked **未登记**.
-- Processing-state and associated-project filters apply only to the issue view and are remembered when switching tabs. Processing-state counts follow the chosen project. Search and source filters are shared between views. Search matches Session IDs, issue IDs, titles and category names; a source filter appears only when sessions come from more than one source. Category cards show their latest session run time. Category ordering, uncategorized counts and drawer match counts follow the current filters. **清除筛选** appears with active filters and clears those used by the current view.
+- Processing-state and associated-project filters apply only to the issue view and are remembered when switching tabs. Processing-state counts follow the chosen project. Search and source filters are shared between views. Search matches Session IDs, issue IDs, titles and category names; a source filter appears only when sessions come from more than one source. Category ordering, uncategorized counts and drawer match counts follow the current filters. **清除筛选** appears with active filters and clears those used by the current view.
 - A card opens a right-side drawer listing its issues, unfinished first. Each issue links to its place in the session preview (`preview.html#issue=…`). A session drawer also shows capture and detection coverage and the command to generate a missing or stale preview.
 - Deep links: `#view=session&session=<dir>`, `#view=category&category=<id>` and `#view=category&project=<id>`. A link with several `project` values keeps the first one still offered; one that is no longer offered means **全部**. When the dashboard exists beside a default preview, the preview shows **← 大盘** and its category tags link to the dashboard.
 

{agent_tune_kit-2.4.0 → agent_tune_kit-2.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agent-tune-kit"
-version = "2.4.0"
+version = "2.4.1"
 description = "Local Codex plugin for iterative Agent tuning with guided Skills, reusable runner templates, versioned results, and static validation."
 readme = "README.en.md"
 requires-python = ">=3.11"

{agent_tune_kit-2.4.0 → agent_tune_kit-2.4.1}/scripts/validate_skill_pack.py

@@ -125,7 +125,7 @@ REQUIRED_FILES += TRACE_SKILL_FILES + [
 ]
 
 PER_FILE_PHRASES = {
-    ".codex-plugin/plugin.json": ['"name": "agent-tune-kit"', '"version": "2.4.0"', '"skills": "./skills/"'],
+    ".codex-plugin/plugin.json": ['"name": "agent-tune-kit"', '"version": "2.4.1"', '"skills": "./skills/"'],
     "skills/atk-dataset/SKILL.md": [
         "## Purpose",
         "## Inputs",

{agent_tune_kit-2.4.0 → agent_tune_kit-2.4.1}/tests/test_install_plugin.py

@@ -104,7 +104,7 @@ class InstallPluginCliTests(unittest.TestCase):
         for args in [("--version",), ("version",)]:
             result = run_cli(*args)
             self.assertEqual(result.returncode, 0, result.stderr)
-            self.assertEqual(result.stdout.strip(), "agent-tune-kit 2.4.0")
+            self.assertEqual(result.stdout.strip(), "agent-tune-kit 2.4.1")
             self.assertEqual(result.stderr, "")
 
     def test_script_wrapper_delegates_to_atk_cli(self) -> None:

{agent_tune_kit-2.4.0 → agent_tune_kit-2.4.1}/tests/test_release_scripts.py

@@ -64,7 +64,7 @@ class ReleaseScriptTests(unittest.TestCase):
         check_release = load_script("check-release.py")
         identity = check_release.read_project_identity()
         self.assertEqual(identity.name, "agent-tune-kit")
-        self.assertEqual(identity.version, "2.4.0")
+        self.assertEqual(identity.version, "2.4.1")
         check_release.assert_versions_aligned(identity)
 
     def test_skill_pack_validation_does_not_phrase_scan_readmes(self) -> None:

{agent_tune_kit-2.4.0 → agent_tune_kit-2.4.1}/tests/test_visualize_trace.py

@@ -653,6 +653,36 @@ def test_recorded_segments_render_as_fragments(tmp_path):
     assert data["issues"][0]["evidence"]
 
 
+def test_shared_segment_evidence_does_not_create_extra_fragments(tmp_path):
+    result = capture(tmp_path)
+    session_dir = Path(result["session_dir"])
+    path = "captures/CAP-001/raw/trace.json"
+    scope = store.evidence_ref(session_dir, path, "/trace/observations/0")
+    shared = store.evidence_ref(session_dir, path, "/trace/observations/1/output")
+    extra = store.evidence_ref(session_dir, path, "/trace/input")
+    records.save_issue(
+        session_dir,
+        {
+            "title": "Shared evidence",
+            "description": "Two segments refer to the same output",
+            "evidence": [extra],
+            "segments": [
+                {"summary": summary, "scope": {"node": scope}, "evidence": [shared]}
+                for summary in ("First perspective", "Second perspective")
+            ],
+        },
+    )
+    before = digests(session_dir)
+    _, data = trace.build_trace_data(tmp_path, session_id=SESSION_ID)
+    item = data["issues"][0]
+    assert len(item["evidence"]) == 2
+    assert len(item["fragments"]) == 3  # Two segments and the genuine extra Trace reference.
+    segments = [part for part in item["fragments"] if part.get("scope_kind")]
+    assert [part["id"] for part in segments] == ["S1", "S2"]
+    assert segments[0]["refs"] == segments[1]["refs"] == [1]
+    assert digests(session_dir) == before
+
+
 def test_issue_rail_hover_does_not_rebuild_rail_or_event_list():
     # Rebuilding the rail under the pointer replaced the buttons between mousedown and mouseup,
     # so clicks on 定位 / segment chips never fired. Hover may redraw the swimlanes only.

{agent_tune_kit-2.4.0 → agent_tune_kit-2.4.1}/tests/trace-dashboard.cjs

@@ -135,6 +135,12 @@ assert.ok(app.cards().every(card => text(metaOf(card)) === "发生时间未记
 assert.equal(app.$("progress-legend").hidden, true);
 assert.equal(app.$("filter-note").hidden, true, "no redundant summary before filtering");
 assert.match(text(app.$("session-attention")), /1 个会话存在验证失败的问题/);
+// Cards flag only results that need attention; routine progress lives in the state filter and the drawers.
+const flagsOf = card => all(card).filter(node => node.className.startsWith("flag")).map(node => [text(node), node.className]);
+const sessionCardOf = id => app.cards().find(card => card.dataset.key === byDir(base, id).dir);
+assert.deepEqual(flagsOf(sessionCardOf("session-b")), [["验证失败 1", "flag bad"]], "a failed verification is flagged on its session");
+assert.deepEqual(flagsOf(sessionCardOf("session-a")), [], "pending, diagnosed and passing issues raise no flag");
+assert.ok(app.cards().every(card => !/待诊断|已诊断|验证通过/.test(text(card))), "session cards do not repeat routine progress");
 
 // --- issue filters stay in their own view and counts follow the visible rows -----------------------------
 app.$("tab-category").onclick();
@@ -305,7 +311,7 @@ assert.equal(metaOf(timedCard).title, "11-06 12:55 – 11-06 13:19", "hover show
 app.$("tab-category").onclick();
 assert.match(text(app.cards()[0]), /最近发生 11-06 12:55/, "category cards name the latest session run");
 assert.ok(app.cards().every(card => !all(card).some(node => node.className.includes("mini-bar"))), "category cards have no progress bar");
-assert.match(text(app.cards()[0]), /(待诊断|已诊断|验证失败|验证通过) \d/, "category cards keep the progress text");
+assert.ok(app.cards().every(card => !/待诊断|已诊断|验证通过/.test(text(card))), "category cards do not repeat routine progress");
 app.$("tab-session").onclick();
 assert.ok(app.cards().every(card => !all(card).some(node => node.className.includes("mini-bar") || node.attrs.role === "img")), "session cards have no progress bar");
 
@@ -506,6 +512,10 @@ const uncertain = JSON.parse(JSON.stringify(base));
 uncertain.sessions[0].issues.forEach(issue => { issue.progress = "inconclusive"; });
 app = boot(uncertain);
 assert.match(text(app.$("session-attention")), /1 个会话存在“无法判断”的验证结论/);
+assert.ok(app.cards().some(card => flagsOf(card).some(([label, cls]) => /^无法判断 \d+$/.test(label) && cls === "flag")), "inconclusive verdicts are flagged on the session card");
+app.$("tab-category").onclick();
+assert.ok(app.cards().some(card => flagsOf(card).some(([label]) => /^无法判断 \d+$/.test(label))), "and on the category card");
+app.$("tab-session").onclick();
 app.search("nothing-matches-this");
 assert.equal(app.$("session-attention").hidden, true);
 all(app.$("filter-note")).find(node => node.tag === "button").onclick();

{agent_tune_kit-2.4.0 → agent_tune_kit-2.4.1}/tests/trace-event-layout.cjs

@@ -128,21 +128,33 @@ const {chromium} = require("playwright");
       } else {
         assert.equal(await page.locator(".lane-zoom").count(), 0);
       }
-      await page.locator("#record-mode").selectOption({label:"仅看异常"});
+      assert.equal(await page.locator("select#record-mode").count(), 0, "Failure-only viewing is not a dropdown");
+      const failedSwitch = page.getByRole("button", {name:/^⚠?\s*失败 \d+$/});
+      const failedCount = Number(await page.locator("#record-failed-count").textContent());
+      assert.ok(failedCount > 0);
+      assert.ok(await failedSwitch.isVisible());
+      assert.ok(await page.locator("#record-failed").evaluate(el =>
+        el.getBoundingClientRect().top < document.getElementById("trace-scroll").getBoundingClientRect().top), "Switch sits in the heading");
+      await failedSwitch.click();
+      assert.equal(await page.locator("#record-failed").getAttribute("aria-pressed"), "true");
+      assert.match(await page.locator("#trace-count").textContent(), new RegExp(`^失败 ${failedCount} / \\d+ 条$`));
       assert.ok(await page.locator(".trace-row.is-error").count());
       assert.equal(await page.locator(".trace-row:not(.is-error)").count(), 0);
       await page.locator("#trace-search").fill("no matching event");
-      assert.equal(await page.locator("#trace-count").textContent(), "0 条");
+      assert.equal(await page.locator("#trace-count").textContent(), "失败 0 / 0 条");
+      assert.equal(await page.locator("#record-failed").isEnabled(), true, "An active switch stays usable at zero");
       assert.equal(await page.locator("#trace-list .empty").textContent(), "没有符合筛选条件的事件。");
-      await page.locator("#record-mode").selectOption("");
+      await page.locator("#record-all").click();
+      assert.equal(await page.locator("#record-failed").isEnabled(), false, "Zero failures disable the inactive switch");
       await page.locator("#trace-search").fill("");
       assert.ok(await page.locator(".trace-row:not(.is-error)").count());
-      await page.locator("#record-mode").selectOption("error");
+      await page.locator("#record-failed").click();
+      assert.ok(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth), "failure switch overflows horizontally");
       await page.locator("#trace-search").fill(failure.id);
       const row = page.locator(`.trace-row[data-node-index="${failure.index}"]`);
       await row.waitFor();
       assert.ok((await row.getAttribute("class")).includes("is-error"));
-      assert.ok(await row.getByRole("img",{name:"执行异常"}).isVisible());
+      assert.ok(await row.getByRole("img",{name:"执行失败"}).isVisible());
       assert.equal(await row.locator(".event-status").textContent(), "失败");
       assert.equal(await row.locator(".event-meta").isVisible(), width > 800);
       const appearance = () => row.evaluate(el => {
@@ -168,7 +180,7 @@ const {chromium} = require("playwright");
       await row.evaluate(el => el.classList.add("in-fragment"));
       const fragment = await appearance();
       assert.ok(fragment.redTint && fragment.marker);
-      assert.ok(await row.getByRole("img",{name:"执行异常"}).isVisible());
+      assert.ok(await row.getByRole("img",{name:"执行失败"}).isVisible());
       assert.deepEqual(errors,[]);
       assert.deepEqual(requests,[], "Event previews must stay offline");
       console.log(`${width}px: column sizing, failure states, selection and offline rendering passed`);

{agent_tune_kit-2.4.0 → agent_tune_kit-2.4.1}/tests/trace-fragments.cjs

@@ -11,8 +11,9 @@ function boot() {
   const elements = new Map();
   const $ = id => {
     if (!elements.has(id)) elements.set(id, {
-      value: "", hidden: false, style: {}, scrollTop: 0, textContent: "",
+      value: "", hidden: false, disabled: false, title: "", style: {}, scrollTop: 0, textContent: "", attrs: {},
       parentElement: {classList: {toggle() {}}}, focus() {}, scrollIntoView() {},
+      setAttribute(name, value) { this.attrs[name] = String(value); }, getAttribute(name) { return this.attrs[name] ?? null; },
     });
     return elements.get(id);
   };
@@ -152,7 +153,7 @@ test("failure-only filtering matches error styling and combines with Trace, type
   app.$("record-mode").value = "error";
   app.context.renderTraces();
   assert.deepEqual(visible(app.rows()), [0, 2, 3, 4]);
-  assert.equal(app.$("trace-count").textContent, "4 条");
+  assert.equal(app.$("trace-count").textContent, "失败 4 / 12 条");
   app.$("trace-search").value = "read";
   app.context.renderTraces();
   assert.deepEqual(visible(app.rows()), [0, 2, 3, 4], "Search must not include matching normal Events");
@@ -162,7 +163,7 @@ test("failure-only filtering matches error styling and combines with Trace, type
   app.$("trace-filter").value = "1";
   app.context.renderTraces();
   assert.deepEqual(visible(app.rows()), []);
-  assert.equal(app.$("trace-count").textContent, "0 条");
+  assert.equal(app.$("trace-count").textContent, "失败 0 / 5 条", "The total counts T1 EVENT rows; node 3 is a TOOL");
   app.$("type-filter").value = "TOOL";
   app.context.renderTraces();
   assert.deepEqual(visible(app.rows()), [3]);
@@ -188,7 +189,41 @@ test("issue navigation restores failure-only filtering and fragment expansion ca
   app.context.exitIssue();
   assert.equal(app.$("record-mode").value, "error");
   assert.deepEqual(visible(app.rows()), [2, 4, 7]);
-  assert.equal(app.$("trace-count").textContent, "3 条");
+  assert.equal(app.$("trace-count").textContent, "失败 3 / 12 条");
+});
+
+test("the failure switch counts within the other filters, stays visible at zero and restores with the view", () => {
+  const app = boot();
+  const pressed = () => [app.$("record-all").getAttribute("aria-pressed"), app.$("record-failed").getAttribute("aria-pressed")];
+  assert.equal(app.$("record-failed-count").textContent, "0");
+  assert.equal(app.$("record-failed").disabled, true, "Zero failures are shown, not hidden, and cannot be chosen");
+  assert.deepEqual(pressed(), ["true", "false"]);
+  for (const i of [1, 2, 4]) app.capture.nodes[i].level = "ERROR";
+  app.context.renderTraces();
+  assert.equal(app.$("record-failed-count").textContent, "3");
+  assert.equal(app.$("record-failed").disabled, false);
+  assert.equal(app.$("trace-count").textContent, "12 条", "Counting failures must not filter the list");
+  app.$("trace-filter").value = "0";
+  app.context.renderTraces();
+  assert.equal(app.$("record-failed-count").textContent, "2", "Count follows the focused Trace before the switch is used");
+  app.context.setRecordMode("error");
+  assert.deepEqual(pressed(), ["false", "true"]);
+  assert.deepEqual(visible(app.rows()), [2, 4]);
+  assert.equal(app.$("trace-count").textContent, "失败 2 / 6 条");
+  app.$("trace-search").value = "no match";
+  app.context.renderTraces();
+  assert.equal(app.$("record-failed-count").textContent, "0");
+  assert.equal(app.$("record-failed").disabled, false, "An active switch stays usable at zero so the selection is visible");
+  app.$("trace-search").value = "";
+  app.context.focusEvents([0, 2, 6]);
+  assert.equal(app.$("record-mode").value, "", "Opening an event group clears the switch like other record filters");
+  assert.equal(app.$("record-failed-count").textContent, "1", "Count stays inside the chosen group");
+  app.context.exitEventFocus();
+  assert.equal(app.$("record-mode").value, "error");
+  assert.deepEqual(pressed(), ["false", "true"]);
+  app.context.setRecordMode("");
+  assert.deepEqual(pressed(), ["true", "false"]);
+  assert.deepEqual(visible(app.rows()), [0, 2, 4, 6, 8, 10]);
 });
 
 test("selecting an issue focuses all its fragments and preserves interleaved records", () => {