dsh-session-grep 0.0.0-stage → 1.0.1

package/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+
+## 1.0.1 — 2026-11-09
+
+- Fixed: cross-session results were unreachable. Search stopped as soon as the row limit was reached, so the longest conversation (scanned first) filled the whole list. Hits are now collected per session and merged round-robin by newest match.
+- Fixed: one row per event with an "N matches" count, instead of repeating the same event for every occurrence.
+- Fixed: selecting a row could be swallowed by the input blur; selection now runs on `mousedown`.
+- Fixed: side threads (`Side: …`) open through their durable `subagent.address` when a bare session id does not navigate.
+- Changed: rows show the session suffix; a hit already on screen only scrolls and highlights instead of navigating.
+- Added: `navFailed` string in both locales.
+
+## 1.0.0 — 2026-11-09
+
+First release.
+
+- Host service `dsh-session-grep` with `GET /dsh-session-grep/api/search`, `/sessions` and `/health`.
+- Decodes the multi-frame `session.v4.jsonl.zstd` log format and caches parses by `mtime + size`.
+- Literal, case-insensitive substring matching (Chinese fragments included), 3 hits per message, 40 rows max.
+- Client search pill in `conversation.header.leading`: debounced query, keyboard navigation, match highlight, open-and-flash on select.
+- Optional tool call / tool result / reasoning coverage.
+- English and Chinese interface strings.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 chenshanhan0711
+
+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,79 @@
-# Temporary Holding Version
+# dsh-session-grep
 
-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.
+Substring search across every message in a DeepSeek Harness workspace — the kind of search where `搜索输出` finds the sentence `…只能搜索输出`, and `插件` finds words inside longer words.
+
+## Why this exists
+
+The built-in session search (sidebar `Ctrl+K`) runs on an SQLite FTS5 index created with the `unicode61` tokenizer. That tokenizer matches **whole tokens and phrases**, not arbitrary substrings:
+
+- Contiguous Chinese has no spaces, so an entire clause is one token. `搜索输出` is a fragment of the token `只能搜索输出` and therefore matches nothing.
+- The upstream documentation says it plainly: *"`unicode61` tokenizer matches tokens and phrases rather than arbitrary substrings"* (`@deepseek-ai/dsh-session-query-sqlite`, README line 63).
+
+This plugin keeps its own literal index instead: it reads the session logs, decompresses them and does a case-insensitive `indexOf`. Any fragment matches, Chinese included.
+
+## What it looks like
+
+- A **搜索 / Search** pill in the conversation header (the same slot the session title sits next to).
+- Click it, type, and get one row per matching message: role, title, session suffix, snippet with the match highlighted.
+- Results rotate across sessions, so one very long conversation cannot crowd out the others.
+- `↑` `↓` to move, `Enter` to open, `Esc` to close.
+- Picking a row opens that conversation and flashes the matched text for ~2.6 s. A hit in the conversation already on screen only scrolls and highlights — no pointless navigation.
+- Toggle **工具输出 / Tool output** to also search tool calls, tool results and reasoning.
+- Results are scoped to the current workspace, 40 rows max.
+
+## Install
+
+From npm:
+
+```
+dsh plugin --profile <profile> add dsh-session-grep
+```
+
+From a clone:
+
+```
+git clone https://github.com/chenshanhan0711/dsh-session-grep
+dsh plugin --profile <profile> add ./dsh-session-grep
+```
+
+Or in the app: **Plugins → Add plugin** and point it at that folder. The bundle adds one Host service and one client slot; the pill appears after a restart.
+
+Remove it the same way you removed any plugin; it never touches the DSH install directory.
+
+## How it works
+
+**Host** (`index.js`)
+
+- Finds logs at `$DSH_HOME/sessions/<cwd-key>/<session-id>/session.v4.jsonl.zstd`.
+- Each file is a sequence of concatenated zstd frames with no length prefix: split on the zstd magic, inflate each frame, and merge a slice into the next candidate when inflation fails (so a stray magic inside compressed bytes costs a retry, not an event).
+- Parses the JSONL, extracts text per event type (`user/message`, `assistant/message`, optionally `tool/call` / `tool/result` / reasoning), and caches parses by `mtime + size` (max 64 sessions).
+- One hit per event with an "N matches" count; each session collects up to `max(10, limit/2)` first, then the sessions are merged round-robin by their newest match — a long conversation cannot swallow the list.
+- Serves three read-only routes under `/dsh-session-grep/api`: `search`, `sessions`, `health`.
+- Scanning a 900-event / 3 MB session takes ~20 ms; a query over it is single-digit milliseconds.
+
+**Client** (`client.js`)
+
+- Registers into the `conversation.header.leading` slot.
+- 200 ms debounce, one in-flight request at a time (the previous one is aborted).
+- Results panel is `position: fixed` from the input rect, so it is never clipped by the header.
+- Clicking a result calls `uiWorkspace.openSession(...)`; for a side thread it first retains the session and opens through the durable `subagent.address` from its snapshot. If the view has not switched after 1 s it retries once, and only then reports failure.
+- Then it walks the rendered text nodes to wrap the match in a `<mark>`, scrolling it into view; if the message is not rendered yet it retries for ~9 s and then says so.
+- Selection runs on `mousedown`, not `click`, so a blur cannot unmount the row before the handler runs.
+
+## Limits
+
+- Matches **text**, not rendered Markdown: a match split across `**bold**` boundaries may be found by the scanner but not highlighted on screen.
+- Tool output, reasoning and JSON payloads are off by default; switch on **Tool output** to include them.
+- Only sessions of the current workspace directory are scanned.
+- Live sessions are re-parsed when the file changes; there is no incremental tailing yet.
+- Very large histories are scanned fully per query (no persistent on-disk index), which is why results cap at 40.
+- Changing the **Host** half needs an app restart; changing only `client.js` needs a page refresh (the Host hot-loads client bundles).
+- Archived sessions still match; the app refuses to open them.
+
+## Privacy
+
+Zero network requests. The Host reads local session files and answers its own loopback route; the client only calls that route. No telemetry, no remote endpoints, no hardcoded credentials.
+
+## License
+
+MIT

package/README.zh.md

@@ -0,0 +1,80 @@
+# dsh-session-grep · 对话正文搜索
+
+在工作区所有对话正文里做**真正的子串搜索**：输入 `搜索输出` 能命中「…只能搜索输出」这句话，输入 `插件` 能命中「插件市场」这类词中间的字。
+
+## 为什么需要它
+
+DSH 内置的会话搜索（侧栏 `Ctrl+K`）走的是 SQLite FTS5 索引，分词器是 `unicode61`。它匹配的是**整 token 和短语**，不是任意子串：
+
+- 中文没有空格，一整句是一个 token。`搜索输出` 只是 token `只能搜索输出` 的中间片段，所以一条都搜不到；
+- 上游文档写得很清楚：*"`unicode61` tokenizer matches tokens and phrases rather than arbitrary substrings"*（`@deepseek-ai/dsh-session-query-sqlite` README 第 63 行）。
+
+本插件不用那套索引：它直接读会话日志、解压、做大小写不敏感的 `indexOf`，所以任何片段都能命中，中文也不例外。
+
+## 使用
+
+- 对话页头部（会话标题左侧）有一个 **搜索** 胶囊按钮。
+- 点开输入关键词，每条命中的消息一行：角色、会话标题、会话尾号、命中的片段（高亮）。
+- 结果按会话轮转排列：同一个超长对话不会占满整个列表，每个对话都能看到。
+- `↑` `↓` 选择，`Enter` 打开，`Esc` 关闭。
+- 选中一行会切到那个会话，并把命中的文字**闪一下高亮**约 2.6 秒。
+- 命中就在当前对话里时不会做多余的跳转，只滚动并高亮。
+- 打开「工具输出」开关，可把工具调用、工具结果和推理内容也纳入搜索。
+- 结果只覆盖当前工作区，最多 40 条。
+
+## 安装
+
+从 npm：
+
+```
+dsh plugin --profile <profile> add dsh-session-grep
+```
+
+从仓库：
+
+```
+git clone https://github.com/chenshanhan0711/dsh-session-grep
+dsh plugin --profile <profile> add ./dsh-session-grep
+```
+
+或在应用内 **插件 → 添加插件** 选择该目录。bundle 只加一个 Host 服务和一个客户端插槽，重启后搜索胶囊出现。
+
+卸载：与其他插件相同，不会改动 DSH 安装目录。
+
+## 实现
+
+**Host（`index.js`）**
+
+- 日志位置：`$DSH_HOME/sessions/<cwd-key>/<session-id>/session.v4.jsonl.zstd`。
+- 文件是多个 zstd frame 顺序拼接、无长度前缀：按 zstd magic 切分，逐段解压；解压失败说明切点落在压缩数据内部，把该段并入下一段重试（不会丢事件）。
+- 解析 JSONL，按事件类型取文本（`user/message`、`assistant/message`，可选 `tool/call`、`tool/result`、reasoning），并按 `mtime + size` 缓存解析结果（上限 64 个会话）。
+- 每个事件只贡献一条命中，附「共 N 处」计数；每个会话先各自收集（上限 `max(10, limit/2)`），再按「会话内最新命中时间」轮转合并 —— 长对话无法挤掉其他对话。
+- 在 `/dsh-session-grep/api` 下暴露三个只读接口：`search`、`sessions`、`health`。
+- 扫描一个 900 事件 / 3 MB 的会话约 20 ms，单次查询个位数毫秒。
+
+**Client（`client.js`）**
+
+- 注册到 `conversation.header.leading` 插槽。
+- 200 ms 防抖，同一时刻只有一个请求在飞（新的会中止旧的）。
+- 结果面板用输入框的矩形做 `position: fixed` 定位，不会被头部裁掉。
+- 点击结果调用 `uiWorkspace.openSession(...)`；如果是子会话（`Side:` 线程），先用 `ctx.sessions.retain()` 拿到快照里的 `subagent.address` 再按地址打开。打开后 1 秒仍未切换就重试一次，仍失败才提示。
+- 命中文字在已渲染文本节点里被包进 `<mark>` 并滚动到可见；消息还没渲染就重试约 9 秒，最后给出提示。
+- 选中用 `mousedown` 而不是 `click`，避免输入框失焦先把面板关掉。
+
+## 限制
+
+- 搜的是**文本**，不是渲染后的 Markdown：命中跨在 `**粗体**` 两侧时，扫描能命中，但屏幕上可能高亮不到。
+- 工具输出、推理和 JSON 需要手动打开开关。
+- 只扫描当前工作区目录下的会话。
+- 会话文件变化会重新解析；暂未做增量 tail。
+- 每次查询全量扫描、不落盘索引，所以结果上限 40 条。
+- 改了 **Host 半边** 的代码需要重启应用；只改 `client.js` 刷新页面即可（Host 会热载客户端 bundle）。
+- 会话列表里被归档的对话仍能被搜到，点开时会被拒绝打开。
+
+## 隐私
+
+**零网络请求**。Host 只读本地会话文件并响应自己的 loopback 路由，客户端只调这个路由；无遥测、无外部端点、无硬编码密钥。
+
+## 许可证
+
+MIT

package/client.js

@@ -0,0 +1,561 @@
+/**
+ * dsh-session-grep — Client half.
+ *
+ * A search pill in the conversation header. Types into the Host's literal
+ * substring index and shows one row per matching message; picking a row opens
+ * that conversation and flashes the matched text in place.
+ */
+window.__ModuleLoader__.load({
+  id: 'dsh-session-grep',
+  factory(require) {
+    const React = require('react');
+    const h = React.createElement;
+
+    const NS = 'dsh-session-grep';
+    const API = '/dsh-session-grep/api';
+    const STYLE_ID = 'dsh-session-grep-style';
+    const LIMIT = 40;
+
+    const DICT = {
+      en: {
+        'meta.title': 'Conversation grep',
+        'meta.description': 'Substring search across every message in this workspace — fragments inside a sentence match too.',
+        search: 'Search',
+        opened: 'Switched to',
+        placeholder: 'Search all messages, e.g. 搜索输出',
+        hint: 'Matches any fragment, including inside a Chinese sentence.',
+        empty: 'No message contains that fragment.',
+        failed: 'Search failed',
+        tools: 'Tool output',
+        hits: 'hits',
+        ms: 'ms',
+        truncated: 'stopped at limit',
+        noHistory: 'No conversation history found in this workspace.',
+        notLocated: 'Opened, but the text is not rendered yet — scroll up in that conversation.',
+        navFailed: 'Could not open that conversation',
+        loading: 'Searching…',
+        user: 'you',
+        assistant: 'assistant',
+        tool: 'tool',
+      },
+      zh: {
+        'meta.title': '对话正文搜索',
+        'meta.description': '在工作区全部对话正文里做真正的子串搜索，中文句子中间的片段也能命中。',
+        search: '搜索',
+        opened: '已切换到',
+        placeholder: '搜索所有对话正文，例如：搜索输出',
+        hint: '任意片段都能命中，包括中文句子中间的字。',
+        empty: '没有消息包含这个片段。',
+        failed: '搜索失败',
+        tools: '工具输出',
+        hits: '处命中',
+        ms: '毫秒',
+        truncated: '已达条数上限',
+        noHistory: '这个工作区还没有对话记录。',
+        notLocated: '已打开对话，但这句还没渲染出来——往上翻一下。',
+        navFailed: '没能打开那个对话',
+        loading: '搜索中…',
+        user: '我',
+        assistant: '助手',
+        tool: '工具',
+      },
+    };
+
+    const runtime = {
+      locale: null,
+      notify: () => {},
+      openSession: () => null,
+      currentSession: () => null,
+      t: (key) => DICT.en[key] ?? key,
+    };
+
+    // Never read the locale service while React renders: capture it at apply
+    // time and keep it fresh through the locale subscription instead.
+    let activeLocale = 'en';
+
+    function translate(key) {
+      try {
+        const active = String(activeLocale).toLowerCase();
+        const dict = active.startsWith('zh') ? DICT.zh : DICT.en;
+        return dict[key] ?? DICT.en[key] ?? key;
+      } catch {
+        return DICT.en[key] ?? key;
+      }
+    }
+
+    const ICON = h(
+      'svg',
+      { width: 13, height: 13, viewBox: '0 0 16 16', fill: 'none', 'aria-hidden': 'true' },
+      h('circle', { cx: 7, cy: 7, r: 4.6, stroke: 'currentColor', strokeWidth: 1.4 }),
+      h('path', { d: 'M10.6 10.6 L14 14', stroke: 'currentColor', strokeWidth: 1.4, strokeLinecap: 'round' }),
+    );
+
+    function ensureStyle() {
+      if (typeof document === 'undefined' || document.getElementById(STYLE_ID)) return;
+      const style = document.createElement('style');
+      style.id = STYLE_ID;
+      style.textContent = `
+.dsg-root{position:relative;display:inline-flex;align-items:center;min-width:0}
+.dsg-trigger{display:inline-flex;align-items:center;gap:6px;height:28px;padding:0 11px;border-radius:999px;border:1px solid var(--dsw-alias-border-l1);background:var(--dsw-alias-bg-layer-1);color:var(--dsw-alias-label-secondary);font-size:12px;line-height:1;cursor:pointer;transition:color .12s,border-color .12s}
+.dsg-trigger:hover{color:var(--dsw-alias-label-primary);border-color:var(--dsw-alias-border-l2)}
+.dsg-field{display:flex;align-items:center;gap:6px;height:30px;width:340px;max-width:46vw;padding:0 9px;border:1px solid var(--dsw-alias-brand-primary);border-radius:9px;background:var(--dsw-alias-bg-base);color:var(--dsw-alias-label-secondary)}
+.dsg-field input{flex:1;min-width:0;border:0;outline:0;background:transparent;color:var(--dsw-alias-label-primary);font-size:13px;font-family:inherit}
+.dsg-kbd{font-size:10px;color:var(--dsw-alias-label-secondary);border:1px solid var(--dsw-alias-border-l1);border-radius:4px;padding:1px 4px}
+.dsg-panel{position:fixed;z-index:80;display:flex;flex-direction:column;max-height:min(62vh,520px);border:1px solid var(--dsw-alias-border-l1);border-radius:11px;background:var(--dsw-alias-bg-overlay);box-shadow:0 14px 36px rgba(0,0,0,.26);overflow:hidden}
+.dsg-bar{display:flex;align-items:center;justify-content:space-between;gap:10px;padding:6px 10px;border-bottom:1px solid var(--dsw-alias-border-l1);font-size:11px;color:var(--dsw-alias-label-secondary)}
+.dsg-chip{cursor:pointer;user-select:none;padding:2px 8px;border-radius:999px;border:1px solid var(--dsw-alias-border-l1);white-space:nowrap}
+.dsg-chip[data-on="1"]{color:var(--dsw-alias-brand-primary);border-color:var(--dsw-alias-brand-primary)}
+.dsg-list{overflow:auto;padding:4px}
+.dsg-item{display:flex;flex-direction:column;gap:3px;padding:7px 9px;border-radius:7px;cursor:pointer;border-left:2px solid transparent}
+.dsg-item[data-active="1"],.dsg-item:hover{background:var(--dsw-alias-bg-layer-1);border-left-color:var(--dsw-alias-brand-primary)}
+.dsg-meta{display:flex;align-items:center;gap:7px;font-size:11px;color:var(--dsw-alias-label-secondary);min-width:0}
+.dsg-title{color:var(--dsw-alias-label-primary);font-size:12px;font-weight:500;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.dsg-role{flex:none;padding:0 5px;border-radius:4px;border:1px solid var(--dsw-alias-border-l1);font-size:10px;line-height:15px}
+.dsg-sid{flex:none;margin-left:auto;font-family:ui-monospace,Menlo,Consolas,monospace;font-size:10px;color:var(--dsw-alias-label-secondary);opacity:.75;letter-spacing:.02em}
+.dsg-snip{font-size:12px;line-height:1.5;color:var(--dsw-alias-label-primary);word-break:break-word}
+.dsg-snip mark{background:transparent;color:var(--dsw-alias-brand-primary);font-weight:600}
+.dsg-empty,.dsg-err{padding:18px 12px;font-size:12px;line-height:1.6;color:var(--dsw-alias-label-secondary);text-align:center}
+.dsg-err{color:var(--dsw-alias-state-error-primary)}
+.dsg-foot{display:flex;justify-content:space-between;gap:10px;padding:5px 10px;border-top:1px solid var(--dsw-alias-border-l1);font-size:10px;color:var(--dsw-alias-label-secondary)}
+.dsg-toast{position:fixed;left:50%;bottom:26px;transform:translateX(-50%);z-index:90;max-width:70vw;padding:7px 14px;border-radius:999px;border:1px solid var(--dsw-alias-border-l1);background:var(--dsw-alias-bg-layer-2);color:var(--dsw-alias-label-primary);font-size:12px;box-shadow:0 8px 24px rgba(0,0,0,.22)}
+mark.dsg-flash{background:var(--dsw-alias-brand-primary);color:#fff;border-radius:3px;padding:0 1px}
+@media (max-width:720px){.dsg-trigger-label{display:none}}
+`;
+      document.head.appendChild(style);
+    }
+
+    function removeStyle() {
+      document.getElementById(STYLE_ID)?.remove();
+    }
+
+    // ---------------------------------------------------------------- locate
+
+    function clearFlash() {
+      for (const mark of Array.from(document.querySelectorAll('mark.dsg-flash'))) {
+        try {
+          mark.replaceWith(document.createTextNode(mark.textContent || ''));
+        } catch {
+          mark.remove();
+        }
+      }
+    }
+
+    /** Wrap the first visible occurrence of `target` in a flashing mark. */
+    function flashText(target) {
+      const needle = String(target || '').trim();
+      if (needle.length < 2 || typeof document === 'undefined') return false;
+      const lowered = needle.toLowerCase();
+      const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT, {
+        acceptNode(node) {
+          const parent = node.parentElement;
+          if (!parent) return NodeFilter.FILTER_REJECT;
+          if (parent.closest('.dsg-root') || parent.closest('mark.dsg-flash')) return NodeFilter.FILTER_REJECT;
+          if (/^(SCRIPT|STYLE|TEXTAREA|INPUT|NOSCRIPT)$/.test(parent.tagName)) return NodeFilter.FILTER_REJECT;
+          return (node.nodeValue || '').length >= needle.length ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+        },
+      });
+      let node = walker.nextNode();
+      while (node) {
+        const text = node.nodeValue;
+        const at = text.toLowerCase().indexOf(lowered);
+        if (at !== -1) {
+          try {
+            const range = document.createRange();
+            range.setStart(node, at);
+            range.setEnd(node, at + needle.length);
+            const mark = document.createElement('mark');
+            mark.className = 'dsg-flash';
+            range.surroundContents(mark);
+            mark.scrollIntoView({ block: 'center', behavior: 'smooth' });
+            setTimeout(clearFlash, 2600);
+            return true;
+          } catch {
+            // cross-element selection: keep looking
+          }
+        }
+        node = walker.nextNode();
+      }
+      return false;
+    }
+
+    function locateAfterOpen(target) {
+      let tries = 0;
+      const timer = setInterval(() => {
+        tries += 1;
+        if (flashText(target)) {
+          clearInterval(timer);
+        } else if (tries >= 30) {
+          clearInterval(timer);
+          runtime.notify?.();
+        }
+      }, 300);
+    }
+
+    // ------------------------------------------------------------- component
+
+    function GrepWidget() {
+      const [open, setOpen] = React.useState(false);
+      const [text, setText] = React.useState('');
+      const [tools, setTools] = React.useState(false);
+      const [result, setResult] = React.useState({ status: 'idle', hits: [], tookMs: 0, truncated: false, scanned: 0 });
+      const [cursor, setCursor] = React.useState(0);
+      const [pos, setPos] = React.useState(null);
+      const [toast, setToast] = React.useState('');
+      const inputRef = React.useRef(null);
+      const rootRef = React.useRef(null);
+      const abortRef = React.useRef(null);
+      const t = runtime.t;
+
+      // 200 ms debounce, one in-flight request at a time.
+      const [query, setQuery] = React.useState('');
+      React.useEffect(() => {
+        const timer = setTimeout(() => setQuery(text.trim()), 200);
+        return () => clearTimeout(timer);
+      }, [text]);
+
+      React.useEffect(() => {
+        if (!open) return;
+        if (!query) {
+          setResult({ status: 'idle', hits: [], tookMs: 0, truncated: false, scanned: 0 });
+          return;
+        }
+        abortRef.current?.abort();
+        const ac = new AbortController();
+        abortRef.current = ac;
+        setResult((prev) => ({ ...prev, status: 'loading' }));
+        const url = `${API}/search?q=${encodeURIComponent(query)}&limit=${LIMIT}&context=70&tools=${tools ? 1 : 0}`;
+        fetch(url, { signal: ac.signal, headers: { accept: 'application/json' } })
+          .then((response) => (response.ok ? response.json() : Promise.reject(new Error(`HTTP ${response.status}`))))
+          .then((data) => {
+            setResult({
+              status: 'done',
+              hits: Array.isArray(data.hits) ? data.hits : [],
+              tookMs: data.tookMs ?? 0,
+              truncated: !!data.truncated,
+              scanned: data.scannedEvents ?? 0,
+            });
+            setCursor(0);
+          })
+          .catch((error) => {
+            if (error?.name === 'AbortError') return;
+            setResult({ status: 'error', hits: [], tookMs: 0, truncated: false, scanned: 0, message: String(error?.message ?? error) });
+          });
+        return () => ac.abort();
+      }, [query, tools, open]);
+
+      const place = React.useCallback(() => {
+        const el = inputRef.current;
+        if (!el) return;
+        const rect = el.getBoundingClientRect();
+        const width = Math.max(rect.width, 440);
+        const left = Math.min(Math.max(8, rect.left), Math.max(8, window.innerWidth - width - 8));
+        setPos({ left, top: rect.bottom + 6, width });
+      }, []);
+
+      React.useEffect(() => {
+        if (!open) return;
+        place();
+        const onScroll = () => place();
+        window.addEventListener('resize', onScroll);
+        window.addEventListener('scroll', onScroll, true);
+        const focus = setTimeout(() => inputRef.current?.focus(), 0);
+        return () => {
+          clearTimeout(focus);
+          window.removeEventListener('resize', onScroll);
+          window.removeEventListener('scroll', onScroll, true);
+        };
+      }, [open, place]);
+
+      React.useEffect(() => {
+        if (!open) return;
+        const onDown = (event) => {
+          if (!rootRef.current?.contains(event.target)) setOpen(false);
+        };
+        document.addEventListener('mousedown', onDown);
+        return () => document.removeEventListener('mousedown', onDown);
+      }, [open]);
+
+      React.useEffect(() => {
+        runtime.notify = () => setToast(translate('notLocated'));
+        return () => {
+          runtime.notify = () => {};
+        };
+      }, []);
+
+      React.useEffect(() => {
+        if (!toast) return;
+        const timer = setTimeout(() => setToast(''), 4200);
+        return () => clearTimeout(timer);
+      }, [toast]);
+
+      React.useEffect(() => {
+        clearFlash();
+        return () => {
+          abortRef.current?.abort();
+          clearFlash();
+        };
+      }, []);
+
+      const choose = React.useCallback((hit) => {
+        if (!hit) return;
+        setOpen(false);
+        clearFlash();
+        const wanted = String(hit.sessionId || '');
+        const target = (hit.match && hit.match.length >= 2 ? hit.match : hit.snippet || '').trim();
+        const current = runtime.currentSession();
+        if (current && current === wanted) {
+          if (target) locateAfterOpen(target);
+          return;
+        }
+        const failure = runtime.openSession(wanted);
+        if (failure) {
+          setToast(`${t('failed')}: ${failure}`);
+          return;
+        }
+        setTimeout(() => {
+          if (runtime.currentSession() === wanted) {
+            if (target) locateAfterOpen(target);
+            return;
+          }
+          // A subagent (side) Session is only addressable through its durable
+          // direct-parent address, not by bare id: resolve it and try once more.
+          runtime.openByAddress(wanted).then((opened) => {
+            if (!opened) {
+              setToast(`${t('navFailed')} ${wanted.slice(-6)}`);
+              return;
+            }
+            setTimeout(() => {
+              if (target) locateAfterOpen(target);
+            }, 600);
+          });
+        }, 1000);
+      }, []);
+
+      const onKeyDown = (event) => {
+        if (event.key === 'Escape') {
+          event.preventDefault();
+          setOpen(false);
+          inputRef.current?.blur();
+        } else if (event.key === 'ArrowDown') {
+          event.preventDefault();
+          setCursor((c) => Math.min(c + 1, Math.max(0, result.hits.length - 1)));
+        } else if (event.key === 'ArrowUp') {
+          event.preventDefault();
+          setCursor((c) => Math.max(c - 1, 0));
+        } else if (event.key === 'Enter' && !event.nativeEvent?.isComposing) {
+          event.preventDefault();
+          choose(result.hits[cursor]);
+        }
+      };
+
+      const roleLabel = (role) => (role === 'user' ? t('user') : role === 'assistant' ? t('assistant') : role === 'tool' ? t('tool') : role);
+
+      const rows = result.hits.map((hit, index) => {
+        const start = typeof hit.matchStart === 'number' && hit.matchStart >= 0 ? hit.matchStart : -1;
+        const end = start >= 0 ? start + (hit.matchLength || 0) : -1;
+        const snippet = hit.snippet || '';
+        return h(
+          'div',
+          {
+            key: `${hit.sessionId}:${hit.seq}:${index}`,
+            className: 'dsg-item',
+            'data-active': index === cursor ? '1' : '0',
+            onMouseEnter: () => setCursor(index),
+            onMouseDown: (event) => {
+              event.preventDefault();
+              choose(hit);
+            },
+          },
+          h(
+            'div',
+            { className: 'dsg-meta' },
+            h('span', { className: 'dsg-role' }, roleLabel(hit.role)),
+            h('span', { className: 'dsg-title' }, hit.title || hit.sessionId.slice(0, 10)),
+            h('span', { className: 'dsg-sid' }, String(hit.sessionId).slice(-6)),
+            hit.count > 1 ? h('span', null, `×${hit.count}`) : null,
+          ),
+          h(
+            'div',
+            { className: 'dsg-snip' },
+            start >= 0 && end <= snippet.length
+              ? [
+                  snippet.slice(0, start),
+                  h('mark', { key: 'm' }, snippet.slice(start, end)),
+                  snippet.slice(end),
+                ]
+              : snippet,
+          ),
+        );
+      });
+
+      const body = (() => {
+        if (result.status === 'loading' && result.hits.length === 0) return h('div', { className: 'dsg-empty' }, t('loading'));
+        if (result.status === 'error') return h('div', { className: 'dsg-err' }, `${t('failed')}: ${result.message || ''}`);
+        if (result.status === 'done' && result.hits.length === 0) return h('div', { className: 'dsg-empty' }, t('empty'));
+        if (result.status === 'idle') return h('div', { className: 'dsg-empty' }, t('hint'));
+        return h('div', { className: 'dsg-list' }, rows);
+      })();
+
+      return h(
+        'div',
+        { className: 'dsg-root', ref: rootRef },
+        open
+          ? h(
+              'div',
+              { className: 'dsg-field' },
+              ICON,
+              h('input', {
+                ref: inputRef,
+                value: text,
+                placeholder: t('placeholder'),
+                onChange: (event) => setText(event.target.value),
+                onKeyDown,
+                spellCheck: false,
+                'aria-label': t('placeholder'),
+              }),
+              h('span', { className: 'dsg-kbd' }, 'Esc'),
+            )
+          : h(
+              'button',
+              {
+                type: 'button',
+                className: 'dsg-trigger',
+                title: t('placeholder'),
+                onClick: () => setOpen(true),
+              },
+              ICON,
+              h('span', { className: 'dsg-trigger-label' }, t('search')),
+            ),
+        open && pos
+          ? h(
+              'div',
+              {
+                className: 'dsg-panel',
+                style: { left: `${pos.left}px`, top: `${pos.top}px`, width: `${pos.width}px` },
+              },
+              h(
+                'div',
+                { className: 'dsg-bar' },
+                h('span', null, result.status === 'done' ? `${result.hits.length} ${t('hits')}` : t('hint')),
+                h(
+                  'span',
+                  {
+                    className: 'dsg-chip',
+                    'data-on': tools ? '1' : '0',
+                    role: 'switch',
+                    'aria-checked': tools ? 'true' : 'false',
+                    onClick: () => setTools((value) => !value),
+                  },
+                  t('tools'),
+                ),
+              ),
+              body,
+              result.status === 'done'
+                ? h(
+                    'div',
+                    { className: 'dsg-foot' },
+                    h('span', null, `${result.tookMs} ${t('ms')} · ${result.scanned} events`),
+                    h('span', null, result.truncated ? t('truncated') : `${LIMIT} max`),
+                  )
+                : null,
+            )
+          : null,
+        toast ? h('div', { className: 'dsg-toast' }, toast) : null,
+      );
+    }
+
+    return {
+      inject: ['slots', 'locale', 'uiWorkspace', 'sessions'],
+      apply(ctx) {
+        ensureStyle();
+        runtime.locale = ctx.locale ?? null;
+        runtime.t = translate;
+        runtime.notify = () => {};
+        runtime.currentSession = () => {
+          try {
+            const node =
+              document.querySelector('[data-conversation-session]') ||
+              document.querySelector('[data-session-id]');
+            return (
+              node?.getAttribute('data-conversation-session') ||
+              node?.getAttribute('data-session-id') ||
+              null
+            );
+          } catch {
+            return null;
+          }
+        };
+        runtime.openSession = (sessionId) => {
+          try {
+            ctx.uiWorkspace.openSession(sessionId);
+            return null;
+          } catch (error) {
+            const message = error?.message || String(error);
+            console.warn('[dsh-session-grep] openSession failed', message);
+            return message;
+          }
+        };
+
+        // Side Sessions are addressed by their durable direct-parent address.
+        runtime.openByAddress = async (sessionId) => {
+          try {
+            const sessions =
+              ctx.sessions || (typeof ctx.get === 'function' ? ctx.get('sessions') : null);
+            if (!sessions || typeof sessions.retain !== 'function') return false;
+            const reference = sessions.retain(sessionId, { source: 'controllerOperation' });
+            try {
+              await reference.ready;
+              const snapshot = reference.binding?.session?.getSnapshot?.();
+              const address = snapshot?.subagent?.address;
+              if (!address) return false;
+              ctx.uiWorkspace.openSession(address);
+              return true;
+            } finally {
+              if (typeof reference.release === 'function') reference.release();
+            }
+          } catch (error) {
+            console.warn('[dsh-session-grep] openByAddress failed', error?.message || error);
+            return false;
+          }
+        };
+
+        try {
+          activeLocale = String(ctx.locale?.getLocale?.()?.active ?? 'en');
+          if (typeof ctx.locale?.subscribe === 'function') {
+            ctx.locale.subscribe(() => {
+              try {
+                activeLocale = String(ctx.locale?.getLocale?.()?.active ?? activeLocale);
+              } catch {
+                /* keep previous */
+              }
+            });
+          }
+        } catch (error) {
+          console.warn('[dsh-session-grep] locale capture failed', error);
+        }
+
+        for (const [locale, dict] of [
+          ['en', DICT.en],
+          ['zh', DICT.zh],
+          ['zh-CN', DICT.zh],
+        ]) {
+          try {
+            ctx.locale.register(NS, locale, dict);
+          } catch (error) {
+            console.warn('[dsh-session-grep] locale register failed', locale, error);
+          }
+        }
+        ctx.slots.inject('conversation.header.leading', () =>
+          ctx.slots.register(
+            {
+              name: 'conversation.header.leading',
+              id: 'dsh-session-grep',
+              order: 10,
+            },
+            GrepWidget,
+          ),
+        );
+      },
+    };
+  },
+});

package/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: dsh-session-grep
+      name: dsh-session-grep

package/icon.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24" fill="none">
+  <path d="M3 6.8A3 3 0 0 1 6 3.8h12a3 3 0 0 1 3 3v6.4a3 3 0 0 1-3 3H9.6L5.2 20v-3.8A3 3 0 0 1 3 13.2Z" fill="currentColor" opacity="0.14"/>
+  <path d="M3 6.8A3 3 0 0 1 6 3.8h12a3 3 0 0 1 3 3v6.4a3 3 0 0 1-3 3H9.6L5.2 20v-3.8A3 3 0 0 1 3 13.2Z" stroke="currentColor" stroke-width="1.6" stroke-linejoin="round"/>
+  <circle cx="10" cy="9.2" r="2.9" stroke="currentColor" stroke-width="1.6"/>
+  <path d="M12.2 11.4 14.6 13.8" stroke="currentColor" stroke-width="1.6" stroke-linecap="round"/>
+</svg>

package/index.js

@@ -0,0 +1,413 @@
+/**
+ * dsh-session-grep — Host half.
+ *
+ * Serves a tiny read-only JSON API over the session logs on disk:
+ *
+ *   GET /dsh-session-grep/api/search?q=&limit=&context=&tools=&session=
+ *   GET /dsh-session-grep/api/sessions
+ *   GET /dsh-session-grep/api/health
+ *
+ * Why the logs and not the session-query service: that service builds an
+ * FTS5 index with the `unicode61` tokenizer, which matches whole tokens and
+ * phrases. Contiguous Chinese is one token, so a fragment inside a sentence
+ * ("搜索输出" inside "...只能搜索输出") never matches. This plugin decompresses
+ * the same `session.v4.jsonl.zstd` files (a sequence of concatenated zstd
+ * frames) and does a literal, case-insensitive substring scan — the same
+ * thing `String.prototype.indexOf` does.
+ *
+ * Zero network access: it reads the local session directory and answers its
+ * own loopback route.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import zlib from 'node:zlib';
+
+export const inject = ['webServer'];
+
+const VERSION = '1.0.1';
+const API = '/dsh-session-grep/api';
+const SESSION_FILE = 'session.v4.jsonl.zstd';
+const MAGIC = Buffer.from([0x28, 0xb5, 0x2f, 0xfd]); // zstd frame magic
+const MAX_HITS_PER_DOC = 3;
+const MAX_LIMIT = 200;
+
+/** file path -> parsed entry */
+const cache = new Map();
+
+function sessionsRoot() {
+  const home = process.env.DSH_HOME || path.join(os.homedir(), '.dsh');
+  return path.join(home, 'sessions');
+}
+
+// ---------------------------------------------------------------- decoding
+
+/**
+ * One log file is several zstd frames concatenated with no length prefix.
+ * Split on the magic and inflate each frame; a magic sequence that shows up
+ * inside compressed bytes simply fails to inflate and is merged into the next
+ * candidate, so a false positive costs one retry instead of a lost event.
+ */
+function decodeFrames(buf) {
+  const cuts = [];
+  let at = 0;
+  while ((at = buf.indexOf(MAGIC, at)) !== -1) {
+    cuts.push(at);
+    at += 4;
+  }
+  if (cuts.length === 0) return buf;
+  const parts = [];
+  let start = cuts[0];
+  for (let k = 1; k <= cuts.length; k++) {
+    const end = k < cuts.length ? cuts[k] : buf.length;
+    try {
+      parts.push(zlib.zstdDecompressSync(buf.subarray(start, end)));
+      start = end;
+    } catch {
+      // Not a frame boundary after all: keep `start` and try a longer slice.
+    }
+  }
+  return Buffer.concat(parts);
+}
+
+function parseEvents(file) {
+  const text = decodeFrames(fs.readFileSync(file)).toString('utf8');
+  const events = [];
+  for (const line of text.split('\n')) {
+    if (!line) continue;
+    try {
+      events.push(JSON.parse(line));
+    } catch {
+      // A torn last line is expected while a session is still being written.
+    }
+  }
+  return events;
+}
+
+// ------------------------------------------------------------ text of event
+
+function textOf(ev, withTools) {
+  const d = ev.data;
+  if (!d) return '';
+  if (ev.type === 'user/message') {
+    return (d.content ?? [])
+      .filter((c) => c && c.type === 'text')
+      .map((c) => c.text)
+      .join('\n');
+  }
+  if (ev.type === 'assistant/message') {
+    const parts = d.message?.content ?? d.content ?? [];
+    const out = [];
+    for (const c of parts) {
+      if (!c) continue;
+      if (c.type === 'text') out.push(c.text);
+      else if (withTools && c.type === 'reasoning') out.push(c.text);
+      else if (withTools && (c.type === 'tool-call' || c.type === 'tool_call')) {
+        out.push(JSON.stringify(c.arguments ?? c.input ?? ''));
+      }
+    }
+    return out.join('\n');
+  }
+  if (withTools && ev.type === 'developer/message') {
+    return JSON.stringify(d.content ?? '');
+  }
+  if (withTools && ev.type === 'tool/call') return JSON.stringify(d);
+  if (withTools && ev.type === 'tool/result') return JSON.stringify(d).slice(0, 20000);
+  return '';
+}
+
+function roleOf(type) {
+  if (type === 'user/message') return 'user';
+  if (type === 'assistant/message') return 'assistant';
+  if (type === 'tool/call' || type === 'tool/result') return 'tool';
+  return 'other';
+}
+
+function timeOf(ev) {
+  const value = ev?.time;
+  if (typeof value === 'number') return value;
+  if (typeof value === 'string') {
+    const parsed = Date.parse(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return 0;
+}
+
+function titleOf(events) {
+  for (const ev of events) {
+    if (ev.type === 'session/title') {
+      const t = ev.data?.title ?? ev.data?.text;
+      if (typeof t === 'string' && t.trim()) return t.trim();
+    }
+  }
+  for (const ev of events) {
+    if (ev.type === 'user/message') {
+      const first = textOf(ev, false).replace(/\s+/g, ' ').trim();
+      if (first) return first.length > 48 ? `${first.slice(0, 48)}…` : first;
+    }
+  }
+  return null;
+}
+
+// ------------------------------------------------------------------- cache
+
+function loadSession(file) {
+  let stat;
+  try {
+    stat = fs.statSync(file);
+  } catch {
+    return null;
+  }
+  const cached = cache.get(file);
+  if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) return cached;
+
+  const events = parseEvents(file);
+  if (events.length === 0) return null;
+  const header = events[0] ?? {};
+  let updatedAt = 0;
+  for (const ev of events) {
+    const at = timeOf(ev);
+    if (at > updatedAt) updatedAt = at;
+  }
+  const entry = {
+    file,
+    id: path.basename(path.dirname(file)),
+    cwd: typeof header.cwd === 'string' ? header.cwd : null,
+    title: titleOf(events),
+    events,
+    updatedAt,
+    mtimeMs: stat.mtimeMs,
+    size: stat.size,
+  };
+  cache.set(file, entry);
+  if (cache.size > 64) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== file) cache.delete(oldest);
+  }
+  return entry;
+}
+
+function listSessions() {
+  const root = sessionsRoot();
+  const out = [];
+  let cwdDirs = [];
+  try {
+    cwdDirs = fs.readdirSync(root);
+  } catch {
+    return { root, sessions: out };
+  }
+  for (const cwdDir of cwdDirs) {
+    const dir = path.join(root, cwdDir);
+    let entries = [];
+    try {
+      if (!fs.statSync(dir).isDirectory()) continue;
+      entries = fs.readdirSync(dir);
+    } catch {
+      continue;
+    }
+    for (const name of entries) {
+      const file = path.join(dir, name, SESSION_FILE);
+      if (!fs.existsSync(file)) continue;
+      const entry = loadSession(file);
+      if (entry) out.push(entry);
+    }
+  }
+  out.sort((a, b) => b.updatedAt - a.updatedAt);
+  return { root, sessions: out };
+}
+
+// ------------------------------------------------------------------ search
+
+function snippetOf(text, at, length, context) {
+  const from = Math.max(0, at - context);
+  const to = Math.min(text.length, at + length + context);
+  const collapsed = text.slice(from, to).replace(/\s+/g, ' ');
+  const match = text.slice(at, at + length);
+  return { snippet: collapsed, match, before: at > from, after: to < text.length };
+}
+
+function search(query, options) {
+  const needle = query.toLowerCase();
+  const limit = Math.min(Math.max(1, options.limit | 0 || 30), MAX_LIMIT);
+  const context = Math.min(Math.max(10, options.context | 0 || 60), 400);
+  const { tools, session } = options;
+  const started = Date.now();
+  const { root, sessions } = listSessions();
+  const perSessionCap = Math.max(10, Math.ceil(limit / 2));
+  const groups = [];
+  let scannedSessions = 0;
+  let scannedEvents = 0;
+  let overflow = false;
+
+  for (const s of sessions) {
+    if (session && !s.id.startsWith(session)) continue;
+    scannedSessions++;
+    const local = [];
+    const seen = new Set();
+    for (const ev of s.events) {
+      const text = textOf(ev, tools);
+      if (!text) continue;
+      scannedEvents++;
+      const low = text.toLowerCase();
+      const at = low.indexOf(needle);
+      if (at === -1) continue;
+      // One hit per event, with the number of in-event occurrences: repeating
+      // the same event for every occurrence crowds out other sessions.
+      const key = typeof ev.seq === 'number' ? `s${ev.seq}` : `e${scannedEvents}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      let count = 1;
+      for (let probe = low.indexOf(needle, at + needle.length); probe !== -1; probe = low.indexOf(needle, probe + needle.length)) {
+        count += 1;
+      }
+      const built = snippetOf(text, at, needle.length, context);
+      local.push({
+        sessionId: s.id,
+        title: s.title,
+        cwd: s.cwd,
+        seq: typeof ev.seq === 'number' ? ev.seq : null,
+        type: ev.type,
+        role: roleOf(ev.type),
+        time: timeOf(ev) || null,
+        snippet: built.snippet,
+        match: built.match,
+        matchStart: built.snippet.toLowerCase().indexOf(needle),
+        matchLength: needle.length,
+        truncatedBefore: built.before,
+        truncatedAfter: built.after,
+        count,
+      });
+      if (local.length >= perSessionCap) {
+        overflow = true;
+        break;
+      }
+    }
+    if (local.length > 0) {
+      const newest = local.reduce((max, hit) => Math.max(max, Number.isFinite(hit.time) ? hit.time : 0), 0);
+      groups.push({ hits: local, newest });
+    }
+  }
+
+  // Round-robin across sessions so one long conversation cannot swallow the
+  // whole result list; sessions with the newest matches contribute first.
+  groups.sort((a, b) => b.newest - a.newest);
+  const hits = [];
+  for (let round = 0; hits.length < limit; round += 1) {
+    let added = 0;
+    for (const group of groups) {
+      const hit = group.hits[round];
+      if (!hit) continue;
+      hits.push(hit);
+      added += 1;
+      if (hits.length >= limit) break;
+    }
+    if (added === 0) break;
+  }
+
+  return {
+    query,
+    hits,
+    limit,
+    total: hits.length,
+    truncated: overflow || hits.length >= limit,
+    scannedSessions,
+    scannedEvents,
+    tookMs: Date.now() - started,
+    sessionsRoot: root,
+  };
+}
+
+// ------------------------------------------------------------------- routes
+
+function sendJson(res, status, body) {
+  const payload = JSON.stringify(body);
+  res.writeHead(status, {
+    'content-type': 'application/json; charset=utf-8',
+    'cache-control': 'no-store',
+    'content-length': Buffer.byteLength(payload),
+  });
+  res.end(payload);
+}
+
+function methodNotAllowed(res) {
+  res.writeHead(405, { allow: 'GET' });
+  res.end();
+}
+
+export function apply(ctx) {
+  const disposeSearch = ctx.webServer.register({
+    kind: 'exact',
+    path: `${API}/search`,
+    handler: (req, res) => {
+      if (req.method !== 'GET') return methodNotAllowed(res);
+      const url = new URL(req.url ?? '/', 'http://localhost');
+      const q = (url.searchParams.get('q') ?? '').trim();
+      if (!q) return sendJson(res, 200, { query: '', hits: [], total: 0, tookMs: 0 });
+      try {
+        sendJson(
+          res,
+          200,
+          search(q, {
+            limit: Number(url.searchParams.get('limit')) || 30,
+            context: Number(url.searchParams.get('context')) || 60,
+            tools: url.searchParams.get('tools') === '1',
+            session: url.searchParams.get('session') || null,
+          }),
+        );
+      } catch (error) {
+        sendJson(res, 500, { error: String(error?.message ?? error) });
+      }
+    },
+  });
+
+  const disposeSessions = ctx.webServer.register({
+    kind: 'exact',
+    path: `${API}/sessions`,
+    handler: (req, res) => {
+      if (req.method !== 'GET') return methodNotAllowed(res);
+      try {
+        const { root, sessions } = listSessions();
+        sendJson(res, 200, {
+          sessionsRoot: root,
+          sessions: sessions.map((s) => ({
+            sessionId: s.id,
+            title: s.title,
+            cwd: s.cwd,
+            events: s.events.length,
+            updatedAt: s.updatedAt,
+            bytes: s.size,
+          })),
+        });
+      } catch (error) {
+        sendJson(res, 500, { error: String(error?.message ?? error) });
+      }
+    },
+  });
+
+  const disposeHealth = ctx.webServer.register({
+    kind: 'exact',
+    path: `${API}/health`,
+    handler: (req, res) => {
+      if (req.method !== 'GET') return methodNotAllowed(res);
+      let sessions = 0;
+      try {
+        sessions = listSessions().sessions.length;
+      } catch {
+        // reported as zero below
+      }
+      sendJson(res, 200, {
+        ok: true,
+        version: VERSION,
+        sessionsRoot: sessionsRoot(),
+        sessions,
+        cached: cache.size,
+      });
+    },
+  });
+
+  return () => {
+    disposeSearch();
+    disposeSessions();
+    disposeHealth();
+  };
+}

package/locale/en.json

@@ -0,0 +1,21 @@
+{
+  "meta": {
+    "title": "Conversation grep",
+    "description": "Substring search across every message in this workspace, Chinese fragments included."
+  },
+  "search": "Search",
+  "placeholder": "Search all messages, e.g. 搜索输出",
+  "hint": "Matches any fragment, including inside a Chinese sentence.",
+  "empty": "No message contains that fragment.",
+  "failed": "Search failed",
+  "tools": "Tool output",
+  "hits": "hits",
+  "ms": "ms",
+  "truncated": "stopped at limit",
+  "noHistory": "No conversation history found in this workspace.",
+  "notLocated": "Opened, but the text is not rendered yet — scroll up in that conversation.",
+  "loading": "Searching…",
+  "user": "you",
+  "assistant": "assistant",
+  "tool": "tool"
+}

package/locale/zh.json

@@ -0,0 +1,21 @@
+{
+  "meta": {
+    "title": "对话正文搜索",
+    "description": "在工作区全部对话正文里做真正的子串搜索，中文句子中间的片段也能命中。"
+  },
+  "search": "搜索",
+  "placeholder": "搜索所有对话正文，例如：搜索输出",
+  "hint": "任意片段都能命中，包括中文句子中间的字。",
+  "empty": "没有消息包含这个片段。",
+  "failed": "搜索失败",
+  "tools": "工具输出",
+  "hits": "处命中",
+  "ms": "毫秒",
+  "truncated": "已达条数上限",
+  "noHistory": "这个工作区还没有对话记录。",
+  "notLocated": "已打开对话，但这句还没渲染出来——往上翻一下。",
+  "loading": "搜索中…",
+  "user": "我",
+  "assistant": "助手",
+  "tool": "工具"
+}

package/package.json

@@ -1,6 +1,64 @@
 {
   "name": "dsh-session-grep",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.1",
+  "description": "Substring search across every conversation in a workspace, Chinese included: the built-in tokenizer only matches whole tokens, this matches any fragment. · 在对话正文里做真正的子串搜索（中文片段也能命中）。",
+  "type": "module",
+  "license": "MIT",
+  "author": "chenshanhan0711",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chenshanhan0711/dsh-session-grep.git"
+  },
+  "homepage": "https://github.com/chenshanhan0711/dsh-session-grep#readme",
+  "bugs": {
+    "url": "https://github.com/chenshanhan0711/dsh-session-grep/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "deepseek",
+    "harness",
+    "dsh",
+    "dsh-plugin",
+    "search",
+    "session",
+    "conversation",
+    "grep"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "icon.svg",
+    "README.md",
+    "README.zh.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-conversation"
+      ]
+    }
+  }
+}