dsh-cost-profiler 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dsh-cost-profiler contributors
+
+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

@@ -1,3 +1,147 @@
-# Temporary Holding Version
+# dsh-cost-profiler
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Turn-level cost & performance profiler for [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) — attribution, not just a balance display.
+
+The 4000-plugin DSH ecosystem has hundreds of "remaining quota" widgets, but nothing that answers *where* a session's tokens, seconds and cents actually went. This plugin folds the session's own event stream into a per-turn, per-model, per-tool profile and renders it on demand — **zero extra LLM calls, zero extra storage**.
+
+[中文说明](./README.zh.md)
+
+## What you get
+
+- **`/cost`** slash command — instant session report with three granularities:
+  - `/cost` / `/cost summary` — totals, per-model breakdown, slowest tools
+  - `/cost full` — adds the per-turn timeline (wall / LLM ≈ / tools ≈ / tokens / est. cost per turn)
+  - `/cost json` — machine-readable output for scripts and dashboards
+- **Cross-session rollup** — the built-in panels are strictly per-session; this is the only place that answers "what did this week / this workspace cost me across all sessions":
+  - `/cost week` / `/cost month` / `/cost all` — per-workspace and per-session tables with tokens and estimated cost (append `json` for machine output)
+- **`cost_report`** tool — the model can pull the same session report mid-session when you ask "how much have we spent so far?"
+- **`costProfiler` session projection** — the live aggregate behind both, also exposed on the client wire for dashboards.
+- **Rendered output** — command results and tool cards render as real Markdown (see [Rendering](#rendering)).
+
+### Sample output
+
+```
+Session cost $0.04 (est) · 2 turns · 27.6k in · 2.7k out · 88.5% cache hit · 58s wall
+
+**Turns** 2 · **Messages** 2 · **Retries** 0
+**Wall** 58s · **LLM ≈** 36.16s · **Tools ≈** 3.84s
+**Tokens** 27.6k in · 213.1k cache hit (88.5%) · 2.7k out · 5.5k reasoning
+**Estimated cost** $0.04 — API list prices (peak), USD
+
+| Model route | In (uncached) | Cache hit | Cache write | Out | Reasoning | Msgs | Est. cost |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+| `deepseek/deepseek-v4-pro` | 15.2k | 115k | 0 | 1.9k | 3.4k | 1 | $0.03 |
+| `deepseek/deepseek-flash` | 12.4k | 98.1k | 0 | 812 | 2.1k | 1 | $0.0053 |
+
+**Slowest tools**
+
+| Tool | Calls | Total | Max | Errors |
+| --- | ---: | ---: | ---: | ---: |
+| `bash` | 1 | 2.3s | 2.3s | 1 |
+| `read_file` | 1 | 1.54s | 1.54s | 0 |
+```
+
+## Rendering
+
+The same report text is rendered as Markdown in the chat, so tables arrive as
+tables instead of as raw pipe characters:
+
+- The `/cost` result renders through the chat's Markdown renderer
+  (`conversation.chat.commandview`), and a `cost_report` call renders through the
+  tool-call slot (`tool.call.toolview`).
+- The row's collapsed label is the report's own first line, which is written as
+  plain prose (`Session cost $0.04 (est) · 2 turns · …`) so it reads correctly
+  even where Markdown is not rendered.
+- Reports of up to 30 lines open by default; longer ones (`/cost full` on a busy
+  session) start collapsed behind that label — click the row to expand.
+- `/cost json` renders as a JSON code block, with the code block's copy button.
+- If the client half is unavailable (or Markdown rendering fails), the card
+  degrades to the monospace text the host sent. The report itself is always
+  plain text end to end — the model always sees text, not markup.
+
+Upgrading from a build without the client half? The plugin composition cache
+holds a package's client declaration for the lifetime of the process, so the
+app needs a full restart (not just a page reload) before the slot entries load.
+
+## Install
+
+Inside DSH (Plugins page, plugin manager tool, or CLI):
+
+```
+dsh plugin --profile <profile> add dsh-cost-profiler
+```
+
+Manual alternative — add the package to your profile's `package.json` dependencies and its name to `dsh.profile.bundles`, then run `pnpm install` in the profile directory. The bundle ships its own `cordis.patch.yml`, so no manual composition edits are needed.
+
+## How it works
+
+The plugin registers one pure [session projection](https://github.com/deepseek-ai/deepseek-harness) that folds durable session events (`assistant/message`, `tool/call` → `tool/result`, `turn/*`, `step/*`) into:
+
+- token buckets per model route (`{provider}/{model}`), including cache read/write and reasoning tokens — taken from authoritative `assistant/message` settlements only, so streamed samples and aborted retries never double-count (same semantics as the official token-usage projection);
+- tool durations from the `tool/call` → `tool/result` envelope-time delta, paired by `callId`, with per-tool call counts, totals, maxima and error counts;
+- turn walls and an `LLM ≈` estimate (step wall minus tool wall).
+
+Per-turn detail is capped (default 100 turns) while session totals always cover everything. State is plain JSON and survives projection checkpointing.
+
+## Cost estimates
+
+Costs are computed from **API list prices** and marked as estimates — subscription/quota billing may differ. Built-in defaults cover DeepSeek's published models (peak and off-peak schedules; off-peak is half of peak). Models without a configured price show `—` instead of a wrong number.
+
+The report language is set by the `language` config key (`en` or `zh`, default `en`) — the host half cannot read the app's UI language, so unlike the card chrome the report body does not switch automatically. `/cost json` values stay English regardless, for script stability.
+
+Set `showCosts: false` to omit costs entirely, or override prices per route in your profile's `cordis.patch.yml`:
+
+```yaml
+- id: cost-profiler
+  name: dsh-cost-profiler
+  config:
+    showCosts: true
+    offPeak: false          # estimate with off-peak (half-peak) rates
+    currency: USD           # display currency label
+    detailTurns: 100        # per-turn detail kept for /cost full
+    language: en            # report language: en | zh (card chrome follows the app UI)
+    prices:                 # currency per 1M tokens
+      deepseek/deepseek-flash: { input: 0.3, cacheRead: 0.006, cacheWrite: 0, output: 1.2 }
+      # bare-model or "default" keys also work as fallbacks
+      default: { input: 1, output: 2 }
+```
+
+## Cross-session rollup
+
+`/cost week` (also `month`, `all`) reads **locally stored sessions** and rolls them up — per-workspace totals plus a per-session table sorted by estimated cost. Nothing like this exists in the built-in panels, which are strictly per-session.
+
+Where the data comes from, in order of preference:
+
+1. this plugin's own checkpoint for that session (per-model-route buckets — priced most accurately);
+2. the app's official `tokenUsage` checkpoint (session totals without routes — priced via the session's last-used model, or your `default` price);
+3. replaying the session log directly (no checkpoint needed).
+
+Notes:
+
+- **Read-only and privacy-bounded**: the scan reads `~/.dsh` (`$DSH_HOME` respected), touches only titles, timestamps and usage/timing numbers — never message content — and writes nothing.
+- The current session's last events may lag by one checkpoint flush (typically seconds).
+- Sessions with no profiled activity are skipped; a window with nothing in it renders a pointer to `/cost all` rather than an empty table.
+- The `cost_report` model tool deliberately stays session-scoped — cross-session tables would bloat model context.
+
+## Notes & limitations
+
+- `LLM ≈` is derived from step timers, not per-request timings — treat it as an approximation.
+- The in-session profile covers the current session (subagent sessions have their own); cross-session rollup is its own feature (see above).
+- The `/cost` command reports text only; it does not enter model context. `/cost json` is the integration point for dashboards.
+- Card chrome (running/JSON/error labels, code-block buttons) follows the app's UI language (English/Chinese) through the app's locale registry; the report body itself is host-generated English.
+
+## Compatibility
+
+- DSH `0.2.0-rc.1` and later `0.2.0-rc.x` (peer range `^0.2.0-rc.1`), cordis `^4.0.1`, Node ≥ 20.
+- The host half is plain ESM with no build step and no native modules. The client half is a hand-written classic script (no bundler) that registers two UI slots and degrades to plain text if the chat UI is absent.
+
+## Development
+
+```
+npm install      # (not required for tests)
+node --test      # 44 unit tests over the fold/report/prices/history layers and the client half
+```
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/README.zh.md

@@ -0,0 +1,136 @@
+# dsh-cost-profiler
+
+[DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) 的 turn 级成本/性能剖析器 —— 做归因分析，而不只是余额显示。
+
+DSH 插件生态里有几百个"剩余额度"组件，但没有一个能回答：一个会话的 token、时间、费用到底花在了哪里。本插件把会话自身的事件流折叠成按 turn、按模型、按工具的剖析报告，按需渲染 —— **零额外 LLM 调用、零额外存储**。
+
+[English](./README.md)
+
+## 功能
+
+- **`/cost` 斜杠命令** —— 即时会话报告，三档粒度：
+  - `/cost` 或 `/cost summary` —— 总量、按模型分解、最慢工具排行
+  - `/cost full` —— 附加逐 turn 时间线（每 turn 的墙钟 / LLM ≈ / 工具 ≈ / token / 估算费用）
+  - `/cost json` —— 机器可读输出，便于脚本与面板集成
+- **跨会话汇总** —— 内置面板严格限于当前会话；「这周 / 这个工作区所有会话一共花了多少」只有这里能回答：
+  - `/cost week` / `/cost month` / `/cost all` —— 按工作区聚合 + 按会话明细（按估算费用排序，附 token 与费用；后缀 `json` 输出机器可读格式）
+- **`cost_report` 工具** —— 当你问"到目前为止花了多少"时，模型可以主动调用获取同一份报告
+- **`costProfiler` 会话投影** —— 上述两者的数据源，同时暴露在客户端 wire 上，供面板类集成使用
+- **渲染输出** —— 命令结果与工具卡片都以真 Markdown 渲染（见[输出渲染](#输出渲染)）
+
+### 输出示例
+
+```
+Session cost $0.04 (est) · 2 turns · 27.6k in · 2.7k out · 88.5% cache hit · 58s wall
+
+**Turns** 2 · **Messages** 2 · **Retries** 0
+**Wall** 58s · **LLM ≈** 36.16s · **Tools ≈** 3.84s
+**Tokens** 27.6k in · 213.1k cache hit (88.5%) · 2.7k out · 5.5k reasoning
+**Estimated cost** $0.04 — API list prices (peak), USD
+
+| Model route | In (uncached) | Cache hit | Cache write | Out | Reasoning | Msgs | Est. cost |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+| `deepseek/deepseek-v4-pro` | 15.2k | 115k | 0 | 1.9k | 3.4k | 1 | $0.03 |
+| `deepseek/deepseek-flash` | 12.4k | 98.1k | 0 | 812 | 2.1k | 1 | $0.0053 |
+
+**Slowest tools**
+
+| Tool | Calls | Total | Max | Errors |
+| --- | ---: | ---: | ---: | ---: |
+| `bash` | 1 | 2.3s | 2.3s | 1 |
+| `read_file` | 1 | 1.54s | 1.54s | 0 |
+```
+
+## 输出渲染
+
+同一份报告文本在聊天界面里以 Markdown 渲染，表格就是表格，而不是裸露的管道符：
+
+- `/cost` 的结果走聊天的 Markdown 渲染器（`conversation.chat.commandview` 槽），`cost_report` 调用走工具卡片槽（`tool.call.toolview`）。
+- 折叠行的标签就是报告首行本身，而首行写成纯文本散文（`Session cost $0.04 (est) · 2 turns · …`），因此在任何不渲染 Markdown 的位置也读得通。
+- 30 行以内的报告默认展开；更长的（繁忙会话的 `/cost full`）默认收起为那一行摘要 —— 点击行即可展开。
+- `/cost json` 渲染为 JSON 代码块，可用代码块自带的复制按钮。
+- 若客户端半边不可用（或 Markdown 渲染失败），卡片降级为宿主发出的等宽文本。报告全程都是纯文本 —— 模型看到的始终是文本，不是标记。
+
+从没有客户端半边的版本升级上来时：插件组合会按进程缓存包的客户端声明，因此需要**完全重启应用**（仅刷新页面无效）后槽才会加载。
+
+## 安装
+
+在 DSH 内（Plugins 页面、插件管理工具或 CLI）：
+
+```
+dsh plugin --profile <profile> add dsh-cost-profiler
+```
+
+手动方式：把包加进 profile 的 `package.json` 依赖，并把包名加进 `dsh.profile.bundles`，然后在 profile 目录运行 `pnpm install`。bundle 自带 `cordis.patch.yml`，无需手工改组合配置。
+
+## 工作原理
+
+插件注册一个纯[会话投影](https://github.com/deepseek-ai/deepseek-harness)，把持久化会话事件（`assistant/message`、`tool/call` → `tool/result`、`turn/*`、`step/*`）折叠为：
+
+- 按模型路由（`{provider}/{model}`）的 token 桶，含缓存读/写与推理 token —— 只取 `assistant/message` 的权威结算值，流式采样与中止的重试不会重复计数（与官方 token-usage 投影语义一致）；
+- 由 `tool/call` → `tool/result` 事件时间差（按 `callId` 配对）得到的工具耗时，以及每个工具的调用次数、总耗时、最大耗时与错误数；
+- turn 墙钟与 `LLM ≈` 估算（step 墙钟减去工具耗时）。
+
+逐 turn 明细有上限（默认 100 turn），会话总量始终覆盖全程。状态为纯 JSON，可随投影 checkpoint 持久化。
+
+## 费用估算
+
+费用按 **API 牌价**计算并标注为估算值 —— 订阅/配额计费可能不同。内置 DeepSeek 公开模型的默认价目（峰值与低谷时段；低谷为峰值一半）。未配置价格的模型显示 `—`，而不是给出错误数字。
+
+报告语言由 `language` 配置键控制（`en` 或 `zh`，默认 `en`）——宿主半边读不到应用界面语言，因此与卡片小文案不同，报告正文不会自动切换。`/cost json` 的字段值始终为英文，保证脚本解析稳定。
+
+设置 `showCosts: false` 可完全关闭费用列，或在 profile 的 `cordis.patch.yml` 中按路由覆盖价格：
+
+```yaml
+- id: cost-profiler
+  name: dsh-cost-profiler
+  config:
+    showCosts: true
+    offPeak: false          # 用低谷价（峰值一半）估算
+    currency: USD           # 费用显示币种
+    detailTurns: 100        # /cost full 保留的逐 turn 明细条数
+    language: en            # 报告语言：en | zh（卡片小文案自动跟随应用界面语言）
+    prices:                 # 每百万 token 的价格
+      deepseek/deepseek-flash: { input: 0.3, cacheRead: 0.006, cacheWrite: 0, output: 1.2 }
+      # 也支持裸模型名或 "default" 键作为兜底
+      default: { input: 1, output: 2 }
+```
+
+## 跨会话汇总
+
+`/cost week`（还有 `month`、`all`）读取**本地已存储的会话**做汇总 —— 按工作区聚合 + 按会话明细（按估算费用排序）。内置面板严格限于当前会话，这类跨会话归因没有任何官方入口。
+
+数据来源（按优先级）：
+
+1. 本插件在该会话自己的 checkpoint（逐模型路由桶，定价最准）；
+2. 应用的官方 `tokenUsage` checkpoint（只有会话总量、无路由 —— 按该会话最近使用的模型或你的 `default` 价定价）;
+3. 直接重放会话日志（不依赖任何 checkpoint）。
+
+说明：
+
+- **只读且隐私有界**：扫描 `~/.dsh`（尊重 `$DSH_HOME`），只读标题、时间戳与用量/计时数字 —— 不碰消息正文 —— 且不写任何文件。
+- 当前会话最后几条事件可能滞后一个 checkpoint 刷新周期（通常几秒）。
+- 无剖析活动的会话会被跳过；窗口内没有数据时给出指向 `/cost all` 的提示，而不是空表。
+- `cost_report` 模型工具刻意保持会话内范围 —— 跨会话大表会撑爆模型上下文。
+
+## 说明与限制
+
+- `LLM ≈` 由 step 计时推导，非逐请求精确计时 —— 视为近似值即可。
+- 会话内剖析范围为当前会话（子代理会话各自独立）；跨会话汇总见上文。
+- `/cost` 命令只输出文本，不进入模型上下文；`/cost json` 是面板类集成的接入点。
+- 卡片小文案（运行态/JSON 标签/错误提示/代码块按钮）通过应用的 locale 注册表跟随界面语言（中/英）；报告正文由宿主半边生成，为英文。
+
+## 兼容性
+
+- DSH `0.2.0-rc.1` 及之后的 `0.2.0-rc.x`（peer 范围 `^0.2.0-rc.1`）、cordis `^4.0.1`、Node ≥ 20。
+- 宿主半边为纯 ESM，无构建步骤、无原生模块。客户端半边是手写的 classic script（不走打包器），注册两个 UI 槽；聊天界面缺失时自动降级为纯文本。
+
+## 开发
+
+```
+node --test      # 44 个单元测试：fold/report/prices/history 层 + 客户端半边
+```
+
+## 许可证
+
+MIT —— 见 [LICENSE](./LICENSE)。

package/cordis.patch.yml

@@ -0,0 +1,6 @@
+# dsh-cost-profiler bundle patch: mounts the plugin into the profile's
+# composition tree. The profile's package.json must list this package under
+# `dsh.profile.bundles` (the `dsh plugin add` flow does this automatically).
+- insert:
+    - id: cost-profiler
+      name: dsh-cost-profiler

package/icon.svg

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
+  <rect width="64" height="64" rx="14" fill="#1b1f27"/>
+  <rect x="12" y="34" width="8" height="16" rx="2" fill="#4d6bfe"/>
+  <rect x="24" y="26" width="8" height="24" rx="2" fill="#7b9bff"/>
+  <rect x="36" y="18" width="8" height="32" rx="2" fill="#a9c1ff"/>
+  <circle cx="50" cy="18" r="7" fill="none" stroke="#ffd166" stroke-width="3"/>
+  <path d="M50 18 L54 14" stroke="#ffd166" stroke-width="2" stroke-linecap="round"/>
+</svg>

package/lib/client.js

@@ -0,0 +1,321 @@
+/**
+ * Client half of dsh-cost-profiler: renders the /cost report as Markdown.
+ *
+ * The host half delivers the report as plain text (see ./report.js) and the
+ * chat UI would otherwise show it in the generic command/tool card, which is a
+ * monospace <pre>. This module claims both render slots for the cost report and
+ * renders the same text through the chat Markdown renderer instead.
+ *
+ * Hand-written classic script: no imports, no exports, no JSX, no build step.
+ * `id` must equal the package name — the client module loader keys the factory
+ * by it and rejects a bundle that registers under a different id.
+ */
+window.__ModuleLoader__.load({
+  id: "dsh-cost-profiler",
+  factory(require) {
+    const React = require("react");
+    const h = React.createElement;
+
+    // Platform seed modules. Missing primitives degrade this card to monospace
+    // text; a throwing require() would fail the whole client entry instead.
+    let primitives = null;
+    try {
+      primitives = require("@deepseek-ai/dsh-client-ui-primitives");
+    } catch (error) {
+      primitives = null;
+    }
+    // Accepts exotic component types: both primitives used here are memo()
+    // wrapped, and memo() returns an object rather than a function.
+    const pick = (name) => {
+      const value = primitives === null ? null : primitives[name];
+      return value === undefined || value === null ? null : value;
+    };
+    const MarkdownText = pick("MarkdownText");
+    const DisclosureRow = pick("DisclosureRow");
+    const RowIcon = pick("IconGaugeOutlineRegular") ?? pick("IconApiOutlineRegular");
+
+    const COMMAND_SLOT = "conversation.chat.commandview";
+    const TOOL_SLOT = "tool.call.toolview";
+    // Slot keys are dispatched verbatim from the command/tool name — no
+    // normalization on either side, so these strings must match lib/index.js.
+    const COMMAND_KEYS = ["cost", "cost-report"];
+    const TOOL_KEY = "cost_report";
+
+    // Reports longer than this start collapsed, so `/cost full` does not push
+    // the conversation away while `/cost` stays readable at a glance.
+    const OPEN_LINE_LIMIT = 30;
+
+    // Card chrome follows the app's UI language through the app's locale
+    // registry — the same mechanism the built-in rows use. The report body
+    // itself stays host-generated English; only these labels translate.
+    const NS = "cost-profiler";
+    const DICTS = Object.freeze({
+      en: Object.freeze({
+        running: "Running…",
+        jsonReport: "JSON report",
+        line: "line",
+        lines: "lines",
+        commandFailed: "The command failed.",
+        reportFailed: "The cost report failed.",
+        copy: "Copy",
+        copied: "Copied",
+        code: "Code",
+        wrap: "Wrap",
+        unwrap: "Unwrap",
+        footnotes: "Footnotes",
+      }),
+      zh: Object.freeze({
+        running: "运行中…",
+        jsonReport: "JSON 报告",
+        line: "行",
+        lines: "行",
+        commandFailed: "命令执行失败。",
+        reportFailed: "费用报告执行失败。",
+        copy: "复制",
+        copied: "已复制",
+        code: "代码",
+        wrap: "自动换行",
+        unwrap: "不换行",
+        footnotes: "脚注",
+      }),
+    });
+
+    /** The slot only receives `t` when the locale face was live at assembly;
+     * fall back to the English dictionary rather than throwing into the
+     * framework's error boundary. */
+    function translate(t) {
+      return typeof t === "function" ? t : (key) => DICTS.en[key] ?? key;
+    }
+
+    function makeLabels(tr) {
+      return Object.freeze({
+        code: Object.freeze({
+          copyLabel: tr("copy"),
+          copiedLabel: tr("copied"),
+          toolbarLabels: Object.freeze({ codeLabel: tr("code"), wrapLabel: tr("wrap"), unwrapLabel: tr("unwrap") }),
+        }),
+        footnotes: tr("footnotes"),
+      });
+    }
+
+    const PLAIN_STYLE = {
+      whiteSpace: "pre-wrap",
+      wordBreak: "break-word",
+      fontFamily: "monospace",
+      fontSize: 12,
+      margin: 0,
+      maxHeight: 320,
+      overflow: "auto",
+    };
+    const ERROR_STYLE = { ...PLAIN_STYLE, color: "#d64545" };
+    const BODY_STYLE = { padding: "2px 0 4px 20px" };
+    const LABEL_STYLE = { marginLeft: 6, opacity: 0.75, whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis" };
+    const ERROR_LABEL_STYLE = { ...LABEL_STYLE, color: "#d64545" };
+
+    /**
+     * Inner boundary for the Markdown subtree. A slot entry that throws during
+     * render is abdicated and then leaves a bare error cell in its place — the
+     * framework does not fall back to the generic card — so Markdown failures
+     * must degrade to the raw report here instead of escaping.
+     */
+    class SafeMarkdown extends React.Component {
+      constructor(props) {
+        super(props);
+        this.state = { failed: false };
+      }
+      static getDerivedStateFromError() {
+        return { failed: true };
+      }
+      componentDidCatch(error) {
+        console.error("dsh-cost-profiler: markdown render failed, showing raw report", error);
+      }
+      render() {
+        if (this.state.failed) return h("pre", { style: PLAIN_STYLE }, this.props.text);
+        return h(MarkdownText, { text: this.props.text, streaming: false, labels: this.props.labels });
+      }
+    }
+
+    function lineCount(text) {
+      return text === "" ? 0 : text.split("\n").length;
+    }
+
+    function firstLine(text) {
+      const end = text.indexOf("\n");
+      return end === -1 ? text : text.slice(0, end);
+    }
+
+    function fenced(text, lang) {
+      return "```" + lang + "\n" + text.replace(/\s+$/, "") + "\n```";
+    }
+
+    /** `/cost json` and `cost_report {detail:"json"}` both end at the same body. */
+    function isJsonText(text) {
+      const trimmed = text.replace(/^\s+/, "");
+      return trimmed.charAt(0) === "{" || trimmed.charAt(0) === "[";
+    }
+
+    function isJsonArg(value) {
+      return typeof value === "string" && value.trim().toLowerCase() === "json";
+    }
+
+    function jsonArgMode(argsRaw) {
+      if (typeof argsRaw !== "string" || argsRaw === "") return false;
+      try {
+        const parsed = JSON.parse(argsRaw);
+        return parsed !== null && typeof parsed === "object" && parsed.detail === "json";
+      } catch (error) {
+        return false;
+      }
+    }
+
+    /** Flatten a tool result's content parts the way the built-in rows do. */
+    function contentText(content) {
+      if (!Array.isArray(content)) return "";
+      const parts = [];
+      for (const part of content) {
+        if (part === null || typeof part !== "object") continue;
+        if (part.type === "text" && typeof part.text === "string") parts.push(part.text);
+        else {
+          try {
+            parts.push(JSON.stringify(part, null, 2));
+          } catch (error) {
+            // Skip parts that cannot be serialized rather than losing the report.
+          }
+        }
+      }
+      return parts.join("\n");
+    }
+
+    function errorText(block, tr) {
+      const error = block.error;
+      if (error !== null && typeof error === "object") {
+        const name = typeof error.name === "string" ? error.name : "";
+        const message = typeof error.message === "string" ? error.message : "";
+        const code = typeof error.code === "string" ? error.code : "";
+        const text = [name, message].filter(Boolean).join(": ") || code;
+        if (text !== "") return text;
+      }
+      return tr("reportFailed");
+    }
+
+    function bodyNode(text, json, error, labels) {
+      if (!MarkdownText) return h("pre", { style: error ? ERROR_STYLE : PLAIN_STYLE }, text);
+      return h(SafeMarkdown, { text: json ? fenced(text, "json") : text, labels });
+    }
+
+    function plainCard(title, text, error) {
+      return h(
+        "div",
+        { style: { fontSize: 12 } },
+        h("div", { style: { opacity: 0.7 } }, title),
+        h("pre", { style: error ? ERROR_STYLE : PLAIN_STYLE }, text),
+      );
+    }
+
+    /**
+     * One report card: a disclosure row whose label is the report's own first
+     * line and whose body is the report as Markdown.
+     *
+     * `open` is derived rather than stored, so a row that starts as "running"
+     * and settles into a short report still opens by default; the first click
+     * takes over from the derivation.
+     */
+    function ReportView(props) {
+      const title = props.title;
+      const text = typeof props.text === "string" ? props.text : "";
+      const running = props.running === true;
+      const error = props.error === true;
+      const json = props.json === true;
+      // An error with no text falls back to a translated generic line.
+      const body = error && text === "" ? translate(props.t)("commandFailed") : text;
+      const lines = lineCount(body);
+      const expandable = !running && body !== "";
+      const defaultOpen = json || lines <= OPEN_LINE_LIMIT;
+      const [userOpen, setUserOpen] = React.useState(null);
+      const open = expandable && (userOpen === null ? defaultOpen : userOpen);
+
+      // The locale seat's identity is not guaranteed stable, so derive the
+      // translator and the MarkdownText labels from it per render pass.
+      const tr = React.useMemo(() => translate(props.t), [props.t]);
+      const labels = React.useMemo(() => makeLabels(tr), [tr]);
+      const label = running
+        ? tr("running")
+        : json
+          ? `${tr("jsonReport")} · ${lines} ${tr(lines === 1 ? "line" : "lines")}`
+          : firstLine(body);
+
+      if (!DisclosureRow) return plainCard(title, running ? "" : body, error);
+
+      return h(
+        DisclosureRow,
+        {
+          icon: RowIcon ? h(RowIcon, { size: 14 }) : undefined,
+          title,
+          open,
+          running,
+          expandable,
+          expandOnRowClick: true,
+          keepContentWhenOpen: true,
+          onToggle: () => setUserOpen(!open),
+          collapsedContent: label ? h("span", { style: error ? ERROR_LABEL_STYLE : LABEL_STYLE }, label) : undefined,
+        },
+        expandable ? h("div", { style: BODY_STYLE }, bodyNode(body, json, error, labels)) : null,
+      );
+    }
+
+    /** `/cost [summary|full|json]` command row. */
+    function CostCommandCard(props) {
+      const node = props.node;
+      if (node === null || typeof node !== "object") return null;
+      const title = typeof node.name === "string" && node.name !== "" ? node.name : "cost";
+      const outcome = node.outcome;
+      if (outcome === null || outcome === undefined) return h(ReportView, { title, running: true, t: props.t });
+      const text = typeof outcome.text === "string" ? outcome.text : "";
+      if (outcome.kind === "error") return h(ReportView, { title, error: true, t: props.t, text });
+      return h(ReportView, { title, text, t: props.t, json: isJsonArg(node.args) || isJsonText(text) });
+    }
+
+    /** `cost_report` tool row. */
+    function CostReportRow(props) {
+      const title = typeof props.toolName === "string" && props.toolName !== "" ? props.toolName : "cost_report";
+      const block = props.block;
+      const settled = props.phase === "result" && block !== null && typeof block === "object" && block.kind === "tool-result";
+      if (!settled) return h(ReportView, { title, running: true, t: props.t });
+      const text = contentText(block.content);
+      const error = block.isError === true;
+      if (error && text === "") return h(ReportView, { title, error: true, t: props.t, text: errorText(block, translate(props.t)) });
+      const argsRaw = block.call !== null && typeof block.call === "object" ? block.call.argsRaw : "";
+      return h(ReportView, { title, text, t: props.t, error, json: jsonArgMode(argsRaw) || isJsonText(text) });
+    }
+
+    function registerEntry(ctx, slotName, key, component) {
+      try {
+        return ctx.slots.register({ name: slotName, key, locale: NS }, component);
+      } catch (error) {
+        // An occupied key means the built-in card keeps rendering this command
+        // or tool; that is a working fallback, not a failure worth crashing on.
+        console.warn(`dsh-cost-profiler: slot entry "${key}" was not registered in ${slotName}`, error);
+        return null;
+      }
+    }
+
+    function registerAll(ctx, slotName, entries) {
+      const disposers = [];
+      for (const [key, component] of entries) {
+        const dispose = registerEntry(ctx, slotName, key, component);
+        if (dispose) disposers.push(dispose);
+      }
+      return disposers;
+    }
+
+    function apply(ctx) {
+      ctx.effect(() => ctx.locale.register(NS, DICTS), "cost-profiler: dictionaries");
+      ctx.slots.inject(COMMAND_SLOT, () =>
+        registerAll(ctx, COMMAND_SLOT, COMMAND_KEYS.map((key) => [key, CostCommandCard])),
+      );
+      ctx.slots.inject(TOOL_SLOT, () => registerAll(ctx, TOOL_SLOT, [[TOOL_KEY, CostReportRow]]));
+    }
+
+    return { inject: ["slots", "locale"], apply };
+  },
+});