dsh-claude-move 0.2.6 → 0.3.0

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable changes to this project are documented here. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versions follow [SemVer](https://semver.org/).
 
+## [0.3.0] - 2026-08-26
+
+### Added
+
+- DSH 会话回迁 Claude jsonl 双向导出：新增 `claude_export` 工具与 `/claude-export` 命令，把 DSH 会话导出回 Claude 的 jsonl 格式。
+
+### Fixed
+
+- Use platform-neutral absolute paths in the export path tests (CI).
+
+## [0.2.7] - 2026-08-23
+
+### Changed
+
+- Tighten the `@deepseek-ai/schemastery` peer range from `>=3.0.0` to `^3.18.0` to match the range every other DSH plugin declares (and the harness's pinned `3.18.x` line); `>=3.0.0` over-claimed API compatibility across 3.x minors.
+
 ## [0.2.6] - 2026-08-22
 
 ### Changed

package/README.es.md

@@ -42,7 +42,8 @@
 4. **Solo-copia e incremental** — nada se mueve, reescribe ni elimina en ninguno de los dos lados; reejecutar solo añade los turnos nuevos (`force: true` guarda una copia completa adicional con un id nuevo).
 5. **Contexto personal, siempre fresco** — las memorias se inyectan como una sección de prompt en vivo, las habilidades de Claude se registran como habilidades DSH reales (globales + a nivel de proyecto), y el `CLAUDE.md` global + de proyecto se inyecta temprano.
 6. **Asistente de migración de cuatro fuentes** — `/move` más `move_detect` / `move_preview` / `move_run` migran Claude Code, Codex, OpenCode y Hermes, con aprobación e idempotencia (`move.json`).
-7. **Panel web y comandos** — `/claude-import-all`, `/resume-claude`, `/claude-move-reset` y un panel de migración flotante.
+7. **Panel web y comandos** — `/claude-import-all`, `/resume-claude`, `/claude-move-reset`, `/claude-export` y un panel de migración flotante.
+8. **Exportación bidireccional** — `claude_export` (o `/claude-export <sessionId>`) vuelve a escribir una sesión DSH como transcript JSONL reanudable de Claude Code (turnos `user`/`assistant`/`tool`, emparejamiento `thinking` + `tool_use`/`tool_result`, mapeo `cwd` de mejor esfuerzo), para que el historial pueda salir de DSH de nuevo.
 
 ## Asistente de migración de cuatro fuentes
 
@@ -122,6 +123,9 @@ import_claude { path: "all" }                       # todo
 # Reejecuta en cualquier momento: los archivos sin cambios se omiten, las transcripciones crecidas solo añaden los turnos nuevos.
 # Los archivos mayores que maxTranscriptBytes se importan por streaming en trozos (sin techo de memoria).
 import_claude { path: "...", force: true }          # copia completa nueva (se conserva la copia anterior)
+
+claude_export { sessionId: "<dsh-session-id>" }     # escribe una sesión DSH de vuelta a JSONL de Claude
+claude_export { sessionId: "...", path: "~/.claude/projects/<slug>/<id>.jsonl" }  # destino explícito
 ```
 
 Comandos (activados por el usuario, sin turno del modelo):
@@ -132,6 +136,7 @@ Comandos (activados por el usuario, sin turno del modelo):
 /resume-claude <sessionId>        # por id de sesión fuente o id import-<src>
 /resume-claude <keyword>          # coincide con títulos; varias coincidencias se listan, nunca se adivina
 /claude-move-reset                # reinicia la caché del plugin (marcadores + mapa de importación); las sesiones importadas se conservan
+/claude-export <sessionId> [path] # exporta una sesión DSH a un transcript JSONL reanudable de Claude
 ```
 
 Panel web: un panel de migración flotante con el árbol de proyectos/sesiones, insignias de estado (no importado / importado / importado-con-turnos-nuevos / fuente ausente / directorio ausente / git sucio), filtro por palabra clave, renderizado paginado, "Importar y continuar" + "Abrir sesión" + "Refrescar lista de sesiones" por sesión, importación por lotes con barra de progreso en vivo y cancelar, y un botón de reinicio de caché. Los textos siguen el idioma del navegador (zh/en). Servido a través de las rutas JSON `/api/claude-move/*` propias del plugin en la costura pública `ctx.webServer`.
@@ -177,6 +182,8 @@ Todo opcional, anulable en cordis.yml.
 | `skillsDir` | `$DSH_HOME/skills` | Destino de habilidades del asistente |
 | `agentsMdPath` | `$DSH_HOME/AGENTS.md` | Destino de memoria/instrucciones del asistente |
 | `moveWorkspaceMode` | `per-source` | Agrupación de workspace para importaciones del asistente: `per-source` · `single` |
+| `enableExport` | `true` | Registra la herramienta `claude_export` y el comando `/claude-export` |
+| `exportDir` | `$DSH_HOME/claude-export` | Carpeta de exportación por defecto (un `path` explícito siempre gana) |
 
 ## Herramientas y superficies
 
@@ -184,10 +191,12 @@ Todo opcional, anulable en cordis.yml.
 |---|---|---|
 | `claude_scan` | herramienta | Índice estructurado de proyectos/sesiones/memorias/habilidades/ajustes |
 | `import_claude` | herramienta | Importa una sesión, un directorio o `all` (incremental; `force` para una copia nueva) |
+| `claude_export` | herramienta | Exporta una sesión DSH a un transcript JSONL reanudable de Claude Code |
 | `move_detect` / `move_preview` / `move_run` | herramientas | Asistente de cuatro fuentes: escanear, plan por ítem con diffs, ejecutar tras la aprobación |
 | `/claude-import-all` | comando | Escanea → importa todo → informa |
 | `/resume-claude` | comando | Continúa una sesión de Claude (latest, id o palabra clave) |
 | `/claude-move-reset` | comando | Reinicia la caché del plugin (las sesiones importadas se conservan) |
+| `/claude-export` | comando | Exporta una sesión DSH a un transcript JSONL reanudable de Claude |
 | `/move` | comando | Asistente de cuatro fuentes de un solo paso |
 | Panel web de migración | cliente | Panel flotante con progreso, cancelación, paginación, abrir sesión |
 

package/README.hi.md

@@ -42,7 +42,8 @@
 4. **केवल-कॉपी और वृद्धिशील** — किसी भी तरफ कुछ भी स्थानांतरित, दोबारा लिखा या हटाया नहीं जाता; फिर चलाने पर केवल नए टर्न जोड़े जाते हैं (`force: true` एक नए id के तहत अतिरिक्त पूरी कॉपी सहेजता है)।
 5. **व्यक्तिगत संदर्भ, हमेशा ताज़ा** — यादें लाइव प्रॉम्प्ट अनुभाग के रूप में इंजेक्ट होती हैं, Claude कौशल वास्तविक DSH कौशल के रूप में पंजीकृत होते हैं (वैश्विक + प्रोजेक्ट-स्तर), वैश्विक + प्रोजेक्ट `CLAUDE.md` जल्दी इंजेक्ट होता है।
 6. **चार-स्रोत माइग्रेशन विज़ार्ड** — `/move` और `move_detect` / `move_preview` / `move_run` Claude Code, Codex, OpenCode और Hermes को माइग्रेट करते हैं, अनुमोदन-गेटेड और आइडेम्पोटेंट (`move.json`)।
-7. **वेब पैनल और कमांड** — `/claude-import-all`, `/resume-claude`, `/claude-move-reset`, और एक फ़्लोटिंग माइग्रेशन पैनल।
+7. **वेब पैनल और कमांड** — `/claude-import-all`, `/resume-claude`, `/claude-move-reset`, `/claude-export`, और एक फ़्लोटिंग माइग्रेशन पैनल।
+8. **द्विदिश निर्यात** — `claude_export` (या `/claude-export <sessionId>`) एक DSH सत्र को वापस resumable Claude Code JSONL transcript के रूप में लिखता है (`user`/`assistant`/`tool` टर्न, `thinking` + `tool_use`/`tool_result` जोड़ी, सर्वोत्तम-प्रयास `cwd` मैपिंग), ताकि इतिहास फिर से DSH से बाहर जा सके।
 
 ## चार-स्रोत माइग्रेशन विज़ार्ड
 
@@ -122,6 +123,9 @@ import_claude { path: "all" }                       # सब कुछ
 # कभी भी फिर चलाएँ: अपरिवर्तित फ़ाइलें छोड़ दी जाती हैं, बढ़ी ट्रांसक्रिप्ट केवल नए टर्न जोड़ती हैं।
 # maxTranscriptBytes से बड़ी फ़ाइलें खंडों में स्ट्रीम-आयात होती हैं (कोई मेमोरी सीमा नहीं)।
 import_claude { path: "...", force: true }          # ताज़ा पूरी कॉपी (पिछली कॉपी रखी जाती है)
+
+claude_export { sessionId: "<dsh-session-id>" }     # DSH सत्र को वापस Claude JSONL में लिखें
+claude_export { sessionId: "...", path: "~/.claude/projects/<slug>/<id>.jsonl" }  # स्पष्ट लक्ष्य
 ```
 
 कमांड (उपयोगकर्ता-ट्रिगर, कोई मॉडल टर्न नहीं):
@@ -132,6 +136,7 @@ import_claude { path: "...", force: true }          # ताज़ा पूर
 /resume-claude <sessionId>        # स्रोत सत्र id या import-<src> id से
 /resume-claude <keyword>          # शीर्षक मिलाएँ; कई मिलान सूचीबद्ध होते हैं, कभी अनुमान नहीं
 /claude-move-reset                # प्लगइन कैश रीसेट करें (बुकमार्क + आयात मैप); आयातित सत्र बने रहते हैं
+/claude-export <sessionId> [path] # DSH सत्र को resumable Claude JSONL transcript में निर्यात करें
 ```
 
 वेब पैनल: प्रोजेक्ट/सत्र ट्री, स्थिति बैज (आयातित नहीं / आयातित / नए-टर्न-सहित-आयातित / स्रोत अनुपस्थित / निर्देशिका अनुपस्थित / git गंदा), कीवर्ड फ़िल्टर, पृष्ठांकित रेंडरिंग, प्रति-सत्र "आयात करें और जारी रखें" + "सत्र खोलें" + "सत्र सूची रीफ़्रेश करें", लाइव प्रगति पट्टी और रद्द के साथ बैच आयात, और एक कैश-रीसेट बटन वाला फ़्लोटिंग माइग्रेशन पैनल। पाठ ब्राउज़र भाषा (zh/en) का अनुसरण करते हैं। सार्वजनिक `ctx.webServer` सीम पर प्लगइन के अपने `/api/claude-move/*` JSON मार्गों से परोसा जाता है।
@@ -177,6 +182,8 @@ import_claude { path: "...", force: true }          # ताज़ा पूर
 | `skillsDir` | `$DSH_HOME/skills` | विज़ार्ड कौशल लक्ष्य |
 | `agentsMdPath` | `$DSH_HOME/AGENTS.md` | विज़ार्ड याद/निर्देश लक्ष्य |
 | `moveWorkspaceMode` | `per-source` | विज़ार्ड आयात के लिए workspace समूहन: `per-source` · `single` |
+| `enableExport` | `true` | `claude_export` टूल और `/claude-export` कमांड पंजीकृत करें |
+| `exportDir` | `$DSH_HOME/claude-export` | डिफ़ॉल्ट निर्यात फ़ोल्डर (स्पष्ट `path` हमेशा प्राथमिकता) |
 
 ## उपकरण और सतहें
 
@@ -184,10 +191,12 @@ import_claude { path: "...", force: true }          # ताज़ा पूर
 |---|---|---|
 | `claude_scan` | टूल | प्रोजेक्ट/सत्र/याद/कौशल/सेटिंग का संरचित इंडेक्स |
 | `import_claude` | टूल | एक सत्र, निर्देशिका या `all` आयात करें (वृद्धिशील; `force` से नई कॉपी) |
+| `claude_export` | टूल | DSH सत्र को resumable Claude Code JSONL transcript में निर्यात करें |
 | `move_detect` / `move_preview` / `move_run` | टूल | चार-स्रोत विज़ार्ड: स्कैन, diff सहित प्रति-आइटम योजना, अनुमोदन के बाद निष्पादन |
 | `/claude-import-all` | कमांड | स्कैन → सब आयात → रिपोर्ट |
 | `/resume-claude` | कमांड | Claude सत्र जारी करें (latest, id या कीवर्ड) |
 | `/claude-move-reset` | कमांड | प्लगइन कैश रीसेट करें (आयातित सत्र बने रहते हैं) |
+| `/claude-export` | कमांड | DSH सत्र को resumable Claude JSONL transcript में निर्यात करें |
 | `/move` | कमांड | एक-चरण चार-स्रोत विज़ार्ड |
 | वेब माइग्रेशन पैनल | क्लाइंट | प्रगति, रद्द, पेजिंग, सत्र खोलें वाला फ़्लोटिंग पैनल |
 

package/README.md

@@ -43,7 +43,8 @@
 4. **Copy-only & incremental** — nothing on either side is moved, rewritten, or deleted; re-running appends only the new turns (`force: true` saves an extra full copy under a new id).
 5. **Personal context, always fresh** — memories injected as a live prompt section, Claude skills registered as real DSH skills (global + project-level), global + project `CLAUDE.md` injected early.
 6. **Four-source migration wizard** — `/move` plus `move_detect` / `move_preview` / `move_run` migrate Claude Code, Codex, OpenCode and Hermes, approval-gated and idempotent (`move.json`).
-7. **Web panel & commands** — `/claude-import-all`, `/resume-claude`, `/claude-move-reset`, and a floating migration panel.
+7. **Web panel & commands** — `/claude-import-all`, `/resume-claude`, `/claude-move-reset`, `/claude-export`, and a floating migration panel.
+8. **Bidirectional export** — `claude_export` (or `/claude-export <sessionId>`) writes a DSH session back out as a resumable Claude Code JSONL transcript (`user`/`assistant`/`tool` turns, `thinking` + `tool_use`/`tool_result` pairing, best-effort `cwd` mapping), so history can leave DSH again.
 
 ## Four-source migration wizard
 
@@ -123,6 +124,9 @@ import_claude { path: "all" }                       # everything
 # Re-run any time: unchanged files are skipped, grown transcripts append only the new turns.
 # Files over maxTranscriptBytes are stream-imported in chunks (no memory ceiling).
 import_claude { path: "...", force: true }          # fresh full copy (previous copy kept)
+
+claude_export { sessionId: "<dsh-session-id>" }     # write a DSH session back to Claude JSONL
+claude_export { sessionId: "...", path: "~/.claude/projects/<slug>/<id>.jsonl" }  # explicit target
 ```
 
 Commands (user-triggered, no model turn):
@@ -133,6 +137,7 @@ Commands (user-triggered, no model turn):
 /resume-claude <sessionId>        # by source session id or import-<src> id
 /resume-claude <keyword>          # match titles; multiple matches are listed, never guessed
 /claude-move-reset                # reset the plugin cache (bookmarks + import map); imported sessions are kept
+/claude-export <sessionId> [path] # export a DSH session to a resumable Claude JSONL transcript
 ```
 
 Web panel: a floating migration panel with the project/session tree, status badges (not imported / imported / imported-with-new-turns / source missing / directory missing / git dirty), keyword filter, paged rendering, per-session "Import & continue" + "Open session" + "Refresh session list", batch import with a live progress bar and cancel, and a cache-reset button. Texts follow the browser language (zh/en). Served through the plugin's own `/api/claude-move/*` JSON routes on the public `ctx.webServer` seam.
@@ -178,6 +183,8 @@ All optional, overridable in cordis.yml.
 | `skillsDir` | `$DSH_HOME/skills` | Wizard skill target |
 | `agentsMdPath` | `$DSH_HOME/AGENTS.md` | Wizard memory/instruction target |
 | `moveWorkspaceMode` | `per-source` | `per-source` · `single` workspace grouping for wizard imports |
+| `enableExport` | `true` | Register the `claude_export` tool and `/claude-export` command |
+| `exportDir` | `$DSH_HOME/claude-export` | Default export folder (explicit `path` always wins) |
 
 ## Tools & surfaces
 
@@ -185,10 +192,12 @@ All optional, overridable in cordis.yml.
 |---|---|---|
 | `claude_scan` | tool | Structured index of projects/sessions/memories/skills/settings |
 | `import_claude` | tool | Import one session, a directory, or `all` (incremental, `force` for a fresh copy) |
+| `claude_export` | tool | Export a DSH session to a resumable Claude Code JSONL transcript |
 | `move_detect` / `move_preview` / `move_run` | tools | Four-source wizard: scan, per-item plan with diffs, execute behind approval |
 | `/claude-import-all` | command | Scan → import everything → report |
 | `/resume-claude` | command | Continue a Claude session (latest, id, or keyword) |
 | `/claude-move-reset` | command | Reset the plugin cache (imported sessions kept) |
+| `/claude-export` | command | Export a DSH session to a resumable Claude JSONL transcript |
 | `/move` | command | One-shot four-source wizard |
 | Web migration panel | client | Floating panel with progress, cancel, paging, open session |
 
@@ -196,7 +205,7 @@ All optional, overridable in cordis.yml.
 
 - **Permissions**: the workshop manifest declares `filesystem:read` and `filesystem:write`.
 - **Reads** `~/.claude` (transcripts, memories, skills, `CLAUDE.md`, `settings.json`) — strictly read-only — and the project directories it imports into.
-- **Writes** DSH session logs via the public `sessionPersistence` service (create + append only, never delete/rewrite/archive), workspace-registry records, its cache under `$DSH_HOME/claude-move/`, and the `claudecode` workspace folder.
+- **Writes** DSH session logs via the public `sessionPersistence` service (create + append only, never delete/rewrite/archive), workspace-registry records, its cache under `$DSH_HOME/claude-move/`, the `claudecode` workspace folder, and exported `.jsonl` files under `$DSH_HOME/claude-export/` (or an explicit target path).
 - **Never** modifies Claude source files, touches other applications' data, or accesses the network. **No credentials** are read or transmitted.
 
 ## Security boundaries
@@ -220,7 +229,7 @@ All optional, overridable in cordis.yml.
 
 ## Model Experience
 
-- The model-facing surface is the two tools' descriptions/schemas and their outputs: `claude_scan` returns the structured index, `import_claude` returns per-file summaries with positions of warnings. Tool results are themselves logged `tool/result` events, so everything is reconstructable.
+- The model-facing surface is the tools' descriptions/schemas and their outputs: `claude_scan` returns the structured index, `import_claude` returns per-file summaries with positions of warnings, and `claude_export` returns the export summary (target path + turn/message/tool counts). Tool results are themselves logged `tool/result` events, so everything is reconstructable.
 - No hidden model-facing text; memory/`CLAUDE.md` sections are registered on `ctx.systemPrompt` (prompt assembly, rebuildable from the session log).
 
 ## Troubleshooting

package/README.pt.md

@@ -42,7 +42,8 @@
 4. **Somente-cópia e incremental** — nada é movido, reescrito ou excluído em nenhum dos lados; reexecutar apenas anexa os turnos novos (`force: true` salva uma cópia completa extra sob um novo id).
 5. **Contexto pessoal, sempre atualizado** — memórias injetadas como uma seção de prompt em tempo real, habilidades do Claude registradas como habilidades DSH reais (globais + de projeto), e o `CLAUDE.md` global + de projeto injetado cedo.
 6. **Assistente de migração de quatro fontes** — `/move` mais `move_detect` / `move_preview` / `move_run` migram Claude Code, Codex, OpenCode e Hermes, com aprovação e idempotência (`move.json`).
-7. **Painel web e comandos** — `/claude-import-all`, `/resume-claude`, `/claude-move-reset` e um painel de migração flutuante.
+7. **Painel web e comandos** — `/claude-import-all`, `/resume-claude`, `/claude-move-reset`, `/claude-export` e um painel de migração flutuante.
+8. **Exportação bidirecional** — `claude_export` (ou `/claude-export <sessionId>`) grava uma sessão DSH de volta como transcript JSONL retomável do Claude Code (turnos `user`/`assistant`/`tool`, pareamento `thinking` + `tool_use`/`tool_result`, mapeamento `cwd` de melhor esforço), para que o histórico possa sair do DSH novamente.
 
 ## Assistente de migração de quatro fontes
 
@@ -122,6 +123,9 @@ import_claude { path: "all" }                       # tudo
 # Reexecute a qualquer momento: arquivos inalterados são pulados, transcrições crescidas anexam apenas os turnos novos.
 # Arquivos acima de maxTranscriptBytes são importados por streaming em blocos (sem teto de memória).
 import_claude { path: "...", force: true }          # cópia completa nova (cópia anterior mantida)
+
+claude_export { sessionId: "<dsh-session-id>" }     # grava uma sessão DSH de volta para JSONL do Claude
+claude_export { sessionId: "...", path: "~/.claude/projects/<slug>/<id>.jsonl" }  # destino explícito
 ```
 
 Comandos (acionados pelo usuário, sem turno do modelo):
@@ -132,6 +136,7 @@ Comandos (acionados pelo usuário, sem turno do modelo):
 /resume-claude <sessionId>        # por id de sessão fonte ou id import-<src>
 /resume-claude <keyword>          # corresponde a títulos; múltiplas correspondências são listadas, nunca adivinhadas
 /claude-move-reset                # reinicia o cache do plugin (marcadores + mapa de importação); sessões importadas são mantidas
+/claude-export <sessionId> [path] # exporta uma sessão DSH para um transcript JSONL retomável do Claude
 ```
 
 Painel web: um painel de migração flutuante com a árvore de projetos/sessões, selos de status (não importado / importado / importado-com-turnos-novos / fonte ausente / diretório ausente / git sujo), filtro por palavra-chave, renderização paginada, "Importar e continuar" + "Abrir sessão" + "Atualizar lista de sessões" por sessão, importação em lote com barra de progresso em tempo real e cancelar, e um botão de reinício de cache. Os textos seguem o idioma do navegador (zh/en). Servido pelas rotas JSON `/api/claude-move/*` próprias do plugin na costura pública `ctx.webServer`.
@@ -177,6 +182,8 @@ Tudo opcional, anulável no cordis.yml.
 | `skillsDir` | `$DSH_HOME/skills` | Destino de skills do assistente |
 | `agentsMdPath` | `$DSH_HOME/AGENTS.md` | Destino de memória/instruções do assistente |
 | `moveWorkspaceMode` | `per-source` | Agrupamento de workspace para importações do assistente: `per-source` · `single` |
+| `enableExport` | `true` | Registra a ferramenta `claude_export` e o comando `/claude-export` |
+| `exportDir` | `$DSH_HOME/claude-export` | Pasta de exportação padrão (um `path` explícito sempre vence) |
 
 ## Ferramentas e superfícies
 
@@ -184,10 +191,12 @@ Tudo opcional, anulável no cordis.yml.
 |---|---|---|
 | `claude_scan` | ferramenta | Índice estruturado de projetos/sessões/memórias/habilidades/ajustes |
 | `import_claude` | ferramenta | Importa uma sessão, um diretório ou `all` (incremental; `force` para cópia nova) |
+| `claude_export` | ferramenta | Exporta uma sessão DSH para um transcript JSONL retomável do Claude Code |
 | `move_detect` / `move_preview` / `move_run` | ferramentas | Assistente de quatro fontes: varrer, plano por item com diffs, executar após aprovação |
 | `/claude-import-all` | comando | Varre → importa tudo → relata |
 | `/resume-claude` | comando | Continua uma sessão do Claude (latest, id ou palavra-chave) |
 | `/claude-move-reset` | comando | Reinicia o cache do plugin (sessões importadas mantidas) |
+| `/claude-export` | comando | Exporta uma sessão DSH para um transcript JSONL retomável do Claude |
 | `/move` | comando | Assistente de quatro fontes de um só passo |
 | Painel web de migração | cliente | Painel flutuante com progresso, cancelamento, paginação, abrir sessão |
 

package/README.zh.md

@@ -42,7 +42,8 @@
 4. **只复制且增量** —— 两侧都不会被移动、改写或删除；重新运行只追加新的轮次（`force: true` 以新 id 额外保存一份完整副本）。
 5. **个人上下文，始终新鲜** —— 记忆作为实时提示词段落注入，Claude 技能注册为真正的 DSH 技能（全局 + 项目级），全局 + 项目 `CLAUDE.md` 提前注入。
 6. **四来源迁移向导** —— `/move` 加上 `move_detect` / `move_preview` / `move_run` 迁移 Claude Code、Codex、OpenCode 和 Hermes，审批门控且幂等（`move.json`）。
-7. **Web 面板与命令** —— `/claude-import-all`、`/resume-claude`、`/claude-move-reset`，以及一个浮动迁移面板。
+7. **Web 面板与命令** —— `/claude-import-all`、`/resume-claude`、`/claude-move-reset`、`/claude-export`，以及一个浮动迁移面板。
+8. **双向导出** —— `claude_export`（或 `/claude-export <sessionId>`）把 DSH 会话回写为 Claude Code 可 resume 的 JSONL transcript（user/assistant/tool 轮次、thinking + tool_use/tool_result 配对、cwd 尽力映射），让历史可以再次离开 DSH。
 
 ## 四来源迁移向导
 
@@ -122,6 +123,9 @@ import_claude { path: "all" }                       # 全部
 # 随时重新运行：未变更的文件被跳过，增长的 transcript 只追加新的轮次。
 # 超过 maxTranscriptBytes 的文件以分块流式导入（无内存上限）。
 import_claude { path: "...", force: true }          # 全新的完整副本（保留之前的副本）
+
+claude_export { sessionId: "<dsh-session-id>" }     # 把 DSH 会话回写为 Claude JSONL
+claude_export { sessionId: "...", path: "~/.claude/projects/<slug>/<id>.jsonl" }  # 指定目标
 ```
 
 命令（用户触发，不占模型轮次）：
@@ -132,6 +136,7 @@ import_claude { path: "...", force: true }          # 全新的完整副本（
 /resume-claude <sessionId>        # 按源会话 id 或 import-<src> id
 /resume-claude <keyword>          # 匹配标题；多个匹配会列出，绝不猜测
 /claude-move-reset                # 重置插件缓存（书签 + 导入映射）；导入的会话保留
+/claude-export <sessionId> [path] # 导出 DSH 会话为可 resume 的 Claude JSONL transcript
 ```
 
 Web 面板：一个浮动迁移面板，包含项目/会话树、状态徽章（未导入 / 已导入 / 已导入并有新轮次 / 源缺失 / 目录缺失 / git 脏）、关键字过滤、分页渲染、每个会话的「导入并继续」+「打开会话」+「刷新会话列表」、带实时进度条和取消的批量导入，以及一个缓存重置按钮。文本跟随浏览器语言（zh/en）。通过插件自身的 `/api/claude-move/*` JSON 路由在公开 `ctx.webServer` 接缝上提供。
@@ -177,6 +182,8 @@ Web 面板：一个浮动迁移面板，包含项目/会话树、状态徽章（
 | `skillsDir` | `$DSH_HOME/skills` | 向导技能目标 |
 | `agentsMdPath` | `$DSH_HOME/AGENTS.md` | 向导记忆/指令目标 |
 | `moveWorkspaceMode` | `per-source` | 向导导入的工作区分组：`per-source` · `single` |
+| `enableExport` | `true` | 注册 `claude_export` 工具与 `/claude-export` 命令 |
+| `exportDir` | `$DSH_HOME/claude-export` | 默认导出目录（显式 `path` 始终优先） |
 
 ## 工具与界面
 
@@ -184,10 +191,12 @@ Web 面板：一个浮动迁移面板，包含项目/会话树、状态徽章（
 |---|---|---|
 | `claude_scan` | 工具 | 项目/会话/记忆/技能/设置的结构化索引 |
 | `import_claude` | 工具 | 导入单个会话、一个目录或 `all`（增量；`force` 生成全新副本） |
+| `claude_export` | 工具 | 把 DSH 会话导出为可 resume 的 Claude Code JSONL transcript |
 | `move_detect` / `move_preview` / `move_run` | 工具 | 四来源向导：扫描、带 diff 的逐项计划、在审批之后执行 |
 | `/claude-import-all` | 命令 | 扫描 → 导入全部 → 报告 |
 | `/resume-claude` | 命令 | 继续一个 Claude 会话（latest、id 或关键字） |
 | `/claude-move-reset` | 命令 | 重置插件缓存（导入的会话保留） |
+| `/claude-export` | 命令 | 导出 DSH 会话为可 resume 的 Claude JSONL transcript |
 | `/move` | 命令 | 一次性四来源向导 |
 | Web 迁移面板 | 客户端 | 带进度、取消、分页、打开会话的浮动面板 |
 
@@ -219,7 +228,7 @@ Web 面板：一个浮动迁移面板，包含项目/会话树、状态徽章（
 
 ## 模型体验
 
-- 面向模型的面是两个工具的描述/schema 及其输出：`claude_scan` 返回结构化索引，`import_claude` 返回逐文件摘要以及警告的位置。工具结果本身被记录为 `tool/result` 事件，因此一切都可以重建。
+- 面向模型的面是这些工具的描述/schema 及其输出：`claude_scan` 返回结构化索引，`import_claude` 返回逐文件摘要以及警告的位置，`claude_export` 返回导出摘要（目标路径 + 轮次/消息/工具计数）。工具结果本身被记录为 `tool/result` 事件，因此一切都可以重建。
 - 没有隐藏的面向模型的文本；记忆/`CLAUDE.md` 段落注册在 `ctx.systemPrompt` 上（提示词组装，可从会话日志重建）。
 
 ## 故障排查

package/index.mjs

@@ -42,6 +42,7 @@ import { makeFileCache, readMemoriesSync, renderMemories, renderClaudeMd, fileEx
 import { makeClaudeSkillsProvider } from './lib/skills-provider.mjs'
 import { translateSettings } from './lib/settings.mjs'
 import { buildHandoff, DEFAULT_HANDOFF_MAX_CHARS } from './lib/handoff.mjs'
+import { eventsToClaudeJsonl } from './lib/export.mjs'
 import { importsStore } from './lib/imports-store.mjs'
 import { manifestStore } from './lib/manifest.mjs'
 import { runPreview, runExecute, runWizard, reportLines } from './lib/wizard.mjs'
@@ -97,6 +98,8 @@ export const DEFAULT_IMPORT_CONCURRENCY = 4
  * @property {'per-source'|'single'} [moveWorkspaceMode] 向导会话归组：'per-source'（默认）每源一个工作区（`$DSH_HOME/imports/<source>`）；'single' 全部挂到一个 imports 工作区（`$DSH_HOME/imports`）。
  * @property {string} [skillsDir] 向导技能落点；缺省 `$DSH_HOME/skills`（官方用户技能根，DSH 自动发现）。
  * @property {string} [agentsMdPath] 向导记忆/指令落点；缺省 `$DSH_HOME/AGENTS.md`（DSH 全局指令文件）。
+ * @property {boolean} [enableExport] 注册 DSH 会话回迁导出（claude_export 工具与 /claude-export 命令，默认 true）。
+ * @property {string} [exportDir] 回迁导出落点目录；缺省 `$DSH_HOME/claude-export`（DSH_HOME 缺失时 `~/.dsh/claude-export`）。
  */
 
 export const Config = Schema.object({
@@ -131,6 +134,8 @@ export const Config = Schema.object({
   moveWorkspaceMode: Schema.union([Schema.const('per-source'), Schema.const('single')]).default('per-source'),
   skillsDir: Schema.string(),
   agentsMdPath: Schema.string(),
+  enableExport: Schema.boolean().default(true),
+  exportDir: Schema.string(),
 })
 
 const sessionImportSchema = {
@@ -1520,6 +1525,146 @@ function makeImportTool(ctx, config) {
   })
 }
 
+// ── 会话回迁导出（F18）：DSH 会话 → Claude 可 resume JSONL ────────────────────
+
+/** claude_export 输出 schema。 */
+const exportResultSchema = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    sessionId: { type: 'string', required: true },
+    path: { type: 'string', required: true },
+    title: { type: 'string' },
+    cwd: { type: 'string' },
+    lines: { type: 'integer', required: true },
+    turns: { type: 'integer', required: true },
+    user: { type: 'integer', required: true },
+    assistant: { type: 'integer', required: true },
+    toolCalls: { type: 'integer', required: true },
+    toolResults: { type: 'integer', required: true },
+  },
+}
+
+/**
+ * 回迁导出落点目录：config.exportDir 显式给出则按绝对路径解析，否则
+ * `$DSH_HOME/claude-export`（DSH_HOME 缺失时 `~/.dsh/claude-export`）。
+ * @param config - 插件配置。
+ * @param env - 环境对象，缺省 process.env。
+ * @returns 目录绝对路径。
+ */
+export function resolveExportDir(config, env = process.env) {
+  if (typeof config?.exportDir === 'string' && config.exportDir.trim().length > 0) {
+    return path.resolve(config.exportDir)
+  }
+  const base = env.DSH_HOME || path.join(homedir(), '.dsh')
+  return path.join(base, 'claude-export')
+}
+
+/**
+ * 解析导出目标文件路径：显式 path（支持 `~`）直接解析；缺省落回
+ * `<exportDir>/<sanitized-sessionId>.jsonl`。
+ * @param raw - 工具参数里的 path。
+ * @param sessionId - DSH 会话 id。
+ * @param config - 插件配置。
+ * @returns 绝对文件路径。
+ */
+export function resolveExportTarget(raw, sessionId, config) {
+  if (typeof raw === 'string' && raw.trim().length > 0) {
+    const expanded = raw.startsWith('~')
+      ? path.join(homedir(), raw.slice(1).replace(/^[\\/]+/, ''))
+      : raw
+    return path.resolve(expanded)
+  }
+  const safe = String(sessionId ?? '').replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 128)
+  return path.join(resolveExportDir(config), `${safe || 'session'}.jsonl`)
+}
+
+/**
+ * 执行一次回迁导出：读 DSH 会话日志（sessionPersistence.readFrom）→ 反向折叠为
+ * Claude 可 resume JSONL → 写入目标文件。只读源会话、只写导出落点文件，绝不
+ * 改写 DSH 会话日志。会话不可读/无可导出内容时大声失败。
+ * @param ctx - Cordis 上下文。
+ * @param config - 插件配置。
+ * @param args - 工具参数 `{ sessionId, path? }`。
+ * @param signal - 可选 AbortSignal。
+ * @returns `{ sessionId, path, title, cwd, lines, turns, user, assistant, toolCalls, toolResults }`。
+ */
+export async function runExport(ctx, config, args, signal) {
+  const sp = ctx.get('sessionPersistence')
+  if (!sp || typeof sp.readFrom !== 'function') {
+    throw new Error('会话持久化服务（sessionPersistence）不可用：claude-move 回迁导出需要该服务')
+  }
+  const sessionId = typeof args?.sessionId === 'string' ? args.sessionId.trim() : ''
+  if (sessionId.length === 0) throw new Error('sessionId 必填：要回迁为 Claude jsonl 的 DSH 会话 id')
+  signal?.throwIfAborted()
+  let read
+  try {
+    read = await sp.readFrom(sessionId, 0)
+  } catch (err) {
+    throw new Error(`读取会话 ${sessionId} 失败（不存在或不可读）：${String((err && err.message) || err)}`)
+  }
+  const events = Array.isArray(read?.events) ? read.events : null
+  if (!events || events.length === 0) throw new Error(`会话 ${sessionId} 无日志事件，无法导出`)
+  const cwd = typeof read?.meta?.cwd === 'string' ? read.meta.cwd : null
+  const result = eventsToClaudeJsonl({ events, sessionId, cwd })
+  if (result.lines.length === 0) {
+    throw new Error(`会话 ${sessionId} 无可导出的对话内容（user/assistant/tool 轮次为空）`)
+  }
+  const target = resolveExportTarget(args?.path, sessionId, config)
+  await mkdir(path.dirname(target), { recursive: true })
+  await writeFile(target, result.lines.map((l) => l + '\n').join(''), 'utf8')
+  return {
+    sessionId,
+    path: target,
+    title: result.title ?? null,
+    cwd,
+    lines: result.lines.length,
+    turns: result.counts.turns,
+    user: result.counts.user,
+    assistant: result.counts.assistant,
+    toolCalls: result.counts.toolCalls,
+    toolResults: result.counts.toolResults,
+  }
+}
+
+/** claude_export 结果的模型可读摘要（中文）。 */
+export function renderExport(args, value) {
+  const lines = [
+    `已把 DSH 会话 ${value.sessionId} 回迁为 Claude 可 resume JSONL：`,
+    `- 输出文件：${value.path}`,
+    `- 轮次 ${value.turns}、用户消息 ${value.user}、助手消息 ${value.assistant}、` +
+      `工具调用 ${value.toolCalls}、工具结果 ${value.toolResults}（共 ${value.lines} 行）`,
+    value.title ? `- 标题：${value.title}` : null,
+    value.cwd ? `- 工作目录：${value.cwd}` : '- 工作目录：未知（Claude 打开时回退当前目录）',
+    'Claude Code 续接：claude --resume <输出文件>（或放入项目 .claude/projects 后 resume）。',
+  ].filter(Boolean)
+  return [{ type: 'text', text: lines.join('\n') }]
+}
+
+function makeExportTool(ctx, config) {
+  return defineTool({
+    name: 'claude_export',
+    description:
+      'Export a DSH session back into a resumable Claude Code JSONL transcript (user/assistant/tool turns, thinking and tool_use/tool_result pairing, file reference best-effort mapping). Read-only on the source session; writes one .jsonl target. Round-trips the same shape claude_scan/import_claude consume, so the export can be re-imported or resumed by Claude Code. ' +
+      '（把 DSH 会话回迁为 Claude Code 可 resume 的 JSONL transcript：覆盖 user/assistant/tool 轮次、thinking 与 tool_use/tool_result 配对、文件引用尽力映射。只读源会话，只写一个目标 .jsonl；与 import_claude 同构，可被再次导入或由 Claude Code resume。）',
+    parameters: {
+      sessionId: {
+        type: 'string',
+        required: true,
+        description: '要导出的 DSH 会话 id（会话列表/import_claude 结果中的 dshSessionId）。',
+      },
+      path: {
+        type: 'string',
+        description: `可选：目标 .jsonl 文件路径（支持 ~）。缺省写入 ${resolveExportDir(config)}/<sessionId>.jsonl。`,
+      },
+    },
+    output: { schema: exportResultSchema, render: renderExport },
+    async execute(args, exec) {
+      return runExport(ctx, config, args, exec?.signal)
+    },
+  })
+}
+
 // ── 个人信息搬移（F11-F13）：同步注入 + 技能 provider ────────────────────────
 
 /**
@@ -2001,6 +2146,29 @@ function registerCommandDefinitions(ctx, config, commands) {
       }
     },
   })
+
+  // F18：DSH 会话回迁 Claude 可 resume JSONL（双向迁移的导出方向）。
+  if (config.enableExport !== false) {
+    commands.register({
+      name: 'claude-export',
+      description: 'Export a DSH session into a resumable Claude Code JSONL transcript（把 DSH 会话回迁为 Claude Code 可 resume 的 JSONL transcript）',
+      input: { hint: '<DSH 会话 id> [目标 .jsonl 路径]' },
+      handler: async (invocation) => {
+        try {
+          const parts = invocation.rawInput.trim().split(/\s+/)
+          const sessionId = parts[0]
+          if (!sessionId) {
+            return { kind: 'error', text: '请提供要导出的 DSH 会话 id：/claude-export <sessionId> [path]' }
+          }
+          const value = await runExport(ctx, config, { sessionId, path: parts[1] }, invocation.signal)
+          const text = renderExport({}, value).map((b) => b.text).join('\n')
+          return { kind: 'success', text }
+        } catch (err) {
+          return { kind: 'error', text: 'claude-export 失败：' + String((err && err.message) || err) }
+        }
+      },
+    })
+  }
 }
 
 // ── 面板 JSON 路由（F16）：ctx.webServer 公开 seam ─────────────────────────────
@@ -2887,6 +3055,7 @@ export function apply(ctx, config = {}) {
   const state = makeClaudeState(config)
   ctx.tools.register(makeScanTool(ctx, config, state))
   ctx.tools.register(makeImportTool(ctx, config))
+  if (config.enableExport !== false) ctx.tools.register(makeExportTool(ctx, config))
   if (config.enableMove !== false) {
     const move = makeMoveTools(ctx, config, state)
     ctx.tools.register(move.detect)

package/lib/export.mjs

@@ -0,0 +1,261 @@
+// SPDX-License-Identifier: Apache-2.0
+// lib/export.mjs — DSH 会话事件 → Claude Code 可 resume JSONL（纯函数，零 DSH 依赖）。
+//
+// 与 convert.mjs 相对：convert.mjs 把外部 transcript（Claude/Codex/OpenCode/Hermes）
+// 折成 DSH 会话事件；本模块把 DSH 会话事件反向折叠为 Claude Code 可直接 --resume
+// 的 JSONL 行。覆盖 user/assistant/tool 轮次：
+//   user/message   → type:user（直连提问字符串，或内联 tool_result 的 user 消息）
+//   assistant/message → type:assistant（text→text、reasoning→thinking、tool-call→tool_use）
+//   tool/call      → 并入所属 assistant 消息的 tool_use 块（按 callId 去重，仅当
+//                    assistant content 未内联时补入）
+//   tool/result    → type:user（连续多条合并为一条 tool_result 数组，规范形状）
+//   session/title  → type:custom-title（时间线任意位置均可被 Claude 读取）
+// 文件引用（cwd）由调用方从会话 header 传入；映射不到时省略 cwd（Claude 打开时
+// 回退当前目录）。tool_use 参数经 JSON 解析还原为对象；解析失败保留原文（尽力映射）。
+
+import { randomUUID } from 'node:crypto'
+
+/** Claude Code 可 resume 的 JSONL 版本字符串。 */
+export const CLAUDE_JSONL_VERSION = '2.0.0'
+
+/**
+ * 把 DSH tool-call 的 arguments（JSON 字符串）还原为 Claude tool_use 的 input 对象。
+ * 非字符串原样返回；JSON 字符串解析失败时保留原文（不静默丢参数）。
+ * @param argumentsText - DSH tool-call.arguments 字段。
+ * @returns input 对象或原值。
+ */
+function parseToolInput(argumentsText) {
+  if (typeof argumentsText !== 'string') return argumentsText ?? {}
+  try {
+    const parsed = JSON.parse(argumentsText)
+    return parsed !== null && typeof parsed === 'object' ? parsed : argumentsText
+  } catch {
+    // 非 JSON 参数（自由格式字符串）：保留原文，Claude 侧仍可读。
+    return argumentsText
+  }
+}
+
+/**
+ * DSH assistant content block → Claude assistant content block。
+ * @param block - DSH content block（text/reasoning/tool-call）。
+ * @returns Claude block（text/thinking/tool_use）或 null。
+ */
+function mapAssistantBlock(block) {
+  if (!block) return null
+  if (block.type === 'text' && typeof block.text === 'string') return { type: 'text', text: block.text }
+  if (block.type === 'reasoning' && typeof block.text === 'string') return { type: 'thinking', thinking: block.text }
+  if (block.type === 'tool-call') {
+    return { type: 'tool_use', id: block.id, name: block.name, input: parseToolInput(block.arguments) }
+  }
+  return null
+}
+
+/** 提取纯文本（content 为字符串或 [{type:'text',text}] 数组）。 */
+function extractText(content) {
+  if (typeof content === 'string') return content
+  if (!Array.isArray(content)) return ''
+  return content
+    .filter((b) => b && b.type === 'text' && typeof b.text === 'string')
+    .map((b) => b.text)
+    .join('\n')
+}
+
+/** DSH tool-result 内容 → Claude tool_result content 数组（仅 text 块）。 */
+function mapToolResultContent(content) {
+  if (Array.isArray(content)) {
+    const blocks = content.map(mapAssistantBlock).filter(Boolean)
+    return blocks.length > 0 ? blocks : [{ type: 'text', text: '' }]
+  }
+  if (typeof content === 'string') return [{ type: 'text', text: content }]
+  return [{ type: 'text', text: String(content ?? '') }]
+}
+
+/**
+ * 从 user/message 的 content 里提取 tool_result 块（部分会话把工具结果作为
+ * user/message 的 content 内联，而非独立 tool/result 事件）。
+ * @param content - user/message 的 content。
+ * @returns Claude tool_result 块数组。
+ */
+function extractInlineToolResults(content) {
+  if (!Array.isArray(content)) return []
+  const blocks = []
+  for (const b of content) {
+    if (b && b.type === 'tool-result' && typeof b.toolCallId === 'string') {
+      blocks.push({
+        type: 'tool_result',
+        tool_use_id: b.toolCallId,
+        content: mapToolResultContent(b.content),
+        is_error: b.isError === true,
+      })
+    }
+  }
+  return blocks
+}
+
+/** DSH 事件时间（毫秒 epoch）→ ISO 字符串；缺失回退当前时间。 */
+function isoTime(ev) {
+  return typeof ev?.time === 'number' ? new Date(ev.time).toISOString() : new Date().toISOString()
+}
+
+/**
+ * 构造一条 Claude JSONL 记录（与 Claude Code 自身 transcript 的信封一致）。
+ * @param fields - `{ type, message?, sessionId, cwd?, timestamp }`；`custom-title`
+ *   记录用顶层 `customTitle` 字段而非 message。
+ * @returns 记录对象。
+ */
+function makeRecord({ type, message, customTitle, sessionId, cwd, timestamp }) {
+  const rec = {
+    parentUuid: null,
+    isSidechain: false,
+    userType: 'user',
+    ...(typeof cwd === 'string' && cwd.length > 0 ? { cwd } : {}),
+    sessionId,
+    version: CLAUDE_JSONL_VERSION,
+    gitBranch: null,
+    type,
+    ...(message !== undefined ? { message } : {}),
+    ...(customTitle !== undefined ? { customTitle } : {}),
+    uuid: randomUUID(),
+    timestamp: timestamp ?? new Date().toISOString(),
+  }
+  return rec
+}
+
+/**
+ * 把 DSH 会话事件反向折叠为 Claude Code 可 resume 的 JSONL 记录。
+ * 纯函数：不读写文件，输入事件数组，输出记录对象数组与 JSONL 行。
+ * @param options - `{ events, sessionId, cwd, model }`；model 为 assistant
+ *   消息缺省模型名（事件自带 source.model 时优先）。
+ * @returns `{ records, lines, title, counts }`：
+ *   counts 为 `{ turns, user, assistant, toolCalls, toolResults }`。
+ */
+export function eventsToClaudeJsonl({ events, sessionId, cwd, model } = {}) {
+  const list = Array.isArray(events) ? events : []
+  const records = []
+  let title = null
+
+  for (const ev of list) {
+    if (ev?.type === 'session/title' && typeof ev.data?.title === 'string' && ev.data.title.trim().length > 0) {
+      title = ev.data.title.trim()
+    }
+  }
+
+  // 标题先行：Claude 在时间线任意位置读到 custom-title 均视为本会话标题。
+  if (title) {
+    records.push(makeRecord({ type: 'custom-title', customTitle: title, sessionId, cwd }))
+  }
+
+  let i = 0
+  while (i < list.length) {
+    const ev = list[i]
+    const type = ev?.type
+    const ts = isoTime(ev)
+
+    if (type === 'user/message') {
+      const inline = extractInlineToolResults(ev.data?.content)
+      if (inline.length > 0) {
+        records.push(makeRecord({
+          type: 'user', message: { role: 'user', content: inline }, sessionId, cwd, timestamp: ts,
+        }))
+      } else {
+        const text = extractText(ev.data?.content)
+        if (text.length > 0) {
+          records.push(makeRecord({
+            type: 'user', message: { role: 'user', content: text }, sessionId, cwd, timestamp: ts,
+          }))
+        }
+      }
+      i++
+      continue
+    }
+
+    if (type === 'assistant/message') {
+      const content = Array.isArray(ev.data?.message?.content) ? ev.data.message.content : []
+      const blocks = []
+      for (const b of content) {
+        const mapped = mapAssistantBlock(b)
+        if (mapped) blocks.push(mapped)
+      }
+      // 紧随其后的 tool/call 事件：仅当 assistant content 未内联同 id tool_use 时
+      // 补入（claude-move 导入的会话 content 已内联，这里保证其余会话形状也可导出）。
+      let j = i + 1
+      while (j < list.length && list[j]?.type === 'tool/call') {
+        const tc = list[j]
+        const callId = tc.data?.callId
+        if (typeof callId === 'string' && !blocks.some((b) => b.type === 'tool_use' && b.id === callId)) {
+          blocks.push({
+            type: 'tool_use',
+            id: callId,
+            name: tc.data?.name ?? 'unknown',
+            input: parseToolInput(tc.data?.arguments),
+          })
+        }
+        j++
+      }
+      if (blocks.length > 0) {
+        const modelName = ev.data?.message?.source?.model ?? model ?? null
+        records.push(makeRecord({
+          type: 'assistant',
+          message: {
+            id: randomUUID(),
+            role: 'assistant',
+            ...(modelName ? { model: modelName } : {}),
+            content: blocks,
+          },
+          sessionId, cwd, timestamp: ts,
+        }))
+      }
+      i = j
+      continue
+    }
+
+    if (type === 'tool/result') {
+      // 连续 tool/result 合并为一条 user 消息（Claude 规范：一步的工具结果并入一条）。
+      const blocks = []
+      while (i < list.length && list[i]?.type === 'tool/result') {
+        const tr = list[i]
+        const block = tr.data?.message?.content?.[0]
+        if (block && typeof block.toolCallId === 'string') {
+          blocks.push({
+            type: 'tool_result',
+            tool_use_id: block.toolCallId,
+            content: mapToolResultContent(block.content),
+            is_error: block.isError === true,
+          })
+        }
+        i++
+      }
+      if (blocks.length > 0) {
+        records.push(makeRecord({
+          type: 'user', message: { role: 'user', content: blocks }, sessionId, cwd, timestamp: ts,
+        }))
+      }
+      continue
+    }
+
+    i++
+  }
+
+  const counts = {
+    turns: list.filter((e) => e?.type === 'turn/start').length,
+    user: records.filter((r) => r.type === 'user').length,
+    assistant: records.filter((r) => r.type === 'assistant').length,
+    toolCalls: records.reduce(
+      (n, r) => n + (r.type === 'assistant' ? (r.message.content ?? []).filter((b) => b.type === 'tool_use').length : 0),
+      0,
+    ),
+    toolResults: records.reduce(
+      (n, r) => n + (r.type === 'user' && Array.isArray(r.message.content)
+        ? r.message.content.filter((b) => b.type === 'tool_result').length
+        : 0),
+      0,
+    ),
+  }
+
+  return {
+    records,
+    lines: records.map((r) => JSON.stringify(r)),
+    title,
+    counts,
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-claude-move",
   "description": "Four-source migration wizard: copy Claude Code, Codex, OpenCode and Hermes sessions, memories, skills, instructions and slash commands into DeepSeek Harness as resumable sessions — copy-only, approval-gated, idempotent",
-  "version": "0.2.6",
+  "version": "0.3.0",
   "type": "module",
   "main": "./index.mjs",
   "exports": {
@@ -85,7 +85,7 @@
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/dsh-tools": ">=0.1.0-rc.8 <0.2.0",
-    "@deepseek-ai/schemastery": ">=3.0.0"
+    "@deepseek-ai/schemastery": "^3.18.0"
   },
   "scripts": {
     "test": "node --test \"test/*.test.mjs\"",