dsh-log-slicer 0.0.0-stage → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# 变更记录
+
+## 0.1.1
+
+三处都是第一次真用（拿 2026-10-31 上午那段去切）时暴露出来的。
+
+- **修**：`--kind work` 的三行头里，「原件」默认值从 `已移走` 改成 `（待填）`。工具并不知道那份原件在哪儿，替人写一个断言是越界。
+- **修**：目录里如果某一卷的名字正好是「卷」，它会撞上表头首格，行被插到表头与分隔行中间，表格就坏了。现在表头与分隔行不参与"这是该卷的行"的判断。
+- **增**：指路句识别。形如「我更新了第一轮」「你可以看看那个文件」「这方面内容我们就结束了」的句子，是他往文件上指，不是他的话。dry-run 会把它们列出来，并提示去原件抄真段落；若那段属三级，就不抄，写一句"按三级不抄在这里"。
+
+## 0.1.0
+
+第一版。取数 → 清洗 → 切片 → 渲染 → 登记，CLI 与插件两条入口共用 `src/pipeline.js`。

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dsh-log-slicer 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.en.md

@@ -0,0 +1,81 @@
+# dsh-log-slicer
+
+Slice one section out of a DeepSeek Harness session log — verbatim turns, catalog row, backups, verification hash. One command. **Dry-run by default.**
+
+## 30-second start
+
+```bash
+dsh-log-slicer --list --limit 20                  # 1. read-only: what is in the log
+dsh-log-slicer --kind chat --title "try" \
+  --from "verbatim fragment" --to "verbatim fragment"        # 2. dry-run, nothing written
+dsh-log-slicer ... --file notes.md --index index.md --apply  # 3. write after backing up
+```
+
+Anchors are **verbatim fragments**, never line numbers. `--apply` backs the target up to `旧版本/` first, then appends the section and the catalog row, then prints a verification line.
+
+## What it is / is not
+
+- It is a **data extraction** tool: it pulls a slice of the session log out verbatim and lays it out in one of two house styles.
+- It is **not** a summarizer, a compressor, or a memory tool. It does not rewrite, rank, or "improve" anything.
+- Because it only extracts, it is not universal: it knows the "section" format it was built for (`**you:**` / `**me:**` labels, three-line header, catalog row, verification line). That format is a house style, not a standard.
+
+## Install
+
+```bash
+dsh plugin add dsh-log-slicer   # as a plugin: adds log_probe / log_slice tools
+npx dsh-log-slicer --help       # or just use the CLI
+```
+
+## Usage
+
+```bash
+# read-only: what is in the log
+dsh-log-slicer --list --limit 40
+
+# dry-run: check the slice before touching files
+dsh-log-slicer --kind chat --title "2026-10-31 ① ..." \
+  --from "start fragment" --to "end fragment" \
+  --file "./notes/vol-8.md" --index "./notes/index.md" --volume vol-8
+
+# write (backs up to 旧版本/ first)
+dsh-log-slicer ... --apply --tag "before adding 10-31 ①"
+```
+
+Anchors are **verbatim fragments**, never line numbers: the log grows every day. When an anchor is missing the CLI lists nearby turns as candidates.
+
+## Output contract
+
+- Body: `## title` then turns, taken verbatim from the log
+- Catalog row: `| volume | title | turns |`
+- Verification line: `| date | file (+N turns) | bytes | sha256-prefix-16 | equal in both places |`
+- Backup: `旧版本/<name>（<before the change>）.bak`
+
+## Environment
+
+- Node ≥ 22.15 (`zlib.zstdDecompressSync`). The Node bundled inside DSH works.
+- Logs at `$DSH_HOME/sessions/<workspace>/<sessionId>/session.v4.jsonl.zstd`; `$DSH_HOME` defaults to `~/.dsh`.
+- No third-party dependencies.
+
+## Limitations
+
+- **Depends on the host's log format.** `src/decode.js` is the only layer that touches it.
+- Images are reported as `sha256` + media type only; copying them out is on you.
+- Only `user/message` and `assistant/message` events are understood.
+
+## FAQ
+
+**"Log not found."** It looks under `~/.dsh/sessions` for the newest file. Set `DSH_HOME` or pass `--log "C:\path\to\session.v4.jsonl.zstd"`.
+
+**"Anchor not found" plus a list of candidates.** Anchors are verbatim fragments, not line numbers or titles. Copy a whole turn from `--list`.
+
+**The section has too many / too few turns.** `--to` is inclusive; slice small and often rather than one big block.
+
+**Windows paths fail.** Quote the path, don't escape backslashes.
+
+**Where are the images?** Only `sha256` + media type are reported. Copying and numbering them belongs to your note-taking convention, not to this tool.
+
+**Can I use it without DSH?** Yes — any `session.v4.jsonl.zstd` fed to `--log`. Pure Node, no deps; if the format changes, it breaks.
+
+## Maintenance
+
+Maintained whenever. If it breaks, fork it or send a PR — do not expect a schedule. MIT.

package/README.md

@@ -1,3 +1,110 @@
-# Temporary Holding Version
+# dsh-log-slicer
 
-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.
+把 DeepSeek Harness 的会话日志，切成"一节"能直接贴进笔记的东西。
+
+一条命令：读日志 → 取原话 → 切一段 → 出正文 → 出目录行 → 备份旧样 → 出校验记录。**默认 dry-run，不写盘**。
+
+## 30 秒上手
+
+不用读完这篇，四步：
+
+```bash
+# 1. 看看日志里有什么（只读，随便跑）
+dsh-log-slicer --list --limit 20
+
+# 2. 从里面挑两句原话当锚点，试切一段（还是只读）
+dsh-log-slicer --kind chat --title "试一下" \
+  --from "把 --list 里看到的一句原话粘这里" \
+  --to "另一句原话粘这里"
+
+# 3. 看着像你要的东西了，指定文件写盘
+dsh-log-slicer ... --file 我的笔记.md --index 目录.md --apply
+
+# 4. 不确定它认没认对，就一直不加 --apply：dry-run 会把要写的东西整段打出来
+```
+
+写盘时它先在 `旧版本/` 备份一份，再追加正文和目录行，最后打印一行校验记录；不满意就把 `.bak` 拷回去。
+
+想装成插件：`dsh plugin add dsh-log-slicer`，装完多出 `log_probe`、`log_slice` 两个工具，功能一样。
+
+
+## 它是什么 / 不是什么
+
+- 是：一个**取数**工具。日志是唯一的来源，它把日志里某一段原话原封不动取出来，按你指定的体裁排版。
+- 不是：摘要工具、压缩工具、记忆工具。它不总结、不改写、不替你判断哪段重要。
+- 因为它只取数，所以它不通用于所有人——它认的是"一节"的写法：`**你：**`／`**我：**` 独占一行、三行头、目录行、校验行。这些格式来自某一套笔记法，不是通用标准。
+
+## 安装
+
+```bash
+# 当插件装（DSH 里出现 log_probe / log_slice 两个工具）
+dsh plugin add dsh-log-slicer
+
+# 只用命令行，不装插件也行
+npx dsh-log-slicer --help
+```
+
+## 用法
+
+```bash
+# 先看看日志里有什么（只读、便宜）
+dsh-log-slicer --list --limit 40
+
+# 切一节，先 dry-run 核对
+dsh-log-slicer --kind chat \
+  --title "2026-10-31 ① 榫卯与第一栋房子" \
+  --from "我们开始今天的工作" --to "看看对你有没有帮助" \
+  --file "../闲话集/闲话集-8.md" --index "../闲话集/目录.md" --volume 闲话集-8
+
+# 核对无误再写盘（会先备份到 旧版本/）
+dsh-log-slicer ... --apply --tag "加 10-31 ① 之前"
+```
+
+`--kind work` 生成另一种体裁：三行头 + 引用块（他的话照抄）+ 我的判断标成判断。
+
+## 锚点
+
+`--from` / `--to` 要的是**原话片段**，不是行号——日志每天都在长。找不到时会列出最近的几句当候选，别猜行号。
+
+## 输出契约
+
+- 正文：`## 标题` + 轮次，逐字取自日志
+- 目录行：`| 卷 | 标题 | 轮 |`
+- 校验记录：`| 日期 | 文件（+N 轮） | 字节 | 哈希前16位 | 本体＝原件，两处一致 |`
+- 备份：`旧版本/<名字>（<动作之前>）.bak`（不带日期）
+
+## 环境
+
+- Node ≥ 22.15（要用 `zlib.zstdDecompressSync`）。DSH 自带的 Node 就够，`DSH_NODE` 或直接用它的绝对路径。
+- 日志位置：`$DSH_HOME/sessions/<workspace>/<sessionId>/session.v4.jsonl.zstd`，默认 `$DSH_HOME` 是 `~/.dsh`。
+- 没有第三方依赖。
+
+## 已知限制
+
+- **依赖宿主的日志格式**。`src/decode.js` 是唯一贴着格式的那一层，宿主改了只改这一处。
+- 图片只给出 `sha256` 与媒体类型，落盘要自己按附件仓路径复制（也可 `--apply` 后手工补「（图见 …）」）。
+- 只认 `user/message` 与 `assistant/message` 两种事件。
+
+## 常见问题
+
+**跑起来说找不到日志。**
+默认去 `~/.dsh/sessions` 找最新的那份。装在别处就设 `DSH_HOME`，或者直接 `--log "C:\path\to\session.v4.jsonl.zstd"`。
+
+**锚点找不到，报错还列了一堆候选。**
+锚点是**原话片段**，不是行号，也不是标题。复制时去掉句首句尾的空格和标点差异，或者先用 `--list` 把那条轮次整句抄下来。
+
+**切出来的节少了/多了几句。**
+`--to` 那一条要不要收进来，看它是不是"最后一句"。宁可切多几次，也不要一次切一大段：这东西本来就是按节用的。
+
+**Windows 下路径报错。**
+给路径加双引号，别用反斜杠转义（`\\` 会变成转义符）。中文路径没问题。
+
+**图呢？**
+它只认出图片的 `sha256` 和类型，落盘要自己复制，然后在正文补一行 `（图见 …）`。不是漏做——"图放哪个文件夹、怎么编号"是笔记法的约定，不该写死进取数工具。
+
+**我不用 DSH，能用吗？**
+能，只要能拿到 `session.v4.jsonl.zstd` 并把它喂给 `--log`。它是纯 Node，没有别的依赖；但日志格式变了它也会跟着坏。
+
+## 维护
+
+不定期维护。坏了、要改、要适配新版本：欢迎 fork 或提 PR，别指望我按时修。MIT。

package/bin/log-slicer.mjs

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+/**
+ * dsh-log-slicer —— 命令行入口。
+ *
+ * 一条龙：读日志 → 取原话 → 切一节 → 出目录行 → 备份旧样 → 出校验记录。
+ * 默认 dry-run，只打印；加 --apply 才写盘。
+ *
+ * 用法：
+ *   dsh-log-slicer --kind chat --file "C:\...\闲话集-8.md" --index "C:\...\目录.md" \
+ *     --volume 闲话集-8 --title "2026-10-31 ① 标题" --from "起点片段" --to "终点片段" [--apply] [--tag "加 10-31 ① 之前"]
+ *
+ * 找不到锚点时会列出最近的几句当候选，不猜行号。
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { buildSection } from '../src/pipeline.js';
+import { indexRow, insertIndexRow, backupFile, appendSection, sha256Hex16, today } from '../src/register.js';
+import { AnchorError } from '../src/slice.js';
+
+const FLAGS = new Set(['apply', 'help', 'list']);
+
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (!a.startsWith('--')) continue;
+    const key = a.slice(2);
+    if (FLAGS.has(key)) {
+      out[key] = true;
+      continue;
+    }
+    out[key] = argv[++i];
+  }
+  return out;
+}
+
+const HELP = `dsh-log-slicer — slice one section out of a DSH session log
+
+  --kind chat|work          体裁（默认 chat）
+  --title "..."             节标题（必填）
+  --from "..."              起点锚点：第一句要收进来的原话片段
+  --to "..."                终点锚点：最后一句；不给就取到日志末尾
+  --file <path>             目标文件（加 --apply 时必填）
+  --index <path>            目录文件，自动插一行
+  --volume <name>           目录行里的卷名，如 闲话集-8
+  --log <path>              会话日志；默认取最新
+  --list                    列最近的对话轮次，只读（配 --limit、--width）
+  --limit <n>               --list 时列几条，默认 40
+  --width <n>               --list 时每条截断多少字，默认 60
+  --tag "..."               备份标签，默认「自动整理之前」
+  --apply                   真写盘
+  --help                    这份说明
+`;
+
+function stamp(ts) {
+  if (!ts) return '';
+  const d = new Date(Number(ts) || ts);
+  if (Number.isNaN(d.getTime())) return '';
+  const p = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    process.stdout.write(HELP);
+    return;
+  }
+  if (!args.list && !args.title) {
+    process.stderr.write('错误：缺少 --title\n\n' + HELP);
+    process.exit(2);
+  }
+
+  if (args.list) {
+    const all = buildSection({ kind: 'chat', title: 'list', logPath: args.log });
+    const limit = Math.max(1, Math.min(1000, Number(args.limit) || 40));
+    const width = Math.max(10, Math.min(500, Number(args.width) || 60));
+    const turns = all.segment.slice(-limit);
+    const startNo = all.totalTurns - turns.length + 1;
+    const lines = turns.map((t, i) => {
+      const who = t.who === 'user' ? '你' : '我';
+      const when = stamp(t.ts);
+      const body = String(t.text || '').replace(/\s+/g, ' ').slice(0, width);
+      return `${startNo + i}. [${who}] ${when}  ${body}`;
+    });
+    process.stdout.write(
+      `# 日志 ${all.log}\n# ${all.frames} 帧（${all.failedFrames} 帧解不开）/ ${all.totalTurns} 轮有效\n\n` +
+        lines.join('\n') + '\n',
+    );
+    return;
+  }
+
+  let built;
+  try {
+    built = buildSection({
+      kind: args.kind === 'work' ? 'work' : 'chat',
+      title: args.title,
+      from: args.from,
+      to: args.to,
+      logPath: args.log,
+    });
+  } catch (e) {
+    if (e instanceof AnchorError) {
+      process.stderr.write(`错误：${e.message}\n`);
+      if (e.candidates.length) {
+        process.stderr.write('最近的几句（可拿其中一段当锚点）：\n' + e.candidates.map((c) => '  ' + c).join('\n') + '\n');
+      }
+      process.exit(3);
+    }
+    throw e;
+  }
+
+  const out = [];
+  out.push(`# 日志 ${built.log}`);
+  out.push(`# ${(built.logSize / 1048576).toFixed(1)} MB / ${built.frames} 帧（${built.failedFrames} 帧解不开）/ ${built.totalTurns} 轮有效`);
+  out.push(`# 切成 ${built.segment.length} 轮，其中你 ${built.counts.you} 轮、我 ${built.counts.me} 轮`);
+  if (built.imageCount) {
+    out.push(`# 图片 ${built.imageCount} 张：`);
+    for (const img of built.images) out.push(`#   ${img.mediaType || '?'}  sha256:${img.sha256}`);
+  }
+  if (built.pointerLines.length) {
+    out.push(`# 注意：有 ${built.pointerLines.length} 轮像"指路句"（往文件上指，不是原话）——`);
+    for (const p of built.pointerLines) {
+      out.push(`#   第 ${p.index + 1} 轮「${p.phrase}」：${p.text.replace(/\s+/g, ' ')}…`);
+    }
+    out.push('#   去那几份原件里抄真段落；若属三级，就不抄，写一句"按三级不抄在这里"。');
+  }
+  out.push('', '===== 正文（将追加） =====', '', built.markdown);
+
+  const row = indexRow(args.volume || (args.file ? path.basename(args.file, '.md') : '卷'), args.title, built.counts.you);
+  out.push('===== 目录行 =====', '', row);
+
+  if (args.apply !== true) {
+    out.push('', '（dry-run，没有写盘。加 --apply 才动手。）');
+    process.stdout.write(out.join('\n') + '\n');
+    return;
+  }
+  if (!args.file) {
+    process.stderr.write('错误：--apply 需要 --file\n');
+    process.exit(2);
+  }
+
+  const target = path.resolve(args.file);
+  const tag = args.tag || '自动整理之前';
+  const backup = fs.existsSync(target) ? backupFile(target, tag) : null;
+  const { after } = appendSection(target, built.markdown);
+  let indexBackup = null;
+  if (args.index && fs.existsSync(args.index)) {
+    const indexPath = path.resolve(args.index);
+    indexBackup = backupFile(indexPath, tag);
+    const updated = insertIndexRow(fs.readFileSync(indexPath, 'utf8'), row, args.volume || path.basename(target, '.md'));
+    fs.writeFileSync(indexPath, updated, 'utf8');
+  }
+
+  out.push('');
+  out.push(`已写入：${target}`);
+  if (backup) out.push(`备份：${backup}`);
+  if (indexBackup) out.push(`备份：${indexBackup}`);
+  out.push(`字节：${after}`);
+  out.push(`校验记录（贴进备份说明）：| ${today()} | ${path.basename(target)}（+${built.counts.you} 轮） | ${after} | \`${sha256Hex16(target)}\` | 本体＝原件，两处一致 |`);
+  process.stdout.write(out.join('\n') + '\n');
+}
+
+main();

package/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: dsh-log-slicer
+      name: dsh-log-slicer

package/dsh.plugin.json

@@ -0,0 +1,11 @@
+{
+  "name": "dsh-log-slicer",
+  "description": "Slice one section out of a DSH session log: verbatim turns, catalog row, backup and verification hash.",
+  "version": "0.1.0",
+  "entry": {
+    "name": "dsh-log-slicer",
+    "inject": [
+      "tools"
+    ]
+  }
+}

package/package.json

@@ -1,6 +1,53 @@
 {
   "name": "dsh-log-slicer",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "Slice one section out of a DeepSeek Harness session log: verbatim turns, images, catalog row, backups and a verification hash — one command, dry-run by default.",
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "session-log",
+    "zstd",
+    "transcript",
+    "markdown"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./pipeline": "./src/pipeline.js",
+    "./decode": "./src/decode.js",
+    "./clean": "./src/clean.js",
+    "./slice": "./src/slice.js",
+    "./render": "./src/render.js",
+    "./register": "./src/register.js"
+  },
+  "bin": {
+    "dsh-log-slicer": "./bin/log-slicer.mjs"
+  },
+  "files": [
+    "src",
+    "bin",
+    "cordis.patch.yml",
+    "dsh.plugin.json",
+    "README.md",
+    "README.en.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22.15.0"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh-tools": "*"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-tools": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "test": "node --test"
+  }
 }

package/src/clean.js

@@ -0,0 +1,77 @@
+/**
+ * clean.js —— 事件流 → 轮次。
+ *
+ * 只留人和模型真正说的话：宿主注入的环境文本、图片占位行都扔掉。
+ * 图片留下 sha256 与媒体类型，供上层落成文件。
+ */
+
+const ENV_PREFIXES = [
+  'Current runtime context.',
+  'Time sampled while preparing',
+  'Browser time zone for this request',
+  'Elapsed since the preceding model-visible message',
+  '<system-reminder>',
+  '[Compressed conversation section]',
+];
+
+const IMAGE_PLACEHOLDER = /^Image "[^"]+" \(sha256:[0-9a-f]{4,}/i;
+
+export function isEnvironmentText(text) {
+  if (typeof text !== 'string') return true;
+  const t = text.trim();
+  if (!t) return true;
+  if (IMAGE_PLACEHOLDER.test(t)) return true;
+  return ENV_PREFIXES.some((p) => t.startsWith(p));
+}
+
+function textOf(items) {
+  if (!Array.isArray(items)) return '';
+  return items
+    .filter((x) => x && x.type === 'text' && typeof x.text === 'string')
+    .map((x) => x.text)
+    .join('\n');
+}
+
+function imagesOf(items) {
+  if (!Array.isArray(items)) return [];
+  const out = [];
+  for (const x of items) {
+    if (!x || x.type !== 'image') continue;
+    const a = x.attachment || {};
+    const id = String(a.attachmentId || a.id || '').replace(/^sha256:sha256:/, 'sha256:');
+    out.push({ id, sha256: id.replace(/^sha256:/, ''), mediaType: a.mediaType || '' });
+  }
+  return out;
+}
+
+/**
+ * @param {string} text 解压后的 JSONL 文本
+ * @returns {Array<{who: 'user'|'me', ts: number|null, text: string, images: Array}>}
+ */
+export function turnsFromText(text) {
+  const turns = [];
+  for (const line of String(text).split('\n')) {
+    if (!line.trim()) continue;
+    let ev;
+    try {
+      ev = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!ev || typeof ev !== 'object') continue;
+    const ts = ev.time ?? ev.timestamp ?? null;
+    if (ev.type === 'user/message') {
+      const items = (ev.data && ev.data.content) || [];
+      const body = textOf(items);
+      const images = imagesOf(items);
+      if (isEnvironmentText(body) && images.length === 0) continue;
+      turns.push({ who: 'user', ts, text: body.trim(), images });
+    } else if (ev.type === 'assistant/message') {
+      const items = (ev.data && ev.data.message && ev.data.message.content) || [];
+      const body = textOf(items);
+      if (isEnvironmentText(body)) continue;
+      turns.push({ who: 'me', ts, text: body.trim(), images: [] });
+    }
+  }
+  return turns;
+}

package/src/decode.js

@@ -0,0 +1,104 @@
+/**
+ * decode.js —— 只做一件事：把会话日志的多帧 zstd 解成文本。
+ *
+ * 这是整个包里最容易随宿主版本失效的一层，所以单独一个文件：
+ * 宿主一改日志格式，只改这里。
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import zlib from 'node:zlib';
+
+const MAGIC = [0x28, 0xb5, 0x2f, 0xfd];
+
+export function dshHome() {
+  return process.env.DSH_HOME || path.join(os.homedir(), '.dsh');
+}
+
+function assertZstd() {
+  if (typeof zlib.zstdDecompressSync !== 'function') {
+    throw new Error(
+      'this Node build has no zstd support (needs node >= 22.15). ' +
+        'Run it with the Node that ships inside DSH, or upgrade Node.',
+    );
+  }
+}
+
+/**
+ * 逐帧解压。帧尾可能带垃圾（非本帧字节），所以解不开时逐字节缩短再试。
+ * @returns {{text: string, frames: number, failed: number}}
+ */
+export function decodeFrames(buf, { maxTrim = 32 } = {}) {
+  assertZstd();
+  const offs = [];
+  for (let i = 0; i + 4 <= buf.length; i++) {
+    if (buf[i] === MAGIC[0] && buf[i + 1] === MAGIC[1] && buf[i + 2] === MAGIC[2] && buf[i + 3] === MAGIC[3]) {
+      offs.push(i);
+    }
+  }
+  const parts = [];
+  let failed = 0;
+  for (let k = 0; k < offs.length; k++) {
+    const start = offs[k];
+    const end = k + 1 < offs.length ? offs[k + 1] : buf.length;
+    let ok = false;
+    for (let trim = 0; trim <= maxTrim && !ok; trim++) {
+      const stop = end - trim;
+      if (stop <= start) break;
+      try {
+        parts.push(zlib.zstdDecompressSync(buf.subarray(start, stop)).toString('utf8'));
+        ok = true;
+      } catch {
+        /* 帧尾有垃圾，缩短重试 */
+      }
+    }
+    if (!ok) failed++;
+  }
+  return { text: parts.join(''), frames: offs.length, failed };
+}
+
+export function decodeFile(filePath, options) {
+  return decodeFrames(fs.readFileSync(filePath), options);
+}
+
+/**
+ * 在 $DSH_HOME/sessions 下找 session.v4.jsonl.zstd，按修改时间倒序。
+ * sessions/<workspace>/<sessionId>/session.v4.jsonl.zstd
+ */
+export function findSessionLogs(root = path.join(dshHome(), 'sessions')) {
+  const out = [];
+  let entries;
+  try {
+    entries = fs.readdirSync(root, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const ws of entries) {
+    if (!ws.isDirectory()) continue;
+    const wsDir = path.join(root, ws.name);
+    let subs;
+    try {
+      subs = fs.readdirSync(wsDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const s of subs) {
+      const file = path.join(wsDir, s.name, 'session.v4.jsonl.zstd');
+      try {
+        const st = fs.statSync(file);
+        out.push({ path: file, workspace: ws.name, session: s.name, mtime: st.mtimeMs, size: st.size });
+      } catch {
+        /* 不是会话目录 */
+      }
+    }
+  }
+  out.sort((a, b) => b.mtime - a.mtime);
+  return out;
+}
+
+export function latestSessionLog(root) {
+  const logs = findSessionLogs(root);
+  if (!logs.length) throw new Error('no session.v4.jsonl.zstd found under ' + (root || path.join(dshHome(), 'sessions')));
+  return logs[0];
+}

package/src/index.js

@@ -0,0 +1,178 @@
+/**
+ * index.js —— DSH 插件入口。
+ *
+ * 两件事：
+ *   log_probe  看日志里有什么（轮次、时间、可用的锚点），只读、便宜
+ *   log_slice  切一节出来；默认 dry-run，写盘要 apply === true
+ *
+ * 契约（对着 @deepseek-ai/dsh-tools 的用法）：
+ *   - export const inject = ['tools']
+ *   - apply(ctx) 里 ctx.tools.register(defineTool({...spec, execute}))
+ *   - apply 的异常一律吞掉：最坏是插件不工作，不能让应用起不来
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { buildSection } from './pipeline.js';
+import { indexRow, insertIndexRow, backupFile, appendSection, sha256Hex16, today } from './register.js';
+
+export const name = 'dsh-log-slicer';
+export const inject = ['tools'];
+
+async function loadDefineTool() {
+  try {
+    const mod = await import('@deepseek-ai/dsh-tools');
+    if (mod?.defineTool) return mod.defineTool;
+  } catch {
+    /* 落到环境变量 */
+  }
+  const override = process.env.DSH_TOOLS_PATH;
+  if (override) {
+    const { pathToFileURL } = await import('node:url');
+    const mod = await import(pathToFileURL(override).href);
+    if (mod?.defineTool) return mod.defineTool;
+  }
+  throw new Error('cannot resolve @deepseek-ai/dsh-tools (set DSH_TOOLS_PATH for local dev)');
+}
+
+export const probeSpec = {
+  name: 'log_probe',
+  description: [
+    'List recent conversation turns from the DSH session log, so you can pick anchors before slicing.',
+    'Read-only and cheap: it decodes the log and prints who said what (truncated), newest last.',
+    'Use it when you need to know where a section starts or ends.',
+  ].join('\n'),
+  parameters: {
+    logPath: {
+      type: 'string',
+      description: 'Absolute path to session.v4.jsonl.zstd. Default: the newest session log under $DSH_HOME/sessions.',
+    },
+    limit: {
+      type: 'integer',
+      description: 'How many turns to print, newest last. Default 40.',
+    },
+    width: {
+      type: 'integer',
+      description: 'Characters per turn before truncating. Default 60.',
+    },
+  },
+};
+
+export const sliceSpec = {
+  name: 'log_slice',
+  description: [
+    'Slice one section out of the DSH session log and render it as chat-log markdown or work-dialogue markdown.',
+    'Anchors are verbatim sentence fragments (--from / --to), not line numbers: the log grows every day.',
+    'Default dry-run: nothing is written unless apply is true.',
+    'When apply is true it backs up the target first, appends the section, inserts the index row and prints a verification line.',
+  ].join('\n'),
+  parameters: {
+    kind: {
+      type: 'string',
+      enum: ['chat', 'work'],
+      description: 'chat = 《闲话集》 style (verbatim turns); work = three-line header plus quoted turns.',
+    },
+    title: {
+      type: 'string',
+      required: true,
+      description: 'Section title, e.g. "2026-10-31 ① 榫卯与第一栋房子".',
+    },
+    from: { type: 'string', description: 'Start anchor: a verbatim fragment of the first turn to include.' },
+    to: { type: 'string', description: 'End anchor: a verbatim fragment of the last turn to include. Omit for end of log.' },
+    file: { type: 'string', description: 'Target markdown file to append to (requires apply).' },
+    index: { type: 'string', description: 'Index (catalog) file whose table gets a new row (requires apply).' },
+    volume: { type: 'string', description: 'Volume name used in the index row, e.g. "闲话集-8".' },
+    logPath: { type: 'string', description: 'Path to the session log. Default: newest.' },
+    tag: { type: 'string', description: 'Backup tag, e.g. "加10-31 ① 之前". Backups go to <dir>/旧版本/.' },
+    apply: { type: 'boolean', description: 'Actually write. Default false.' },
+  },
+};
+
+async function registerAll(ctx) {
+  const defineTool = await loadDefineTool();
+
+  const probe = defineTool({
+    ...probeSpec,
+    async execute(args = {}) {
+      const limit = Math.max(1, Math.min(500, Number(args.limit) || 40));
+      const width = Math.max(10, Math.min(400, Number(args.width) || 60));
+      const built = buildSection({ kind: 'chat', title: 'probe', logPath: args.logPath });
+      const turns = built.segment.length ? built.segment : [];
+      const lines = turns.slice(-limit).map((t, i) => {
+        const who = t.who === 'user' ? 'you' : 'me';
+        const when = t.ts ? new Date(Number(t.ts) || t.ts).toLocaleString() : '';
+        const body = String(t.text || '').replace(/\s+/g, ' ').slice(0, width);
+        return `${turns.length - Math.min(limit, turns.length) + i + 1}. [${who}] ${when} ${body}`;
+      });
+      return {
+        text:
+          `# ${built.log}\n` +
+          `# ${built.frames} frames (${built.failedFrames} failed) / ${built.totalTurns} turns\n\n` +
+          lines.join('\n'),
+      };
+    },
+  });
+
+  const slice = defineTool({
+    ...sliceSpec,
+    async execute(args = {}) {
+      const built = buildSection({
+        kind: args.kind === 'work' ? 'work' : 'chat',
+        title: args.title,
+        from: args.from,
+        to: args.to,
+        logPath: args.logPath,
+      });
+      const head =
+        `# ${built.log}\n` +
+        `# ${built.frames} frames (${built.failedFrames} failed) / ${built.totalTurns} turns\n` +
+        `# sliced ${built.segment.length} turns (you ${built.counts.you} / me ${built.counts.me})\n`;
+      if (args.apply !== true) {
+        return { text: `${head}\n===== markdown (dry-run) =====\n\n${built.markdown}` };
+      }
+      if (!args.file) throw new Error('apply=true requires "file"');
+
+      const target = path.resolve(args.file);
+      const tag = args.tag || '自动整理之前';
+      const backup = fs.existsSync(target) ? backupFile(target, tag) : null;
+      const { after } = appendSection(target, built.markdown);
+      const row = indexRow(args.volume || path.basename(target, '.md'), args.title, built.counts.you);
+      let indexBackup = null;
+      let indexPath = null;
+      if (args.index && fs.existsSync(args.index)) {
+        indexPath = path.resolve(args.index);
+        indexBackup = backupFile(indexPath, tag);
+        const updated = insertIndexRow(fs.readFileSync(indexPath, 'utf8'), row, args.volume || path.basename(target, '.md'));
+        fs.writeFileSync(indexPath, updated, 'utf8');
+      }
+      const line = `| ${today()} | ${path.basename(target)}（+${built.counts.you} 轮） | ${after} | \`${sha256Hex16(target)}\` | 本体＝原件，两处一致 |`;
+      return {
+        text:
+          `${head}\nwritten: ${target}\n` +
+          (backup ? `backup: ${backup}\n` : '') +
+          (indexBackup ? `backup: ${indexBackup}\n` : '') +
+          (indexPath ? `index: ${indexPath}\n` : '') +
+          `bytes: ${after}\nrow: ${row}\nverification: ${line}`,
+      };
+    },
+  });
+
+  const disposers = [ctx.tools.register(probe), ctx.tools.register(slice)];
+  return () => {
+    for (const d of disposers.reverse()) d?.();
+  };
+}
+
+export async function apply(ctx) {
+  try {
+    return await registerAll(ctx);
+  } catch (e) {
+    try {
+      ctx?.logger?.error?.(`[dsh-log-slicer] failed to load: ${e?.stack ?? e}`);
+    } catch {
+      /* 连日志都写不了就算了 */
+    }
+    if (process.env.DSH_LOG_SLICER_DEBUG) throw e;
+    return () => {};
+  }
+}

package/src/pipeline.js

@@ -0,0 +1,61 @@
+/**
+ * pipeline.js —— 把四层串起来：取数 → 清洗 → 切片 → 渲染。
+ *
+ * CLI 和插件工具都调这里，保证两条路产出一样的东西。
+ */
+
+import fs from 'node:fs';
+import { decodeFile, latestSessionLog } from './decode.js';
+import { turnsFromText } from './clean.js';
+import { sliceTurns, countTurns } from './slice.js';
+import { renderChat, renderWork, applyImageNotes, findPointerLines } from './render.js';
+
+/**
+ * @param {object} options
+ * @param {'chat'|'work'} options.kind
+ * @param {string} options.title
+ * @param {string} [options.from]
+ * @param {string} [options.to]
+ * @param {string} [options.logPath]  不给就取最新的会话日志
+ * @param {object} [options.workHeader]  work 体裁的三行头内容
+ */
+export function buildSection(options = {}) {
+  const { kind = 'chat', title, from, to, logPath, workHeader } = options;
+  if (!title) throw new Error('title is required');
+
+  const log = logPath ? { path: logPath, size: fsSize(logPath), mtime: 0 } : latestSessionLog();
+  const decoded = decodeFile(log.path);
+  const turns = turnsFromText(decoded.text);
+  const segment = sliceTurns(turns, { from, to });
+  const counts = countTurns(segment);
+
+  const markdown =
+    kind === 'work' ? renderWork(segment, title, workHeader || {}) : renderChat(segment, title);
+
+  const images = segment.flatMap((t) => t.images || []);
+  const pointerLines = findPointerLines(segment);
+
+  return {
+    log: log.path,
+    logSize: decoded.frames ? log.size || 0 : 0,
+    frames: decoded.frames,
+    failedFrames: decoded.failed,
+    totalTurns: turns.length,
+    segment,
+    counts,
+    imageCount: images.length,
+    images,
+    pointerLines,
+    markdown,
+  };
+}
+
+function fsSize(p) {
+  try {
+    return fs.statSync(p).size;
+  } catch {
+    return 0;
+  }
+}
+
+export { applyImageNotes };

package/src/register.js

@@ -0,0 +1,86 @@
+/**
+ * register.js —— 落盘那一层：目录行、旧样备份、追加、哈希。
+ *
+ * 这一层的格式全是"过盈"的：目录行、校验行、`.bak` 命名一旦变了，
+ * 下游（备份说明、目录表、人的习惯）就装不上。
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+
+export function today(now = new Date()) {
+  const p = (n) => String(n).padStart(2, '0');
+  return `${now.getFullYear()}-${p(now.getMonth() + 1)}-${p(now.getDate())}`;
+}
+
+export function sha256Hex16(filePath) {
+  return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex').slice(0, 16).toUpperCase();
+}
+
+/** `| 卷 | 标题 | 轮 |` —— 列间一个空格，和两本正本一致。 */
+export function indexRow(volume, title, turns) {
+  return `| ${volume} | ${title} | ${turns} |`;
+}
+
+/**
+ * 把目录行插到该卷最后一行之后；没有该卷的行就插到表格末尾。
+ */
+export function insertIndexRow(markdown, row, volume) {
+  const lines = String(markdown).split('\n');
+  const cells = (line) => line.split('|').map((c) => c.trim());
+  /** 表头与分隔行不参与"这是该卷的行"的判断——卷名叫「卷」时会撞上表头。 */
+  const isStructural = (line) => {
+    const t = line.trim();
+    if (!t.startsWith('|')) return true;
+    if (t.includes('---')) return true;
+    const c = cells(t);
+    return c[1] === '卷' && (c[2] === '节' || c[2] === '标题');
+  };
+  let last = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const t = lines[i].trim();
+    if (isStructural(t)) continue;
+    if (t.startsWith(`| ${volume} |`) || t.startsWith(`|${volume}|`)) last = i;
+  }
+  if (last >= 0) {
+    lines.splice(last + 1, 0, row);
+    return lines.join('\n');
+  }
+  let headerSep = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim().startsWith('|') && lines[i].includes('---')) headerSep = i;
+  }
+  if (headerSep < 0) throw new Error('index file has no markdown table');
+  let end = headerSep;
+  while (end + 1 < lines.length && lines[end + 1].trim().startsWith('|')) end++;
+  lines.splice(end + 1, 0, row);
+  return lines.join('\n');
+}
+
+/** 旧样名：`<名字>（<动作之前>）.bak`；不写日期。 */
+export function backupPath(target, tag, oldverDir) {
+  const base = path.basename(target, path.extname(target));
+  return path.join(oldverDir || path.join(path.dirname(target), '旧版本'), `${base}（${tag}）.bak`);
+}
+
+export function backupFile(target, tag, oldverDir) {
+  const dir = oldverDir || path.join(path.dirname(target), '旧版本');
+  fs.mkdirSync(dir, { recursive: true });
+  const dst = backupPath(target, tag, dir);
+  fs.copyFileSync(target, dst);
+  return dst;
+}
+
+/** 追加一节：先保证前面是空行，再写正文。 */
+export function appendSection(target, markdown) {
+  const before = fs.existsSync(target) ? fs.readFileSync(target, 'utf8') : '';
+  const needsGap = before.length > 0 && !before.endsWith('\n\n');
+  const body = (needsGap ? '\n' : '') + markdown;
+  fs.writeFileSync(target, before + body, 'utf8');
+  return { before: Buffer.byteLength(before, 'utf8'), after: fs.statSync(target).size };
+}
+
+export function verificationLine({ date = today(), name, note, bytes, hash }) {
+  return `| ${date} | ${name}（${note}） | ${bytes} | \`${hash}\` | 本体＝原件，两处一致 |`;
+}

package/src/render.js

@@ -0,0 +1,94 @@
+/**
+ * render.js —— 轮次 → Markdown。纯字符串，不碰文件。
+ *
+ * 两种体裁：
+ *   chat：《闲话集》体——原话、`**你：**`/`**我：**` 独占一行
+ *   work：《工作时值得记录的对话》体——三行头 + 引用块 + 标成判断
+ */
+
+const LABEL = { user: '**你：**', me: '**我：**' };
+
+function tidy(body) {
+  return String(body || '')
+    .replace(/\r\n/g, '\n')
+    .replace(/[ \t]+$/gm, '')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+export function renderChat(segment, title) {
+  const blocks = [`## ${title}`, ''];
+  for (const t of segment) {
+    const body = tidy(t.text);
+    blocks.push(LABEL[t.who] || LABEL.me, '');
+    if (body) blocks.push(body, '');
+    if (t.who === 'user' && Array.isArray(t.images)) {
+      for (const img of t.images) {
+        // 图片落成文件后由调用方替换成「（图见 …）」；这里给一个显眼占位，别静默丢
+        blocks.push(`（图未落：\`${img.sha256}\` ${img.mediaType} — 落盘后改成「（图见 …）」）`, '');
+      }
+    }
+  }
+  return blocks.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd() + '\n';
+}
+
+export function renderWork(segment, title, { what = '（待写）', line = '（待写）', why = '（待写）', origin = '（待填）' } = {}) {
+  const out = [
+    `## ${title}`,
+    '',
+    `> 这段在做什么：${what}`,
+    `> 涉及：${line}｜原件：${origin}`,
+    `> 为什么留着：${why}`,
+    '',
+  ];
+  for (const t of segment) {
+    const body = tidy(t.text);
+    if (!body) continue;
+    if (t.who === 'user') {
+      // 他的话：引用块照抄，一个字不改
+      out.push(...body.split('\n').map((l) => `> ${l}`.trimEnd()), '');
+    } else {
+      out.push('**我**（当时的判断，可能被推翻）：', '', body, '');
+    }
+  }
+  return out.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd() + '\n';
+}
+
+/**
+ * 他的话里有没有"指路句"（"我更新了第一轮""你可以看看那个文件"）。
+ *
+ * 这类句子不是原话，是他往文件上指；录进正本会让后来的人以为那儿就是内容。
+ * 这里只负责认出来、报给调用方，怎么处理（去原件抄、或按三级不抄）由人决定。
+ */
+const POINTER_PATTERNS = [
+  /我(?:已经)?更新了第[一二三四五六七八九十\d]+轮/,
+  /你可以(?:看看|看一下|读一下|理解一下)/,
+  /这方面内容我们就(?:结束|到此)/,
+  /我(?:在)?工作区(?:更新|放)了/,
+];
+
+export function findPointerLines(segment) {
+  const hits = [];
+  segment.forEach((t, i) => {
+    if (t.who !== 'user') return;
+    const body = tidy(t.text);
+    for (const re of POINTER_PATTERNS) {
+      const m = body.match(re);
+      if (m) {
+        hits.push({ index: i, phrase: m[0], text: body.slice(0, 60) });
+        break;
+      }
+    }
+  });
+  return hits;
+}
+
+/** 把 `（图未落 …）` 占位替换成正式图注。 */
+export function applyImageNotes(markdown, mapping = {}) {
+  let out = markdown;
+  for (const [sha, note] of Object.entries(mapping)) {
+    const re = new RegExp(`（图未落：\`${sha}\`[^）]*）`, 'g');
+    out = out.replace(re, note);
+  }
+  return out;
+}

package/src/slice.js

@@ -0,0 +1,51 @@
+/**
+ * slice.js —— 按锚点切成一段，配对成"你说/我说"。
+ *
+ * 锚点是原话片段（子串匹配），不认行号：日志每天都在长，行号一定会错。
+ */
+
+export class AnchorError extends Error {
+  constructor(message, candidates = []) {
+    super(message);
+    this.name = 'AnchorError';
+    this.candidates = candidates;
+  }
+}
+
+function preview(text, width = 40) {
+  return String(text || '').replace(/\s+/g, ' ').slice(0, width);
+}
+
+/** 找不到锚点时，给最近的几句当候选，别让人猜。 */
+export function suggestAnchors(turns, limit = 8) {
+  return turns
+    .slice(-limit)
+    .map((t, i) => `${t.who === 'user' ? '你' : '我'}: ${preview(t.text)}`);
+}
+
+/**
+ * @param {Array} turns
+ * @param {{from?: string, to?: string}} range
+ */
+export function sliceTurns(turns, range = {}) {
+  const { from, to } = range;
+  let start = 0;
+  if (from) {
+    start = turns.findIndex((t) => t.text && t.text.includes(from));
+    if (start < 0) throw new AnchorError(`anchor not found (from): ${from}`, suggestAnchors(turns));
+  }
+  let end = turns.length - 1;
+  if (to) {
+    const found = turns.findIndex((t, i) => i >= start && t.text && t.text.includes(to));
+    if (found < 0) throw new AnchorError(`anchor not found (to): ${to}`, suggestAnchors(turns));
+    end = found;
+  }
+  if (end < start) throw new AnchorError('anchor range is empty: "to" is before "from"', []);
+  return turns.slice(start, end + 1);
+}
+
+/** 统计轮数：以"你"的条数为"轮"。 */
+export function countTurns(segment) {
+  const you = segment.filter((t) => t.who === 'user').length;
+  return { you, me: segment.length - you };
+}