@ch4acko3/dsh-turn-fold 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ch4acko3
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,59 @@
+# dsh-turn-fold
+
+English | [简体中文](README.zh-CN.md)
+
+A [dsh-harmony](https://github.com/memorax-ai/dsh-harmony) provider that adds
+Codex-Desktop-style turn folding to the DSH WebUI conversation.
+
+During a turn, the summary bar remains visible while native thinking, notes,
+commands, and tool calls keep streaming. Consecutive reasoning and tool activity
+share one compact group from the second item onward. When a turn settles, known
+Agent activity, including context injection, moves into one disclosure
+immediately before the final answer. Its configurable metrics default to wall
+time, tool-call count, and input/output tokens, and appear only when the loaded
+turn contains enough data to calculate them without guessing.
+
+The final answer is located through `turn-tail.closing.finalNode`, not
+`finish_reason` or DOM position. Completed, stopped, and interrupted turns fold,
+with distinct status labels for the latter two. A turn remains expanded when
+DSH marks its closing branch unavailable, when any later node follows the
+closing answer, or while the user has keyboard focus or an active text selection
+inside its activity. Failed, max-token, closing-less, and open turns also stay
+expanded so errors and unfinished work are never hidden.
+
+Expanding reuses the original native node renderers, so tool details, copy, and
+file links keep working. Open turns are remembered per session and turn while
+the WebUI remains loaded. The disclosure has keyboard-visible focus, accessible
+state and action labels, responsive wrapping, reduced-motion handling, and a
+short open/close transition that unmounts the activity after it closes.
+
+## How it works
+
+Two pinned Source Patches run in memory against the compiled browser bundle of
+`@deepseek-ai/dsh-client-ui-conversation` (`lib/client.js`); installed DSH files
+are never modified.
+
+| Patch | Selector (expect 1) | Effect |
+| --- | --- | --- |
+| `inject-turn-fold-runtime` | `FunctionDeclaration[name.name="ChatView"], VariableStatement:has(VariableDeclaration[name.name="ChatView"])` | Injects the fold renderer + disclosure UI into either native or decorated `ChatView` |
+| `rewrite-node-render-loop` | `CallExpression[expression.name.name="map"][expression.expression.name="order"]` | Replaces the `order.map(...)` node loop with the per-turn renderer |
+
+## Install
+
+```sh
+dsh plugin --profile web add github:CH4ACKO3/dsh-turn-fold
+dsh harmony status --profile web   # both patches must be `bound`
+```
+
+## Test
+
+```sh
+node test/run.cjs
+```
+
+`npm install` installs test-only copies of the pinned DSH conversation package,
+TypeScript, and TSQuery. The test suite applies both patches in memory, parses
+the final browser bundle, and covers completed, split-activity, post-closing,
+partial-history, failed, interrupted, open, accessibility, and state-retention
+behavior. A missing target or selector mismatch fails the test; it is never
+reported as a skipped pass.

package/README.zh-CN.md

@@ -0,0 +1,35 @@
+# dsh-turn-fold
+
+[English](README.md) | 简体中文
+
+一个基于 [dsh-harmony](https://github.com/memorax-ai/dsh-harmony) 的 Provider，为 DSH WebUI 对话添加 Codex Desktop 风格的回合折叠。
+
+回合进行期间，摘要栏保持可见，原生思考、说明、命令和工具调用继续流式输出。从第二项开始，连续的推理和工具活动会合并为一个紧凑分组。回合结束后，包括上下文注入在内的已知 Agent 活动会收进最终答复前方的折叠栏。摘要指标可以配置，默认显示耗时、工具调用次数以及输入/输出 token；只有当已加载的回合包含足够数据、无需猜测即可计算时才会展示对应指标。
+
+最终答复通过 `turn-tail.closing.finalNode` 定位，不依赖 `finish_reason` 或 DOM 位置。正常完成、已停止和已中断的回合都会折叠，后两者显示不同的状态标签。当 DSH 将结束分支标记为不可用、结束答复之后仍有节点，或者用户的键盘焦点或文本选择位于活动内容中时，回合会保持展开。失败、达到最大 token、缺少结束节点以及仍在进行的回合也会保持展开，避免隐藏错误或未完成的工作。
+
+展开后仍然使用原生节点渲染器，因此工具详情、复制功能和文件链接都能继续工作。WebUI 保持加载期间，每个会话和回合的展开状态都会被记住。折叠控件提供键盘可见焦点、无障碍状态与操作标签、响应式换行、减少动态效果支持，以及关闭后再卸载活动内容的短暂开合动画。
+
+## 工作原理
+
+两个固定目标的 Source Patch 会在内存中修改 `@deepseek-ai/dsh-client-ui-conversation` 的编译后浏览器包（`lib/client.js`），不会修改已安装的 DSH 文件。
+
+| Patch | 选择器（预期命中 1 次） | 作用 |
+| --- | --- | --- |
+| `inject-turn-fold-runtime` | `FunctionDeclaration[name.name="ChatView"], VariableStatement:has(VariableDeclaration[name.name="ChatView"])` | 向原生或已装饰的 `ChatView` 注入折叠渲染器和折叠 UI |
+| `rewrite-node-render-loop` | `CallExpression[expression.name.name="map"][expression.expression.name="order"]` | 将 `order.map(...)` 节点循环替换为按回合渲染器 |
+
+## 安装
+
+```sh
+dsh plugin --profile web add github:CH4ACKO3/dsh-turn-fold
+dsh harmony status --profile web   # 两个 Patch 都必须为 `bound`
+```
+
+## 测试
+
+```sh
+node test/run.cjs
+```
+
+`npm install` 会安装仅用于测试的固定版本 DSH 对话包、TypeScript 和 TSQuery。测试套件会在内存中应用两个 Patch、解析最终浏览器包，并覆盖已完成回合、分段活动、结束后活动、部分历史、失败、中断、进行中、无障碍和状态保留等行为。目标缺失或选择器不匹配会使测试失败，不会被报告为跳过后通过。

package/harmony.patch.yml

@@ -0,0 +1,4 @@
+- insert:
+    - id: ch4acko3-dsh-turn-fold
+      name: '@ch4acko3/dsh-turn-fold'
+      inject: [harmony]

package/index.cjs

@@ -0,0 +1,13 @@
+'use strict'
+
+// Host entry for the @ch4acko3/dsh-turn-fold Harmony provider.
+const { settingsNamespace } = require('@deepseek-ai/dsh-settings')
+const { Config, SETTINGS_NAMESPACE } = require('./settings.cjs')
+
+exports.Config = Config
+exports.inject = ['harmony']
+exports.apply = (ctx, config) => {
+  ctx.inject(['settings'], (settingsCtx) => {
+    settingsCtx.settings.register(settingsNamespace(SETTINGS_NAMESPACE), Config, { base: config })
+  })
+}

package/inline-source.cjs

@@ -0,0 +1,885 @@
+'use strict'
+
+// Runtime injected into @deepseek-ai/dsh-client-ui-conversation/lib/client.js.
+// It executes inside the target module factory, where react,
+// react_jsx_runtime, formatRunDuration, and formatTokens are already in scope.
+const dictionaries = require('./locales.cjs')
+const { DEFAULT_SUMMARY_FIELDS, SETTINGS_NAMESPACE, SUMMARY_FIELDS } = require('./settings.cjs')
+
+module.exports = String.raw`/* @ch4acko3/dsh-turn-fold runtime (injected) */
+var __ch4acko3DshTurnFoldLocaleNamespace = "@ch4acko3/dsh-turn-fold";
+var __ch4acko3DshTurnFoldDictionaries = ${JSON.stringify(dictionaries)};
+var __ch4acko3DshTurnFoldSettingsNamespace = ${JSON.stringify(SETTINGS_NAMESPACE)};
+var __ch4acko3DshTurnFoldKnownFields = ${JSON.stringify(SUMMARY_FIELDS)};
+var __ch4acko3DshTurnFoldDefaultFields = ${JSON.stringify(DEFAULT_SUMMARY_FIELDS)};
+var __ch4acko3DshTurnFoldTranslate = null;
+var __ch4acko3DshTurnFoldSettingsScope = null;
+var __ch4acko3DshTurnFoldSummaryFields = __ch4acko3DshTurnFoldDefaultFields.slice();
+var __ch4acko3DshTurnFoldSettingsListeners = new Set();
+var __ch4acko3DshTurnFoldCss = [
+  ".__ch4acko3-dsh-turn-fold{min-width:0;margin:1px 0 2px;animation:__ch4acko3-dsh-turn-fold-enter .18s cubic-bezier(.33,1,.68,1)}",
+  ".__ch4acko3-dsh-turn-fold__header{display:block;width:100%;min-height:28px;box-sizing:border-box;margin:0;padding:3px 4px;color:var(--dsw-alias-label-secondary);text-align:left;font:var(--dsw-font-xs-13)}",
+  "button.__ch4acko3-dsh-turn-fold__header{appearance:none;-webkit-tap-highlight-color:transparent;border:0;border-radius:0;background:transparent;cursor:pointer}",
+  "button.__ch4acko3-dsh-turn-fold__header:focus-visible{outline:2px solid var(--dsw-static-deepseek-500);outline-offset:1px}",
+  ".__ch4acko3-dsh-turn-fold__label{display:inline;max-width:100%;font:var(--dsw-font-xs-13);font-variant-numeric:tabular-nums;color:inherit}",
+  ".__ch4acko3-dsh-turn-fold__metric{white-space:nowrap}",
+  ".__ch4acko3-dsh-turn-fold__separator{display:inline-block;width:1px;height:10px;margin:0 7px;background:var(--dsw-alias-border-l2);vertical-align:-1px}",
+  ".__ch4acko3-dsh-turn-fold__metricWindow{display:inline-block;overflow:hidden;vertical-align:bottom}",
+  ".__ch4acko3-dsh-turn-fold__metricValue{display:inline-block;animation:__ch4acko3-dsh-turn-fold-metric-roll .2s cubic-bezier(.33,1,.68,1)}",
+  ".__ch4acko3-dsh-turn-fold__rule{width:100%;height:1px;background:var(--dsw-alias-border-l3)}",
+  ".__ch4acko3-dsh-turn-fold__chevron{display:inline-block;margin-left:5px;color:var(--dsw-alias-label-caption);vertical-align:-2px;transform:rotate(-90deg);transition:transform .16s cubic-bezier(.33,1,.68,1)}",
+  ".__ch4acko3-dsh-turn-fold--open .__ch4acko3-dsh-turn-fold__chevron{transform:rotate(0deg)}",
+  ".__ch4acko3-dsh-turn-fold__clip{display:grid;grid-template-rows:0fr;opacity:0;transition:grid-template-rows .18s cubic-bezier(.33,1,.68,1),opacity .14s ease}",
+  ".__ch4acko3-dsh-turn-fold--open .__ch4acko3-dsh-turn-fold__clip{grid-template-rows:1fr;opacity:1}",
+  ".__ch4acko3-dsh-turn-fold__bodyWrap{min-height:0;overflow:hidden}",
+  ".__ch4acko3-dsh-turn-fold__body{display:flex;flex-direction:column;gap:16px;margin-top:12px}",
+  ".__ch4acko3-dsh-turn-fold__closing{display:contents}",
+  ".__ch4acko3-dsh-turn-fold__closing [data-variant=think]{display:none}",
+  ".__ch4acko3-dsh-turn-fold__activityText{display:contents}",
+  ".__ch4acko3-dsh-turn-fold__activityText [data-variant=think]{display:none}",
+  ".__ch4acko3-dsh-turn-fold-activity{min-width:0}",
+  ".__ch4acko3-dsh-turn-fold-activity__row{position:relative;overflow:hidden}",
+  ".__ch4acko3-dsh-turn-fold-activity[data-state=running] .__ch4acko3-dsh-turn-fold-activity__row:after{content:\"\";position:absolute;inset-block:0;left:-300px;width:300px;pointer-events:none;background:linear-gradient(90deg,transparent 0%,color-mix(in srgb,var(--dsw-alias-bg-base) 60%,transparent) 55%,transparent 100%);animation:2.6s ease-out infinite __ch4acko3-dsh-turn-fold-activity-sweep}",
+  ".__ch4acko3-dsh-turn-fold-activity__leading{flex-shrink:0}",
+  ".__ch4acko3-dsh-turn-fold-activity__title{font-weight:400}",
+  ".__ch4acko3-dsh-turn-fold-activity__chevron{color:var(--dsw-alias-label-secondary)}",
+  ".__ch4acko3-dsh-turn-fold-activity__separator{width:2px;height:2px;margin:0 8px;flex:none;border-radius:1px;background:var(--dsw-alias-label-caption)}",
+  ".__ch4acko3-dsh-turn-fold-activity__failure{min-width:0;color:var(--dsw-alias-state-error-primary);font-size:14px;line-height:24px}",
+  ".__ch4acko3-dsh-turn-fold-activity__clip{display:grid;grid-template-rows:0fr;opacity:0;transition:grid-template-rows .18s cubic-bezier(.16,1,.3,1),opacity .12s ease-out}",
+  ".__ch4acko3-dsh-turn-fold-activity--open .__ch4acko3-dsh-turn-fold-activity__clip{grid-template-rows:1fr;opacity:1}",
+  ".__ch4acko3-dsh-turn-fold-activity__bodyWrap{min-height:0;overflow:hidden}",
+  ".__ch4acko3-dsh-turn-fold-activity__body{display:flex;flex-direction:column;gap:8px;margin:4px 0 4px 22px}",
+  ".__ch4acko3-dsh-turn-fold-settings{list-style:none;border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-3);border-radius:12px}",
+  ".__ch4acko3-dsh-turn-fold-settings__header{appearance:none;width:100%;display:flex;align-items:center;gap:12px;padding:14px 16px;border:0;border-radius:12px;background:transparent;color:inherit;text-align:left;font:inherit;cursor:pointer}",
+  ".__ch4acko3-dsh-turn-fold-settings__header:focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:-2px}",
+  ".__ch4acko3-dsh-turn-fold-settings__headText{display:flex;flex:1;min-width:0;flex-direction:column;gap:4px}",
+  ".__ch4acko3-dsh-turn-fold-settings__title{color:var(--dsw-alias-label-primary);font-size:15px;font-weight:600;line-height:1.4}",
+  ".__ch4acko3-dsh-turn-fold-settings__description{color:var(--dsw-alias-label-tertiary);font-size:13px;line-height:1.5}",
+  ".__ch4acko3-dsh-turn-fold-settings__chevron{flex:none;transform:rotate(-90deg);transition:transform .16s}",
+  ".__ch4acko3-dsh-turn-fold-settings--open .__ch4acko3-dsh-turn-fold-settings__chevron{transform:rotate(0deg)}",
+  ".__ch4acko3-dsh-turn-fold-settings__body{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:8px 16px;margin:0 16px;padding:12px 0 14px;border-top:1px solid var(--dsw-alias-border-l2)}",
+  ".__ch4acko3-dsh-turn-fold-settings__field{display:flex;align-items:center;gap:8px;min-width:0;color:var(--dsw-alias-label-secondary);font-size:13px;line-height:20px}",
+  ".__ch4acko3-dsh-turn-fold-settings__field input{accent-color:var(--dsw-alias-brand-primary)}",
+  ".__ch4acko3-dsh-turn-fold-settings__readOnly{grid-column:1/-1;margin:0;color:var(--dsw-alias-label-tertiary);font-size:12px}",
+  "@keyframes __ch4acko3-dsh-turn-fold-enter{from{opacity:0;transform:translateY(-4px)}to{opacity:1;transform:translateY(0)}}",
+  "@keyframes __ch4acko3-dsh-turn-fold-metric-roll{from{opacity:.15;transform:translateY(65%)}to{opacity:1;transform:translateY(0)}}",
+  "@keyframes __ch4acko3-dsh-turn-fold-activity-sweep{0%{left:-300px}90%,to{left:100%}}",
+  "@media(max-width:520px){.__ch4acko3-dsh-turn-fold__label{line-height:18px}.__ch4acko3-dsh-turn-fold-settings__body{grid-template-columns:1fr}}",
+  "@media(prefers-reduced-motion:reduce){.__ch4acko3-dsh-turn-fold,.__ch4acko3-dsh-turn-fold__metricValue,.__ch4acko3-dsh-turn-fold-activity[data-state=running] .__ch4acko3-dsh-turn-fold-activity__row:after{animation:none}.__ch4acko3-dsh-turn-fold__chevron,.__ch4acko3-dsh-turn-fold__clip,.__ch4acko3-dsh-turn-fold-activity__clip,.__ch4acko3-dsh-turn-fold-settings__chevron{transition:none}}"
+].join("");
+if (typeof document !== "undefined") {
+  var __ch4acko3DshTurnFoldStyle = document.getElementById("ch4acko3-dsh-turn-fold-style");
+  if (__ch4acko3DshTurnFoldStyle === null) {
+    __ch4acko3DshTurnFoldStyle = document.createElement("style");
+    __ch4acko3DshTurnFoldStyle.id = "ch4acko3-dsh-turn-fold-style";
+    __ch4acko3DshTurnFoldStyle.setAttribute("data-plugin", "@ch4acko3/dsh-turn-fold");
+    document.head.appendChild(__ch4acko3DshTurnFoldStyle);
+  }
+  __ch4acko3DshTurnFoldStyle.textContent = __ch4acko3DshTurnFoldCss;
+}
+var __ch4acko3DshTurnFoldOpenKeys = new Set();
+var __ch4acko3DshTurnFoldBodyId = 0;
+function __ch4acko3DshTurnFoldText(key, params) {
+  if (__ch4acko3DshTurnFoldTranslate === null) throw new Error("@ch4acko3/dsh-turn-fold: locale service was not installed");
+  return __ch4acko3DshTurnFoldTranslate(key, params);
+}
+function __ch4acko3DshTurnFoldDecodeSettings(section) {
+  if (typeof section !== "object" || section === null || !Array.isArray(section.summaryFields)) return void 0;
+  var seen = new Set();
+  var fields = [];
+  for (var i = 0; i < section.summaryFields.length; i++) {
+    var field = section.summaryFields[i];
+    if (typeof field !== "string" || __ch4acko3DshTurnFoldKnownFields.indexOf(field) < 0) return void 0;
+    if (!seen.has(field)) {
+      seen.add(field);
+      fields.push(field);
+    }
+  }
+  return { summaryFields: fields };
+}
+function __ch4acko3DshTurnFoldPublishSettings(fields) {
+  if (__ch4acko3DshTurnFoldSummaryFields.length === fields.length && __ch4acko3DshTurnFoldSummaryFields.every(function (field, index) { return field === fields[index]; })) return;
+  __ch4acko3DshTurnFoldSummaryFields = fields.slice();
+  __ch4acko3DshTurnFoldSettingsListeners.forEach(function (listener) { listener(); });
+}
+function __ch4acko3DshTurnFoldInstall(ctx) {
+  ctx.effect(function () { return ctx.locale.register(__ch4acko3DshTurnFoldLocaleNamespace, __ch4acko3DshTurnFoldDictionaries); }, "@ch4acko3/dsh-turn-fold: dictionaries");
+  __ch4acko3DshTurnFoldTranslate = ctx.locale.bind(__ch4acko3DshTurnFoldLocaleNamespace);
+  var scope = ctx.settingsScope.bind({ namespace: __ch4acko3DshTurnFoldSettingsNamespace, decode: __ch4acko3DshTurnFoldDecodeSettings });
+  __ch4acko3DshTurnFoldSettingsScope = scope;
+  function publish() {
+    var snapshot = scope.getSnapshot();
+    if (snapshot.status === "ready" && snapshot.value !== void 0) __ch4acko3DshTurnFoldPublishSettings(snapshot.value.summaryFields);
+  }
+  ctx.effect(function () { return scope.subscribe(publish); }, "@ch4acko3/dsh-turn-fold: settings");
+  publish();
+  ctx.slots.inject("settings.plugin.item", function () {
+    return ctx.slots.register({
+      name: "settings.plugin.item",
+      key: __ch4acko3DshTurnFoldSettingsNamespace
+    }, __ch4acko3DshTurnFoldSettingsCard);
+  });
+}
+function __ch4acko3DshTurnFoldSubscribeSettings(listener) {
+  __ch4acko3DshTurnFoldSettingsListeners.add(listener);
+  return function () { __ch4acko3DshTurnFoldSettingsListeners.delete(listener); };
+}
+function __ch4acko3DshTurnFoldGetSettingsSnapshot() {
+  return __ch4acko3DshTurnFoldSummaryFields;
+}
+function __ch4acko3DshTurnFoldNumber(value) {
+  return typeof value === "number" && isFinite(value) && value >= 0 ? value : null;
+}
+function __ch4acko3DshTurnFoldUsage(usage) {
+  if (typeof usage !== "object" || usage === null) return null;
+  var uncached = __ch4acko3DshTurnFoldNumber(usage.inputTokens);
+  var output = __ch4acko3DshTurnFoldNumber(usage.outputTokens);
+  if (uncached === null || output === null) return null;
+  var cacheRead = usage.cacheReadTokens === void 0 ? 0 : __ch4acko3DshTurnFoldNumber(usage.cacheReadTokens);
+  var cacheWrite = usage.cacheWriteTokens === void 0 ? 0 : __ch4acko3DshTurnFoldNumber(usage.cacheWriteTokens);
+  var reasoning = usage.reasoningTokens === void 0 ? 0 : __ch4acko3DshTurnFoldNumber(usage.reasoningTokens);
+  if (cacheRead === null || cacheWrite === null || reasoning === null) return null;
+  return {
+    inputTokens: uncached + cacheRead + cacheWrite,
+    outputTokens: output,
+    cacheReadTokens: cacheRead,
+    cacheWriteTokens: cacheWrite,
+    reasoningTokens: reasoning
+  };
+}
+function __ch4acko3DshTurnFoldReasoningTexts(node) {
+  var blocks = node !== void 0 && node.data !== void 0 ? node.data.blocks : void 0;
+  if (!Array.isArray(blocks)) return [];
+  return blocks.filter(function (block) {
+    return block !== void 0 && block.kind === "reasoning" && typeof block.text === "string" && block.text.length > 0;
+  }).map(function (block) { return block.text; });
+}
+function __ch4acko3DshTurnFoldMotionMs() {
+  if (typeof matchMedia === "function" && matchMedia("(prefers-reduced-motion: reduce)").matches) return 0;
+  return 180;
+}
+function __ch4acko3DshTurnFoldInteractionKeys() {
+  var keys = new Set();
+  if (typeof document === "undefined") return keys;
+  var active = document.activeElement;
+  var activeRow = active instanceof Element ? active.closest("[data-chat-anchor-key]") : null;
+  if (activeRow !== null && activeRow.dataset.chatAnchorKey) keys.add(activeRow.dataset.chatAnchorKey);
+  if (typeof window === "undefined" || typeof window.getSelection !== "function") return keys;
+  var selection = window.getSelection();
+  if (selection === null || selection.isCollapsed || selection.rangeCount === 0) return keys;
+  var range = selection.getRangeAt(0);
+  var rows = document.querySelectorAll("[data-chat-anchor-key]");
+  for (var i = 0; i < rows.length; i++) {
+    if (range.intersectsNode(rows[i]) && rows[i].dataset.chatAnchorKey) keys.add(rows[i].dataset.chatAnchorKey);
+  }
+  return keys;
+}
+function __ch4acko3DshTurnFoldChevron() {
+  return react_jsx_runtime.jsx("svg", {
+    className: "__ch4acko3-dsh-turn-fold__chevron",
+    width: 12,
+    height: 12,
+    viewBox: "0 0 12 12",
+    "aria-hidden": true,
+    children: react_jsx_runtime.jsx("path", {
+      d: "M3.5 4.5 6 7l2.5-2.5",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: 1.5,
+      strokeLinecap: "round",
+      strokeLinejoin: "round"
+    })
+  });
+}
+function __ch4acko3DshTurnFoldToolFacts(toolKeys, nodeStore) {
+  var failed = 0;
+  var running = false;
+  for (var i = 0; i < toolKeys.length; i++) {
+    var node = nodeStore.get(toolKeys[i]);
+    var root = node === void 0 || node.data === void 0 ? void 0 : node.data.root;
+    if (root !== void 0 && root.kind === "tool-result") {
+      if (root.isError === true) failed++;
+    } else {
+      running = true;
+    }
+  }
+  return { failed: failed, running: running };
+}
+function __ch4acko3DshTurnFoldActivityGroup(props) {
+  var foldKey = props.foldKey;
+  var toolCount = 0;
+  var hasThink = false;
+  for (var itemIndex = 0; itemIndex < props.items.length; itemIndex++) {
+    if (props.items[itemIndex].kind === "tool") toolCount++;
+    else hasThink = true;
+  }
+  var initialOpen = __ch4acko3DshTurnFoldOpenKeys.has(foldKey);
+  var openState = react.useState(initialOpen);
+  var open = openState[0];
+  var setOpen = openState[1];
+  var renderedState = react.useState(initialOpen);
+  var bodyRendered = renderedState[0];
+  var setBodyRendered = renderedState[1];
+  var frameRef = react.useRef(null);
+  var timerRef = react.useRef(null);
+  react.useEffect(function () {
+    return function () {
+      if (frameRef.current !== null && typeof cancelAnimationFrame === "function") cancelAnimationFrame(frameRef.current);
+      if (timerRef.current !== null) clearTimeout(timerRef.current);
+    };
+  }, []);
+  var title = hasThink && toolCount === 0
+    ? __ch4acko3DshTurnFoldText("activityGroup.think")
+    : __ch4acko3DshTurnFoldText((hasThink ? "activityGroup.thinkAndTools." : "activityGroup.tools.") + (toolCount === 1 ? "one" : "many"), { count: toolCount });
+  var failure = props.failed === 0 ? null : __ch4acko3DshTurnFoldText("activityGroup.failures." + (props.failed === 1 ? "one" : "many"), { count: props.failed });
+  var state = props.running ? "running" : props.failed > 0 ? "error" : "ok";
+  function toggle() {
+    if (frameRef.current !== null && typeof cancelAnimationFrame === "function") cancelAnimationFrame(frameRef.current);
+    if (timerRef.current !== null) clearTimeout(timerRef.current);
+    frameRef.current = null;
+    timerRef.current = null;
+    if (open) {
+      __ch4acko3DshTurnFoldOpenKeys.delete(foldKey);
+      setOpen(false);
+      var delay = __ch4acko3DshTurnFoldMotionMs();
+      if (delay === 0) setBodyRendered(false);
+      else timerRef.current = setTimeout(function () {
+        timerRef.current = null;
+        setBodyRendered(false);
+      }, delay);
+      return;
+    }
+    __ch4acko3DshTurnFoldOpenKeys.add(foldKey);
+    setBodyRendered(true);
+    if (__ch4acko3DshTurnFoldMotionMs() === 0 || typeof requestAnimationFrame !== "function") {
+      setOpen(true);
+      return;
+    }
+    frameRef.current = requestAnimationFrame(function () {
+      frameRef.current = null;
+      setOpen(true);
+    });
+  }
+  return react_jsx_runtime.jsxs("div", {
+    className: "__ch4acko3-dsh-turn-fold-activity" + (open ? " __ch4acko3-dsh-turn-fold-activity--open" : ""),
+    "data-ch4acko3-dsh-turn-fold-activity": "",
+    "data-ch4acko3-dsh-turn-fold-activity-open": open ? "true" : "false",
+    "data-dsh-fold-owner": "@ch4acko3/dsh-turn-fold",
+    "data-dsh-fold-scope": "activity-run",
+    "data-state": state,
+    children: [
+      react_jsx_runtime.jsx(_deepseek_ai_dsh_client_ui_primitives.DisclosureRow, {
+        rowClassName: "__ch4acko3-dsh-turn-fold-activity__row",
+        leadingClassName: "__ch4acko3-dsh-turn-fold-activity__leading",
+        titleClassName: "__ch4acko3-dsh-turn-fold-activity__title",
+        chevronClassName: "__ch4acko3-dsh-turn-fold-activity__chevron",
+        icon: props.failed > 0 ? react_jsx_runtime.jsx(_deepseek_ai_dsh_client_ui_primitives.StateDot, { state: "error" }) : react_jsx_runtime.jsx(_deepseek_ai_dsh_client_ui_primitives.IconApiOutline14, { size: 14 }),
+        title: title,
+        open: open,
+        expandable: true,
+        expandOnRowClick: true,
+        onToggle: toggle,
+        collapsedContent: failure === null ? void 0 : react_jsx_runtime.jsxs(react_jsx_runtime.Fragment, { children: [
+          react_jsx_runtime.jsx("span", { className: "__ch4acko3-dsh-turn-fold-activity__separator", "aria-hidden": true }),
+          react_jsx_runtime.jsx("span", { className: "__ch4acko3-dsh-turn-fold-activity__failure", children: failure })
+        ] })
+      }),
+      react_jsx_runtime.jsx("div", {
+        className: "__ch4acko3-dsh-turn-fold-activity__clip",
+        "aria-hidden": !open,
+        inert: !open,
+        children: bodyRendered ? react_jsx_runtime.jsx("div", {
+          className: "__ch4acko3-dsh-turn-fold-activity__bodyWrap",
+          children: react_jsx_runtime.jsx("div", {
+            className: "__ch4acko3-dsh-turn-fold-activity__body",
+            children: props.items.map(function (item) {
+              return item.kind === "reasoning"
+                ? react_jsx_runtime.jsx(ReasoningRow, { text: item.text, running: false, t: props.t }, item.key)
+                : props.renderNode(item.key);
+            })
+          })
+        }) : null
+      })
+    ]
+  });
+}
+function __ch4acko3DshTurnFoldSettingsCard() {
+  var openState = react.useState(false);
+  var open = openState[0];
+  var setOpen = openState[1];
+  var pendingState = react.useState(false);
+  var pending = pendingState[0];
+  var setPending = pendingState[1];
+  var failedState = react.useState(false);
+  var failed = failedState[0];
+  var setFailed = failedState[1];
+  var scope = __ch4acko3DshTurnFoldSettingsScope;
+  if (scope === null) return null;
+  var snapshot = react.useSyncExternalStore(function (listener) { return scope.subscribe(listener); }, function () { return scope.getSnapshot(); }, function () { return scope.getSnapshot(); });
+  if (snapshot.status !== "ready" || snapshot.value === void 0) return null;
+  var fields = snapshot.value.summaryFields;
+  var title = __ch4acko3DshTurnFoldText("settings.title");
+  function toggleField(field, checked) {
+    if (!snapshot.writable || pending) return;
+    var next = __ch4acko3DshTurnFoldKnownFields.filter(function (candidate) {
+      return candidate === field ? checked : fields.indexOf(candidate) >= 0;
+    });
+    setPending(true);
+    setFailed(false);
+    scope.set("summaryFields", next).then(function () {
+      setPending(false);
+    }, function () {
+      setPending(false);
+      setFailed(true);
+    });
+  }
+  return react_jsx_runtime.jsxs("li", {
+    className: "__ch4acko3-dsh-turn-fold-settings" + (open ? " __ch4acko3-dsh-turn-fold-settings--open" : ""),
+    "data-ch4acko3-dsh-turn-fold-settings": "",
+    children: [
+      react_jsx_runtime.jsxs("button", {
+        type: "button",
+        className: "__ch4acko3-dsh-turn-fold-settings__header",
+        "aria-expanded": open,
+        "aria-label": __ch4acko3DshTurnFoldText(open ? "settings.collapse" : "settings.expand", { title: title }),
+        onClick: function () { setOpen(!open); },
+        children: [
+          react_jsx_runtime.jsxs("span", {
+            className: "__ch4acko3-dsh-turn-fold-settings__headText",
+            children: [
+              react_jsx_runtime.jsx("span", { className: "__ch4acko3-dsh-turn-fold-settings__title", children: title }),
+              react_jsx_runtime.jsx("span", { className: "__ch4acko3-dsh-turn-fold-settings__description", children: __ch4acko3DshTurnFoldText("settings.description") })
+            ]
+          }),
+          react_jsx_runtime.jsx(__ch4acko3DshTurnFoldChevron, {})
+        ]
+      }),
+      open ? react_jsx_runtime.jsxs("div", {
+        className: "__ch4acko3-dsh-turn-fold-settings__body",
+        children: [
+          !snapshot.writable ? react_jsx_runtime.jsx("p", { className: "__ch4acko3-dsh-turn-fold-settings__readOnly", role: "status", children: __ch4acko3DshTurnFoldText("settings.readOnly") }) : null,
+          failed ? react_jsx_runtime.jsx("p", { className: "__ch4acko3-dsh-turn-fold-settings__readOnly", role: "alert", children: __ch4acko3DshTurnFoldText("settings.writeFailed") }) : null,
+          __ch4acko3DshTurnFoldKnownFields.map(function (field) {
+            return react_jsx_runtime.jsxs("label", {
+              className: "__ch4acko3-dsh-turn-fold-settings__field",
+              children: [
+                react_jsx_runtime.jsx("input", {
+                  type: "checkbox",
+                  checked: fields.indexOf(field) >= 0,
+                  disabled: !snapshot.writable || pending,
+                  onChange: function (event) { toggleField(field, event.currentTarget.checked); }
+                }),
+                react_jsx_runtime.jsx("span", { children: __ch4acko3DshTurnFoldText("settings." + field) })
+              ]
+            }, field);
+          })
+        ]
+      }) : null
+    ]
+  });
+}
+function __ch4acko3DshTurnFoldLiveDuration(metrics, running) {
+  var nowState = react.useState(function () { return Date.now(); });
+  var now = nowState[0];
+  var setNow = nowState[1];
+  react.useEffect(function () {
+    if (!running || typeof metrics.startTime !== "number") return;
+    var timer = setInterval(function () { setNow(Date.now()); }, 1000);
+    return function () { clearInterval(timer); };
+  }, [running, metrics.startTime]);
+  if (running && typeof metrics.startTime === "number") return Math.max(0, now - metrics.startTime);
+  return metrics.durationMs;
+}
+function __ch4acko3DshTurnFoldSpacedDuration(value) {
+  return value.replace(/(\d)(?=(?:小时|分钟|秒|分|时))/g, "$1 ").replace(/(小时|分钟|秒|分|时)(?=\d)/g, "$1 ");
+}
+function __ch4acko3DshTurnFoldAnimatedPart(field, key, parameter, display, animationKey, qualifier) {
+  var marker = "__ch4acko3_dsh_turn_fold_value__";
+  var params = {};
+  params[parameter] = marker;
+  var template = __ch4acko3DshTurnFoldText(key, params);
+  var position = template.indexOf(marker);
+  if (position < 0) throw new Error("@ch4acko3/dsh-turn-fold: summary locale omitted {" + parameter + "} for " + key);
+  qualifier = qualifier || "";
+  return {
+    field: field,
+    text: template.slice(0, position) + qualifier + display + template.slice(position + marker.length),
+    prefix: template.slice(0, position) + qualifier,
+    value: display,
+    suffix: template.slice(position + marker.length),
+    rolling: true,
+    animationKey: String(animationKey)
+  };
+}
+function __ch4acko3DshTurnFoldCountPart(field, key, count, display, qualifier) {
+  return __ch4acko3DshTurnFoldAnimatedPart(field, key, "count", display, count, qualifier);
+}
+function __ch4acko3DshTurnFoldDurationPart(field, key, duration) {
+  var part = __ch4acko3DshTurnFoldAnimatedPart(field, key, "duration", duration, duration);
+  part.segments = duration.split(/(\d+)/).filter(function (segment) { return segment.length > 0; });
+  return part;
+}
+function __ch4acko3DshTurnFoldSummaryParts(metrics, running, settled, completed, durationT) {
+  var fields = react.useSyncExternalStore(__ch4acko3DshTurnFoldSubscribeSettings, __ch4acko3DshTurnFoldGetSettingsSnapshot, __ch4acko3DshTurnFoldGetSettingsSnapshot);
+  var durationMs = __ch4acko3DshTurnFoldLiveDuration(metrics, running);
+  var parts = [];
+  for (var i = 0; i < fields.length; i++) {
+    var field = fields[i];
+    var value = metrics[field];
+    if (field === "duration") {
+      if (typeof durationMs === "number" && isFinite(durationMs) && durationMs >= 0) {
+        var duration = __ch4acko3DshTurnFoldSpacedDuration(formatRunDuration(durationMs, durationT));
+        parts.push(__ch4acko3DshTurnFoldDurationPart(field, completed ? "summary.elapsed" : "summary.duration", duration));
+      }
+    } else if (field === "toolCalls" || field === "modelCalls") {
+      if (typeof value === "number") parts.push(__ch4acko3DshTurnFoldCountPart(field, "summary." + field + (value === 1 ? ".one" : ".many"), value, String(value)));
+    } else if (field === "timeToFirstToken") {
+      if (typeof value === "number") parts.push({ field: field, text: __ch4acko3DshTurnFoldText("summary.timeToFirstToken", { seconds: value < 10000 ? Math.round(value / 100) / 10 : Math.round(value / 1000) }) });
+    } else if (field === "tokensPerSecond") {
+      if (typeof value === "number") parts.push({ field: field, text: __ch4acko3DshTurnFoldText("summary.tokensPerSecond", { count: value >= 10 ? Math.round(value) : Math.round(value * 10) / 10 }) });
+    } else if (typeof value === "number") {
+      parts.push(__ch4acko3DshTurnFoldCountPart(field, "summary." + field, value, formatTokens(value), metrics.tokenUsagePartial && settled ? "≥ " : ""));
+    }
+  }
+  return parts.length === 0 ? [{ field: "activity", text: __ch4acko3DshTurnFoldText("summary.activity") }] : parts;
+}
+function __ch4acko3DshTurnFoldSummaryLabel(parts) {
+  return parts.map(function (part) { return part.text; }).join(" | ");
+}
+function __ch4acko3DshTurnFoldStatusSuffix(termination) {
+  if (termination === "aborted") return __ch4acko3DshTurnFoldText("summary.stoppedSuffix");
+  if (termination === "interrupted") return __ch4acko3DshTurnFoldText("summary.interruptedSuffix");
+  return "";
+}
+function __ch4acko3DshTurnFoldSummaryChildren(parts, disclosure, statusSuffix) {
+  var children = [];
+  for (var i = 0; i < parts.length; i++) {
+    var part = parts[i];
+    if (i > 0) children.push(react_jsx_runtime.jsx("span", { className: "__ch4acko3-dsh-turn-fold__separator", "aria-hidden": true }, "separator-" + i));
+    var animatedValue = part.segments === void 0
+      ? react_jsx_runtime.jsx("span", {
+        className: "__ch4acko3-dsh-turn-fold__metricWindow",
+        children: react_jsx_runtime.jsx("span", { className: "__ch4acko3-dsh-turn-fold__metricValue", children: part.value }, part.field + "-" + part.animationKey)
+      }, "value")
+      : part.segments.map(function (segment, segmentIndex) {
+        return /^\d+$/.test(segment) ? react_jsx_runtime.jsx("span", {
+          className: "__ch4acko3-dsh-turn-fold__metricWindow",
+          children: react_jsx_runtime.jsx("span", { className: "__ch4acko3-dsh-turn-fold__metricValue", children: segment }, part.field + "-" + segmentIndex + "-" + segment)
+        }, "segment-" + segmentIndex) : segment;
+      });
+    var content = part.rolling ? [part.prefix, animatedValue, part.suffix] : part.text;
+    children.push((part.rolling ? react_jsx_runtime.jsxs : react_jsx_runtime.jsx)("span", { className: "__ch4acko3-dsh-turn-fold__metric", children: content }, part.field));
+  }
+  if (statusSuffix) children.push(react_jsx_runtime.jsx("span", { className: "__ch4acko3-dsh-turn-fold__metric", children: statusSuffix }, "status"));
+  if (disclosure) children.push(react_jsx_runtime.jsx(__ch4acko3DshTurnFoldChevron, {}, "chevron"));
+  return children;
+}
+function __ch4acko3DshTurnFoldSummary(props) {
+  var parts = __ch4acko3DshTurnFoldSummaryParts(props.metrics, props.running, props.settled, props.completed, props.t);
+  var statusSuffix = __ch4acko3DshTurnFoldStatusSuffix(props.termination);
+  var label = __ch4acko3DshTurnFoldSummaryLabel(parts) + statusSuffix;
+  return react_jsx_runtime.jsxs("div", {
+    className: "__ch4acko3-dsh-turn-fold",
+    "data-ch4acko3-dsh-turn-fold-summary": props.running ? "running" : "complete",
+    "data-dsh-summary-owner": "@ch4acko3/dsh-turn-fold",
+    children: [
+      react_jsx_runtime.jsx("div", {
+        className: "__ch4acko3-dsh-turn-fold__header",
+        role: props.running ? "status" : void 0,
+        "aria-label": props.running ? label : void 0,
+        children: react_jsx_runtime.jsxs("span", { className: "__ch4acko3-dsh-turn-fold__label", "aria-hidden": props.running ? true : void 0, children: __ch4acko3DshTurnFoldSummaryChildren(parts, false, statusSuffix) })
+      }),
+      react_jsx_runtime.jsx("div", { className: "__ch4acko3-dsh-turn-fold__rule", "aria-hidden": true })
+    ]
+  });
+}
+function __ch4acko3DshTurnFoldNodeTurn(node) {
+  var location = node === void 0 ? void 0 : node.location;
+  return location !== void 0 && (location.kind === "turn" || location.kind === "step") ? location.turn.turn : null;
+}
+function __ch4acko3DshTurnFoldHasVisibleNonReasoning(node) {
+  var blocks = node.data === void 0 ? void 0 : node.data.blocks;
+  if (!Array.isArray(blocks)) return false;
+  for (var i = 0; i < blocks.length; i++) {
+    var block = blocks[i];
+    if (block === void 0 || block.kind === "reasoning" || block.kind === "tool-call") continue;
+    if (block.kind !== "text" || typeof block.text !== "string" || block.text.trim() !== "") return true;
+  }
+  return false;
+}
+function __ch4acko3DshTurnFoldHasToolCallBlock(node) {
+  var blocks = node.data === void 0 ? void 0 : node.data.blocks;
+  return Array.isArray(blocks) && blocks.some(function (block) { return block !== void 0 && block.kind === "tool-call"; });
+}
+function __ch4acko3DshTurnFoldIsActivityNode(node) {
+  if (node.kind === "tool-call") return true;
+  if (node.kind !== "assistant-step" || __ch4acko3DshTurnFoldReasoningTexts(node).length === 0) return false;
+  return __ch4acko3DshTurnFoldHasToolCallBlock(node) || !__ch4acko3DshTurnFoldHasVisibleNonReasoning(node);
+}
+function __ch4acko3DshTurnFoldRenderNativeEntry(entry, renderNode, hideReasoning) {
+  var rendered = renderNode(entry.key);
+  if (hideReasoning) rendered = react_jsx_runtime.jsx("div", {
+    className: "__ch4acko3-dsh-turn-fold__activityText",
+    children: rendered
+  }, "activity-text:" + String(entry.key));
+  return entry.closingKey === void 0 ? rendered : react_jsx_runtime.jsx("div", {
+    className: "__ch4acko3-dsh-turn-fold__closing",
+    children: rendered
+  }, entry.closingKey);
+}
+function __ch4acko3DshTurnFoldRenderEntries(entries, nodeStore, renderNode, sessionId, interactionKeys, t) {
+  var out = [];
+  for (var i = 0; i < entries.length; i++) {
+    var entry = entries[i];
+    if (entry.type === "element") {
+      out.push(entry.element);
+      continue;
+    }
+    var turn = __ch4acko3DshTurnFoldNodeTurn(entry.node);
+    if (!__ch4acko3DshTurnFoldIsActivityNode(entry.node)) {
+      out.push(__ch4acko3DshTurnFoldRenderNativeEntry(entry, renderNode, false));
+      continue;
+    }
+    var activityEntries = [entry];
+    var j = i + 1;
+    while (j < entries.length) {
+      var next = entries[j];
+      if (next.type !== "node" || !__ch4acko3DshTurnFoldIsActivityNode(next.node) || next.order !== activityEntries[activityEntries.length - 1].order + 1 || __ch4acko3DshTurnFoldNodeTurn(next.node) !== turn) break;
+      if (__ch4acko3DshTurnFoldHasVisibleNonReasoning(next.node)) break;
+      activityEntries.push(next);
+      j++;
+    }
+    var selected = activityEntries.some(function (activityEntry) { return interactionKeys.has(activityEntry.key); });
+    if (turn === null || activityEntries.length < 2 || selected) {
+      for (var k = 0; k < activityEntries.length; k++) out.push(__ch4acko3DshTurnFoldRenderNativeEntry(activityEntries[k], renderNode, false));
+    } else {
+      var items = [];
+      var toolKeys = [];
+      for (var activityIndex = 0; activityIndex < activityEntries.length; activityIndex++) {
+        var activityEntry = activityEntries[activityIndex];
+        if (activityEntry.node.kind === "tool-call") {
+          toolKeys.push(activityEntry.key);
+          items.push({ kind: "tool", key: activityEntry.key });
+        } else {
+          var texts = __ch4acko3DshTurnFoldReasoningTexts(activityEntry.node);
+          for (var textIndex = 0; textIndex < texts.length; textIndex++) items.push({ kind: "reasoning", key: String(activityEntry.key) + ":" + String(textIndex), text: texts[textIndex] });
+        }
+      }
+      if (__ch4acko3DshTurnFoldHasVisibleNonReasoning(entry.node)) out.push(__ch4acko3DshTurnFoldRenderNativeEntry(entry, renderNode, true));
+      var facts = __ch4acko3DshTurnFoldToolFacts(toolKeys, nodeStore);
+      var foldKey = "activity:" + String(sessionId) + ":" + String(turn) + ":" + String(entry.key);
+      out.push(react_jsx_runtime.jsx(__ch4acko3DshTurnFoldActivityGroup, {
+        failed: facts.failed,
+        foldKey: foldKey,
+        items: items,
+        renderNode: renderNode,
+        running: facts.running,
+        t: t
+      }, foldKey));
+    }
+    i = j - 1;
+  }
+  return out;
+}
+function __ch4acko3DshTurnFoldRenderKeys(keys, orderPositions, nodeStore, renderNode, sessionId, t) {
+  var entries = [];
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    var node = nodeStore.get(key);
+    if (node !== void 0) entries.push({ type: "node", key: key, node: node, order: orderPositions.get(key) });
+  }
+  return __ch4acko3DshTurnFoldRenderEntries(entries, nodeStore, renderNode, sessionId, new Set(), t);
+}
+function __ch4acko3DshTurnFoldDisclosure(props) {
+  var activity = props.activity;
+  var foldKey = props.foldKey;
+  var renderNode = props.renderNode;
+  var initialOpen = __ch4acko3DshTurnFoldOpenKeys.has(foldKey);
+  var expandedState = react.useState(initialOpen);
+  var expanded = expandedState[0];
+  var setExpanded = expandedState[1];
+  var renderedState = react.useState(initialOpen);
+  var bodyRendered = renderedState[0];
+  var setBodyRendered = renderedState[1];
+  var frameRef = react.useRef(null);
+  var timerRef = react.useRef(null);
+  var bodyIdState = react.useState(function () { return "ch4acko3-dsh-turn-fold-body-" + (++__ch4acko3DshTurnFoldBodyId); });
+  var bodyId = bodyIdState[0];
+  react.useEffect(function () {
+    return function () {
+      if (frameRef.current !== null && typeof cancelAnimationFrame === "function") cancelAnimationFrame(frameRef.current);
+      if (timerRef.current !== null) clearTimeout(timerRef.current);
+    };
+  }, []);
+  var parts = __ch4acko3DshTurnFoldSummaryParts(props.metrics, false, true, props.completed, props.t);
+  var statusSuffix = __ch4acko3DshTurnFoldStatusSuffix(props.termination);
+  var label = __ch4acko3DshTurnFoldSummaryLabel(parts) + statusSuffix;
+  var actionLabel = __ch4acko3DshTurnFoldText(expanded ? "action.collapse" : "action.expand", { summary: label });
+  function toggle() {
+    if (frameRef.current !== null && typeof cancelAnimationFrame === "function") cancelAnimationFrame(frameRef.current);
+    if (timerRef.current !== null) clearTimeout(timerRef.current);
+    frameRef.current = null;
+    timerRef.current = null;
+    if (expanded) {
+      __ch4acko3DshTurnFoldOpenKeys.delete(foldKey);
+      setExpanded(false);
+      var delay = __ch4acko3DshTurnFoldMotionMs();
+      if (delay === 0) setBodyRendered(false);
+      else timerRef.current = setTimeout(function () {
+        timerRef.current = null;
+        setBodyRendered(false);
+      }, delay);
+      return;
+    }
+    __ch4acko3DshTurnFoldOpenKeys.add(foldKey);
+    setBodyRendered(true);
+    if (__ch4acko3DshTurnFoldMotionMs() === 0 || typeof requestAnimationFrame !== "function") {
+      setExpanded(true);
+      return;
+    }
+    frameRef.current = requestAnimationFrame(function () {
+      frameRef.current = null;
+      setExpanded(true);
+    });
+  }
+  return react_jsx_runtime.jsxs("div", {
+    className: "__ch4acko3-dsh-turn-fold" + (expanded ? " __ch4acko3-dsh-turn-fold--open" : ""),
+    "data-ch4acko3-dsh-turn-fold": "",
+    "data-ch4acko3-dsh-turn-fold-open": expanded ? "true" : "false",
+    "data-dsh-fold-owner": "@ch4acko3/dsh-turn-fold",
+    "data-dsh-fold-scope": "turn",
+    children: [
+      react_jsx_runtime.jsx("button", {
+        type: "button",
+        className: "__ch4acko3-dsh-turn-fold__header",
+        "aria-expanded": expanded,
+        "aria-controls": bodyId,
+        "aria-label": actionLabel,
+        title: actionLabel,
+        onClick: toggle,
+        children: react_jsx_runtime.jsxs("span", { className: "__ch4acko3-dsh-turn-fold__label", "aria-hidden": true, children: __ch4acko3DshTurnFoldSummaryChildren(parts, true, statusSuffix) })
+      }),
+      react_jsx_runtime.jsx("div", { className: "__ch4acko3-dsh-turn-fold__rule", "aria-hidden": true }),
+      react_jsx_runtime.jsx("div", {
+        id: bodyId,
+        className: "__ch4acko3-dsh-turn-fold__clip",
+        "aria-hidden": !expanded,
+        inert: !expanded,
+        children: bodyRendered ? react_jsx_runtime.jsx("div", {
+          className: "__ch4acko3-dsh-turn-fold__bodyWrap",
+          children: react_jsx_runtime.jsxs("div", {
+            className: "__ch4acko3-dsh-turn-fold__body",
+            children: [
+              __ch4acko3DshTurnFoldRenderKeys(activity, props.orderPositions, props.nodeStore, renderNode, props.sessionId, props.t),
+              (props.closingReasoning || []).map(function (text, index) {
+                return react_jsx_runtime.jsx(ReasoningRow, { text: text, running: false, t: props.t }, "closing-reasoning-" + index);
+              })
+            ]
+          })
+        }) : null
+      })
+    ]
+  });
+}
+function __ch4acko3DshTurnFoldPlaybackTime(timeline) {
+  var clock = timeline.playbackClock;
+  return clock !== void 0 && clock.kind === "historical" && typeof clock.time === "number" && isFinite(clock.time)
+    ? clock.time
+    : null;
+}
+function __ch4acko3DshTurnFoldPlanMetrics(plan, nodeStore, timeline) {
+  var turnLoc = timeline.turns.get(plan.turn);
+  var startEv = turnLoc === void 0 ? void 0 : turnLoc.start;
+  var endEv = turnLoc === void 0 ? void 0 : turnLoc.end;
+  var startTime = startEv !== void 0 && typeof startEv.time === "number" ? startEv.time : null;
+  var complete = startTime !== null && endEv !== void 0 && typeof endEv.time === "number";
+  var playbackTime = __ch4acko3DshTurnFoldPlaybackTime(timeline);
+  var durationMs = complete && endEv.time >= startTime
+    ? endEv.time - startTime
+    : startTime !== null && playbackTime !== null
+      ? Math.max(0, playbackTime - startTime)
+      : null;
+  var metrics = {
+    startTime: startTime,
+    durationMs: durationMs,
+    toolCalls: 0,
+    modelCalls: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    reasoningTokens: 0,
+    tokenUsagePartial: false,
+    timeToFirstToken: null,
+    tokensPerSecond: null
+  };
+  var usageReliable = true;
+  var usageSamples = 0;
+  var decodeMs = 0;
+  var decodeTokens = 0;
+  var sampledDecode = false;
+  var firstStep = null;
+  var keys = plan.activity.slice();
+  if (plan.closingKey !== void 0 && keys.indexOf(plan.closingKey) < 0) keys.push(plan.closingKey);
+  for (var i = 0; i < keys.length; i++) {
+    var node = nodeStore.get(keys[i]);
+    if (node === void 0) continue;
+    if (node.kind === "tool-call") metrics.toolCalls++;
+    if (node.kind !== "assistant-step") continue;
+    metrics.modelCalls++;
+    var data = node.data === void 0 ? {} : node.data;
+    var usage = __ch4acko3DshTurnFoldUsage(data.usage);
+    if (usage === null) usageReliable = false;
+    else {
+      usageSamples++;
+      metrics.inputTokens += usage.inputTokens;
+      metrics.outputTokens += usage.outputTokens;
+      metrics.cacheReadTokens += usage.cacheReadTokens;
+      metrics.cacheWriteTokens += usage.cacheWriteTokens;
+      metrics.reasoningTokens += usage.reasoningTokens;
+    }
+    var finalNode = data.finalNode;
+    var timing = finalNode === void 0 ? void 0 : finalNode.timing;
+    var step = typeof data.step === "number" ? data.step : i;
+    if (timing !== void 0 && timing.stepStartTime !== null && timing.firstTokenTime !== null && (firstStep === null || step < firstStep)) {
+      firstStep = step;
+      metrics.timeToFirstToken = Math.max(0, timing.firstTokenTime - timing.stepStartTime);
+    }
+    if (timing !== void 0 && timing.firstTokenTime !== null && typeof timing.completedTime === "number" && usage !== null) {
+      decodeMs += Math.max(0, timing.completedTime - timing.firstTokenTime);
+      decodeTokens += usage.outputTokens;
+      sampledDecode = true;
+    }
+  }
+  if (sampledDecode && decodeMs > 0) metrics.tokensPerSecond = decodeTokens / (decodeMs / 1000);
+  if (!usageReliable) {
+    metrics.tokenUsagePartial = usageSamples > 0;
+    if (usageSamples === 0) {
+      metrics.inputTokens = null;
+      metrics.outputTokens = null;
+      metrics.cacheReadTokens = null;
+      metrics.cacheWriteTokens = null;
+      metrics.reasoningTokens = null;
+    }
+  }
+  return metrics;
+}
+function __ch4acko3DshTurnFoldRender(props) {
+  var order = props.order;
+  var nodeStore = props.nodeStore;
+  var timeline = props.timeline;
+  var playbackTime = __ch4acko3DshTurnFoldPlaybackTime(timeline);
+  var renderNode = props.renderNode;
+  var sessionId = props.sessionId;
+  var orderPositions = new Map();
+  var FOLD_KINDS = {
+    "assistant-step": true,
+    "context": true,
+    "tool-call": true,
+    "command": true,
+    "manual-compaction": true,
+    "compaction": true,
+    "model-retry": true
+  };
+  var plans = new Map();
+  var i, key, node, loc, turnNum, plan;
+  for (i = 0; i < order.length; i++) {
+    key = order[i];
+    orderPositions.set(key, i);
+    node = nodeStore.get(key);
+    if (node === void 0) continue;
+    loc = node.location;
+    if (loc === void 0 || (loc.kind !== "turn" && loc.kind !== "step")) continue;
+    turnNum = loc.turn.turn;
+    plan = plans.get(turnNum);
+    if (plan === void 0) {
+      plan = { turn: turnNum, status: loc.turn.status, endReason: void 0, closingSeq: void 0, closingKey: void 0, closingOrder: -1, closingReasoning: [], tailKey: void 0, branchUnavailable: false, hasAfterClosing: false, hasError: false, activity: [], firstActivityOrder: -1 };
+      plans.set(turnNum, plan);
+    }
+    var endEvent = loc.turn.end;
+    if (endEvent !== void 0 && endEvent.data !== void 0 && endEvent.data.reason !== void 0) plan.endReason = endEvent.data.reason.kind;
+    if (node.kind === "turn-tail") {
+      plan.tailKey = key;
+      var closing = node.data === void 0 ? void 0 : node.data.closing;
+      if (closing !== null && closing !== void 0 && closing.finalNode !== void 0) plan.closingSeq = closing.finalNode.seq;
+      plan.branchUnavailable = node.data !== void 0 && node.data.branchUnavailable === true;
+    } else if (node.kind === "turn-error" || node.kind === "turn-max-tokens") {
+      plan.hasError = true;
+    }
+  }
+  for (i = 0; i < order.length; i++) {
+    key = order[i];
+    node = nodeStore.get(key);
+    if (node === void 0) continue;
+    loc = node.location;
+    if (loc === void 0 || (loc.kind !== "turn" && loc.kind !== "step")) continue;
+    plan = plans.get(loc.turn.turn);
+    if (plan === void 0) continue;
+    if (plan.closingSeq !== void 0 && node.kind === "assistant-step" && node.data !== void 0 && node.data.finalNode !== void 0 && node.data.finalNode.seq === plan.closingSeq) {
+      plan.closingKey = key;
+      plan.closingOrder = i;
+      plan.closingReasoning = __ch4acko3DshTurnFoldReasoningTexts(node);
+    }
+  }
+  for (i = 0; i < order.length; i++) {
+    key = order[i];
+    node = nodeStore.get(key);
+    if (node === void 0) continue;
+    loc = node.location;
+    if (loc === void 0 || (loc.kind !== "turn" && loc.kind !== "step")) continue;
+    plan = plans.get(loc.turn.turn);
+    if (plan === void 0 || key === plan.closingKey || key === plan.tailKey) continue;
+    if (plan.closingOrder >= 0 && i > plan.closingOrder) plan.hasAfterClosing = true;
+    if (FOLD_KINDS[node.kind] === true) {
+      if (plan.firstActivityOrder < 0) plan.firstActivityOrder = i;
+      plan.activity.push(key);
+    }
+  }
+  var entries = [];
+  var interactionKeys = __ch4acko3DshTurnFoldInteractionKeys();
+  for (i = 0; i < order.length; i++) {
+    key = order[i];
+    node = nodeStore.get(key);
+    if (node === void 0) continue;
+    loc = node.location;
+    var isTurn = loc !== void 0 && (loc.kind === "turn" || loc.kind === "step");
+    plan = isTurn ? plans.get(loc.turn.turn) : void 0;
+    var foldable = plan !== void 0 && plan.status === "closed" && (plan.endReason === "completed" || plan.endReason === "aborted" || plan.endReason === "interrupted") && !plan.hasError && !plan.branchUnavailable && !plan.hasAfterClosing && plan.closingKey !== void 0 && (plan.activity.length > 0 || plan.closingReasoning.length > 0) && !plan.activity.some(function (activityKey) { return interactionKeys.has(activityKey); });
+    if (foldable && FOLD_KINDS[node.kind] === true && key !== plan.closingKey) continue;
+    var summaryAnchor = plan === void 0 ? void 0 : plan.closingKey !== void 0 && (plan.firstActivityOrder < 0 || plan.closingOrder < plan.firstActivityOrder) ? plan.closingKey : plan.activity[0];
+    if (plan !== void 0 && !foldable && summaryAnchor !== void 0 && key === summaryAnchor) {
+      entries.push({ type: "element", element: react_jsx_runtime.jsx(__ch4acko3DshTurnFoldSummary, {
+        completed: plan.endReason === "completed",
+        metrics: __ch4acko3DshTurnFoldPlanMetrics(plan, nodeStore, timeline),
+        termination: plan.endReason === "aborted" || plan.endReason === "interrupted" ? plan.endReason : void 0,
+        running: plan.status !== "closed" && playbackTime === null,
+        settled: plan.status === "closed",
+        t: props.t
+      }, "ch4acko3-dsh-turn-fold-summary-" + String(sessionId) + "-" + plan.turn) });
+    }
+    if (foldable && key === plan.closingKey) {
+      entries.push({ type: "element", element: react_jsx_runtime.jsx(__ch4acko3DshTurnFoldDisclosure, {
+        activity: plan.activity,
+        closingReasoning: plan.closingReasoning,
+        completed: plan.endReason === "completed",
+        metrics: __ch4acko3DshTurnFoldPlanMetrics(plan, nodeStore, timeline),
+        nodeStore: nodeStore,
+        orderPositions: orderPositions,
+        sessionId: sessionId,
+        termination: plan.endReason === "aborted" || plan.endReason === "interrupted" ? plan.endReason : void 0,
+        foldKey: String(sessionId) + ":" + plan.turn,
+        renderNode: renderNode,
+        t: props.t
+      }, "ch4acko3-dsh-turn-fold-" + String(sessionId) + "-" + plan.turn) });
+    }
+    entries.push({
+      type: "node",
+      key: key,
+      node: node,
+      order: i,
+      closingKey: foldable && key === plan.closingKey && plan.closingReasoning.length > 0 ? "ch4acko3-dsh-turn-fold-closing-" + String(sessionId) + "-" + plan.turn : void 0
+    });
+  }
+  return __ch4acko3DshTurnFoldRenderEntries(entries, nodeStore, renderNode, sessionId, interactionKeys, props.t);
+}
+`;

package/locales/en.json

@@ -0,0 +1,43 @@
+{
+  "summary.activity": "Agent activity",
+  "summary.duration": "Worked for {duration}",
+  "summary.elapsed": "Took {duration}",
+  "summary.toolCalls.one": "{count} tool call",
+  "summary.toolCalls.many": "{count} tool calls",
+  "summary.modelCalls.one": "{count} model call",
+  "summary.modelCalls.many": "{count} model calls",
+  "summary.inputTokens": "{count} input tokens",
+  "summary.outputTokens": "{count} output tokens",
+  "summary.cacheReadTokens": "{count} cache-read tokens",
+  "summary.cacheWriteTokens": "{count} cache-write tokens",
+  "summary.reasoningTokens": "{count} reasoning tokens",
+  "summary.timeToFirstToken": "First token in {seconds}s",
+  "summary.tokensPerSecond": "{count} tokens/s",
+  "summary.stoppedSuffix": " - Stopped",
+  "summary.interruptedSuffix": " - Interrupted",
+  "activityGroup.think": "Think",
+  "activityGroup.tools.one": "{count} tool call",
+  "activityGroup.tools.many": "{count} tool calls",
+  "activityGroup.thinkAndTools.one": "Think · {count} tool call",
+  "activityGroup.thinkAndTools.many": "Think · {count} tool calls",
+  "activityGroup.failures.one": "{count} failed",
+  "activityGroup.failures.many": "{count} failed",
+  "action.expand": "Expand agent activity: {summary}",
+  "action.collapse": "Collapse agent activity: {summary}",
+  "settings.title": "Turn Fold",
+  "settings.description": "Choose the metrics shown in the turn summary bar.",
+  "settings.expand": "Expand settings: {title}",
+  "settings.collapse": "Collapse settings: {title}",
+  "settings.readOnly": "This settings source is read-only.",
+  "settings.writeFailed": "Could not save this setting.",
+  "settings.duration": "Elapsed time",
+  "settings.toolCalls": "Tool calls",
+  "settings.modelCalls": "Model calls",
+  "settings.inputTokens": "Input tokens",
+  "settings.outputTokens": "Output tokens",
+  "settings.cacheReadTokens": "Cache-read tokens",
+  "settings.cacheWriteTokens": "Cache-write tokens",
+  "settings.reasoningTokens": "Reasoning tokens",
+  "settings.timeToFirstToken": "Time to first token",
+  "settings.tokensPerSecond": "Output speed"
+}

package/locales/zh.json

@@ -0,0 +1,43 @@
+{
+  "summary.activity": "执行过程",
+  "summary.duration": "已工作 {duration}",
+  "summary.elapsed": "耗时 {duration}",
+  "summary.toolCalls.one": "{count} 次工具调用",
+  "summary.toolCalls.many": "{count} 次工具调用",
+  "summary.modelCalls.one": "{count} 次模型调用",
+  "summary.modelCalls.many": "{count} 次模型调用",
+  "summary.inputTokens": "{count} 输入 tokens",
+  "summary.outputTokens": "{count} 输出 tokens",
+  "summary.cacheReadTokens": "{count} 缓存读取 tokens",
+  "summary.cacheWriteTokens": "{count} 缓存写入 tokens",
+  "summary.reasoningTokens": "{count} 推理 tokens",
+  "summary.timeToFirstToken": "首 token 用时 {seconds} 秒",
+  "summary.tokensPerSecond": "{count} tokens/秒",
+  "summary.stoppedSuffix": " - 已停止",
+  "summary.interruptedSuffix": " - 已中断",
+  "activityGroup.think": "Think",
+  "activityGroup.tools.one": "{count} 次工具调用",
+  "activityGroup.tools.many": "{count} 次工具调用",
+  "activityGroup.thinkAndTools.one": "Think · {count} 次工具调用",
+  "activityGroup.thinkAndTools.many": "Think · {count} 次工具调用",
+  "activityGroup.failures.one": "{count} 个失败",
+  "activityGroup.failures.many": "{count} 个失败",
+  "action.expand": "展开执行过程：{summary}",
+  "action.collapse": "收起执行过程：{summary}",
+  "settings.title": "会话折叠",
+  "settings.description": "选择 turn 摘要栏中显示的指标。",
+  "settings.expand": "展开设置：{title}",
+  "settings.collapse": "收起设置：{title}",
+  "settings.readOnly": "当前设置来源为只读。",
+  "settings.writeFailed": "无法保存此设置。",
+  "settings.duration": "工作耗时",
+  "settings.toolCalls": "工具调用次数",
+  "settings.modelCalls": "模型调用次数",
+  "settings.inputTokens": "输入 tokens",
+  "settings.outputTokens": "输出 tokens",
+  "settings.cacheReadTokens": "缓存读取 tokens",
+  "settings.cacheWriteTokens": "缓存写入 tokens",
+  "settings.reasoningTokens": "推理 tokens",
+  "settings.timeToFirstToken": "首 token 用时",
+  "settings.tokensPerSecond": "输出速度"
+}

package/locales.cjs

@@ -0,0 +1,21 @@
+'use strict'
+
+const dictionaries = {
+  en: require('./locales/en.json'),
+  zh: require('./locales/zh.json'),
+}
+
+const expected = Object.keys(dictionaries.en).sort()
+for (const [locale, dictionary] of Object.entries(dictionaries)) {
+  const actual = Object.keys(dictionary).sort()
+  if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+    throw new Error(`@ch4acko3/dsh-turn-fold: locale ${locale} does not match the English key set`)
+  }
+  for (const [key, value] of Object.entries(dictionary)) {
+    if (typeof value !== 'string' || value.length === 0) {
+      throw new Error(`@ch4acko3/dsh-turn-fold: locale ${locale} has an invalid value for ${key}`)
+    }
+  }
+}
+
+module.exports = dictionaries

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@ch4acko3/dsh-turn-fold",
+  "version": "0.3.0",
+  "description": "Codex-style turn folding for the DSH WebUI conversation, implemented as a dsh-harmony provider.",
+  "main": "./index.cjs",
+  "files": [
+    "README.md",
+    "README.zh-CN.md",
+    "harmony.patch.yml",
+    "index.cjs",
+    "inline-source.cjs",
+    "locales.cjs",
+    "locales/*.json",
+    "settings.cjs",
+    "patch.cjs"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ch4acko3/dsh-turn-fold.git"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./harmony.patch.yml"
+    },
+    "harmony": {
+      "patches": ["./patch.cjs"]
+    },
+    "plugin": {
+      "schemaVersion": 1,
+      "displayName": {
+        "en": "Turn Fold",
+        "zh-CN": "Turn Fold"
+      },
+      "summary": {
+        "en": "Collapse each completed turn's agent activity into a summary bar; keep the final answer visible.",
+        "zh-CN": "将每个已完成 turn 的 Agent activity 折叠成摘要栏，最终答复保持可见。"
+      },
+      "category": "ui"
+    }
+  },
+  "scripts": {
+    "test": "node test/run.cjs",
+    "check": "node test/run.cjs"
+  },
+  "dependencies": {
+    "@deepseek-ai/dsh-settings": "0.1.0-rc.8",
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/dsh-client-ui-conversation": "0.1.0-rc.8",
+    "@phenomnomnominal/tsquery": "^6.2.0",
+    "react": "18.3.1",
+    "react-test-renderer": "18.3.1",
+    "typescript": "^6.0.3"
+  }
+}

package/patch.cjs

@@ -0,0 +1,67 @@
+// @ch4acko3/dsh-turn-fold — Harmony Source Patches for the DSH conversation chat flow.
+//
+// These three patches run in order, in memory only, against the compiled browser
+// bundle of @deepseek-ai/dsh-client-ui-conversation (lib/client.js). They never
+// modify the installed package.
+//
+//   1. inject-turn-fold-runtime  — injects the fold renderer + disclosure UI
+//      into the module factory, immediately before the ChatView component.
+//   2. rewrite-node-render-loop   — replaces the `order.map(...)` node render
+//      loop with a call to the injected renderer, which groups a completed
+//      turn's agent activity into a collapsible disclosure while keeping the
+//      final answer (turn-tail.closing.finalNode) and the turn tail visible.
+//   3. install-turn-fold-services — registers the plugin's native DSH locale
+//      namespace and binds its native settings scope during conversation boot.
+//
+// Both selectors are pinned with an exact `expect: 1` and a target version so
+// a compiled-shape drift fails loudly in `dsh harmony status`.
+
+const INLINE = require('./inline-source.cjs')
+
+const TARGET = {
+  package: '@deepseek-ai/dsh-client-ui-conversation',
+  version: '0.1.0-rc.8',
+  files: ['lib/client.js'],
+}
+
+module.exports = [
+  {
+    id: 'inject-turn-fold-runtime',
+    target: TARGET,
+    select: 'FunctionDeclaration[name.name="ChatView"], VariableStatement:has(VariableDeclaration[name.name="ChatView"])',
+    expect: 1,
+    apply({ node, sourceFile, edit }) {
+      edit.prependLeft(node.getStart(sourceFile), INLINE + '\n\n')
+    },
+  },
+  {
+    id: 'rewrite-node-render-loop',
+    target: TARGET,
+    select: 'CallExpression[expression.name.name="map"][expression.expression.name="order"]',
+    expect: 1,
+    apply({ node, sourceFile, edit }) {
+      const callback = node.arguments[0]
+      if (callback === undefined) throw new Error('@ch4acko3/dsh-turn-fold: order.map callback is missing')
+      const renderNode = sourceFile.text.slice(callback.getStart(sourceFile), callback.getEnd())
+      edit.overwrite(
+        node.getStart(sourceFile),
+        node.getEnd(),
+        `__ch4acko3DshTurnFoldRender({ order, nodeStore, timeline, sessionId, renderNode: ${renderNode}, t })`
+      )
+    },
+  },
+  {
+    id: 'install-turn-fold-services',
+    target: TARGET,
+    select: 'VariableStatement:has(VariableDeclaration[name.name="t"][initializer.expression.name.name="bind"])',
+    expect: 1,
+    apply({ node, sourceFile, edit }) {
+      const statement = sourceFile.text.slice(node.getStart(sourceFile), node.getEnd())
+      edit.overwrite(
+        node.getStart(sourceFile),
+        node.getEnd(),
+        `${statement}\n\t\t\t__ch4acko3DshTurnFoldInstall(ctx);`
+      )
+    },
+  },
+]

package/settings.cjs

@@ -0,0 +1,36 @@
+'use strict'
+
+const z = require('@deepseek-ai/schemastery')
+
+const SETTINGS_NAMESPACE = 'dsh-turn-fold'
+
+const SUMMARY_FIELDS = [
+  'duration',
+  'toolCalls',
+  'modelCalls',
+  'inputTokens',
+  'outputTokens',
+  'cacheReadTokens',
+  'cacheWriteTokens',
+  'reasoningTokens',
+  'timeToFirstToken',
+  'tokensPerSecond',
+]
+
+const DEFAULT_SUMMARY_FIELDS = [
+  'duration',
+  'toolCalls',
+  'inputTokens',
+  'outputTokens',
+]
+
+const Config = z.object({
+  summaryFields: z.array(z.union(SUMMARY_FIELDS)).default(DEFAULT_SUMMARY_FIELDS),
+})
+
+module.exports = {
+  Config,
+  DEFAULT_SUMMARY_FIELDS,
+  SETTINGS_NAMESPACE,
+  SUMMARY_FIELDS,
+}