dsh-claude-compat 0.6.2 → 0.8.0

package/README.md

@@ -6,17 +6,53 @@
 
 <p align="center">
   <a href="README.zh-CN.md"><img src="https://img.shields.io/badge/🌐_简体中文-点我阅读中文-red?style=for-the-badge" alt="简体中文"></a>
-</p>
-
-<p align="center">
-  <img src="https://img.shields.io/badge/version-0.6.2-blue?style=flat-square" alt="Version">
-  <img src="https://img.shields.io/badge/node-%3E%3D20-green?style=flat-square&logo=node.js&logoColor=white" alt="Node">
+  <img src="https://img.shields.io/npm/dm/dsh-claude-compat?style=flat-square&label=downloads/month&color=brightgreen" alt="npm downloads/month">
+  <img src="https://img.shields.io/npm/dt/dsh-claude-compat?style=flat-square&label=total%20downloads&color=blue" alt="npm total downloads">
+  <img src="https://img.shields.io/badge/version-0.8.0-blue?style=flat-square" alt="Version">
   <img src="https://img.shields.io/badge/license-MIT-orange?style=flat-square" alt="License">
 </p>
 
-<p align="center">DeepSeek Harness plugin that bridges Claude Code's <code>.claude/</code> directory into DSH natively — reuse your skills, slash commands, rules, agents, hooks, and MCP servers with zero migration.</p>
+> **Reuse your entire Claude Code setup in DSH — zero migration.**
+> skills, commands, rules, agents, hooks, MCP — install and they just work. Nothing to reconfigure.
+
+---
+
+## The 10-second pitch
+
+You've already built up a solid `.claude/` in Claude Code — skills, slash commands, rules, agents, hooks, MCP servers. Moving to **DSH (DeepSeek Harness)** shouldn't mean rebuilding all of it.
+
+**dsh-claude-compat is that bridge.** It carries your `.claude/` directories **verbatim into DSH** — everything works immediately. Install once, and both sides share one config: change it in one place, it updates in both.
+
+```bash
+dsh plugin --profile web add dsh-claude-compat@latest
+dsh web
+```
+
+Done. Your skills show up in the `/` menu, rules inject into every new session, and you can invoke agents with `/agent-name` — all inside DSH, exactly like Claude Code.
+
+**Or let DSH install it itself (recommended):** copy this line to DSH — it reads the skill, installs, and verifies:
+
+> Read https://github.com/biedongbin/dsh-claude-compat/blob/main/.claude/skills/install-dsh-compat/SKILL.md and install the dsh-claude-compat plugin following its steps.
+
+> ⭐ Find this useful? [Give it a star](https://github.com/biedongbin/dsh-claude-compat) — it keeps us improving and helps more people discover it.
+
+---
 
-## What it does
+## What it brings over — at a glance
+
+| Your Claude Code asset | Becomes in DSH | How to use it |
+|---|---|---|
+| `skills/**/SKILL.md` | DSH skill (lazy-loaded) | `/skill-name`, the `skill` tool, and the model-visible catalog |
+| `commands/*.md` | DSH skill (user-invocable) | `/command-name` in the slash menu |
+| `rules/*.md` | message-stream injection (same channel Claude uses) | auto-applies to every new session |
+| `agents/*.md` | delegation-shim skill | invoke `/agent-name` with its persona |
+| `.claude/settings.json` hooks | Pre/PostToolUse + UserPromptSubmit bridged | commands, permissions, blocks behave as before |
+| `<root>/.mcp.json` | `dsh-mcp-client` instances | stdio / streamable-http auto-translated |
+| `~/.claude/plugins` | DSH skill (managed via `/cc-plugin`) | installed plugin skills work too |
+
+Both the project `.claude/` and the user-level `~/.claude/` are read. Same-name entries dedupe by fixed priority: **project `.claude` > DSH native > `~/.claude`** — a project skill always wins over other copies, and a user skill never overrides a DSH-native one. `CLAUDE.md` / `AGENTS.md` are handled by DSH's built-in `dsh-agent-instructions` — **this plugin never touches them**.
+
+## What it does (implementation detail)
 
 | `.claude/` path | Mechanism | Behavior |
 |---|---|---|
@@ -46,6 +82,8 @@ Installing this plugin adds three management skills to the catalog:
 | `/cc-plugin` | Full Claude Code plugin management: `list`, `install <name>[@marketplace]`, `uninstall`, `enable`, `disable`, `update [name]`, `search <term>`, `marketplace list\|add\|remove\|update`. One-shot syntax `/cc-plugin <name>@<marketplace>` installs directly. Engine: the `claude` CLI when available, otherwise a built-in fallback (direct JSON + git, with timestamped backups of every file it touches). All state stays in Claude-native locations (`~/.claude/plugins`, `~/.claude/settings.json` `enabledPlugins`) so Claude Code and DSH read the same truth. |
 | `/reload-cc-plugins` | Hot-reload the skill catalog: drop cached provider lists and notify observers so newly installed/removed skills appear in the **current session** — no restart, no new session. |
 | `/reload-skills` | Alias of `/reload-cc-plugins`. |
+| `/cc-export` | Export DSH-native skills (`.dsh/skills`) into Claude Code `.claude/skills/<name>/SKILL.md` with frontmatter preserved. `list` / `export [--overwrite] [--target]`. |
+| `/cc-resume` | List Claude Code conversation sessions for the current project (`~/.claude/projects/`) and import any of them into DSH with full user/assistant/tool history. Imported sessions appear in the DSH session list titled `cc: <preview>` and resume like native ones. `list` / `import <sessionId>` / `--limit-turns N` for huge sessions. |
 
 Typical loop: `/cc-plugin install ralph-loop@claude-plugins-official` → `/reload-cc-plugins` → new skills visible immediately. Plugin-shipped MCP servers still require a DSH restart (process-lifetime mount).
 
@@ -109,6 +147,20 @@ Restart DSH (`dsh web`). Done — skills show up in `/`, rules are injected into
 
 ## Troubleshooting
 
+### Known limitation: `/cc-resume` via the skill tool
+
+In some DSH runtime configurations the `skill` tool resolves in an agent-scoped
+layer where globally registered providers are not visible — the invocation
+returns `skill "cc-resume" is unknown or no longer available` even though the
+catalog lists it. This is a DSH runtime layering behavior, not a plugin bug.
+The skill body only instructs the model to run the CLI, which is always
+available:
+
+```bash
+node node_modules/dsh-claude-compat/scripts/cc-resume.mjs list
+node node_modules/dsh-claude-compat/scripts/cc-resume.mjs import <sessionId>
+```
+
 **DSH won't start back up after a restart / port 3080 stuck.** Old process still holding the port (symptom: `EADDRINUSE` in logs). Use the bundled restart script — it waits for a clean stop, falls back to SIGKILL, and verifies the port before reporting success:
 
 ```bash
@@ -121,8 +173,14 @@ The script also re-applies the idempotent `dsh-terminal-bash` prompt patch, whic
 
 **Installed a plugin via `/cc-plugin` but its skills don't show.** Run `/reload-cc-plugins`. Still missing → restart DSH (plugin-shipped MCP servers always need a restart).
 
+**`/cc-resume` import fails on compression.** The importer needs the `zstd` binary (macOS: `brew install zstd`; most Linux images ship it).
+
 **`/cc-plugin` reports "claude CLI unavailable".** The fallback engine handles install/enable/disable; for marketplace add/update, install Claude Code (`npm install -g @anthropic-ai/claude-code`) or manage marketplaces from Claude Code directly.
 
+## Release notes
+
+- **[Changelog](CHANGELOG.md) ([简体中文](CHANGELOG.zh-CN.md))** — release history from 0.1.0 to the latest version.
+
 ## Acknowledgments
 
 - [Linux.do](https://linux.do) — community
@@ -133,6 +191,12 @@ The script also re-applies the idempotent `dsh-terminal-bash` prompt patch, whic
 
 [MIT](LICENSE)
 
+## 📈 NPM Downloads
+
+![NPM Downloads](.github/assets/downloads.svg)
+
+[Data: api.npmjs.org](https://www.npmjs.com/package/dsh-claude-compat) · [npmtrends](https://npmtrends.com/dsh-claude-compat/)
+
 ## ⭐ Star History
 
 If this project helps you, please give it a ⭐ — it motivates us to keep improving.

package/README.zh-CN.md

@@ -6,17 +6,53 @@
 
 <p align="center">
   <a href="README.md"><img src="https://img.shields.io/badge/🌐_English-Click_me-red?style=for-the-badge" alt="English"></a>
-</p>
-
-<p align="center">
-  <img src="https://img.shields.io/badge/version-0.6.2-blue?style=flat-square" alt="Version">
-  <img src="https://img.shields.io/badge/node-%3E%3D20-green?style=flat-square&logo=node.js&logoColor=white" alt="Node">
+  <img src="https://img.shields.io/npm/dm/dsh-claude-compat?style=flat-square&label=downloads/month&color=brightgreen" alt="npm downloads/month">
+  <img src="https://img.shields.io/npm/dt/dsh-claude-compat?style=flat-square&label=total%20downloads&color=blue" alt="npm total downloads">
+  <img src="https://img.shields.io/badge/version-0.8.0-blue?style=flat-square" alt="Version">
   <img src="https://img.shields.io/badge/license-MIT-orange?style=flat-square" alt="License">
 </p>
 
-<p align="center">DeepSeek Harness 插件：把 Claude Code 的 <code>.claude/</code> 目录原生桥接进 DSH —— skills、斜杠命令、rules、agents、hooks、MCP 服务器零迁移直接复用。</p>
+> **在 DSH 里，直接用回你整套 Claude Code 配置——零迁移。**
+> skills、命令、规则、agents、hooks、MCP，装上就能用，什么都不用重配。
+
+---
+
+## 10 秒速览
+
+你已经在 Claude Code 里攒了一整套趁手的 `.claude/`——skills、斜杠命令、rules、agents、hooks、MCP servers。换到 **DSH (DeepSeek Harness)** 时，你不想把这些全部重新搭一遍。
+
+**dsh-claude-compat 就是那座桥。** 它把你的 `.claude/` 目录**原样搬进 DSH**，所有能力即刻生效。装一次，两边的配置从此共用一份，改一处两边都变。
+
+```bash
+dsh plugin --profile web add dsh-claude-compat@latest
+dsh web
+```
+
+搞定。你的 skills 出现在 `/` 菜单里，规则注入每个新会话，agent 能用 `/agent-name` 调起——全都在 DSH 里，跟 Claude Code 里一模一样。
+
+**或用 DSH 自己装（推荐）**：复制下面这句给 DSH，它会读 skill、自动安装并验证：
+
+> 请阅读 https://github.com/biedongbin/dsh-claude-compat/blob/main/.claude/skills/install-dsh-compat/SKILL.md 并按步骤安装 dsh-claude-compat 插件。
+
+> ⭐ 觉得好用？[点这里给个 star](https://github.com/biedongbin/dsh-claude-compat)——它让我们持续改进，也帮更多人找到这个插件。
+
+---
 
-## 功能
+## 一键带过来的东西
+
+| Claude Code 里的东西 | 在 DSH 里变成 | 怎么用 |
+|---|---|---|
+| `skills/**/SKILL.md` | DSH skill（目录可加载） | `/skill-name`、`skill` 工具、模型目录都能看到 |
+| `commands/*.md` | DSH skill（用户可调） | `/command-name` 出现在斜杠菜单 |
+| `rules/*.md` | 消息流注入（同 Claude 的 `prependUserContext` 通道） | 每个新会话自动生效 |
+| `agents/*.md` | 委派 shim skill | `/agent-name` 按角色调起 |
+| `.claude/settings.json` hooks | Pre/PostToolUse + UserPromptSubmit 桥接 | 命令、权限、拦截照旧 |
+| `<root>/.mcp.json` | `dsh-mcp-client` 实例 | stdio / streamable-http 自动翻译 |
+| `~/.claude/plugins` | DSH skill（`/cc-plugin` 管理） | 安装的插件技能一并可用 |
+
+同一套目录，项目 `.claude/` 和用户级 `~/.claude/` **都会读**。同名项按固定优先级去重：**项目 `.claude` > DSH 原生 > `~/.claude`**——项目技能永远覆盖其他副本，用户技能永远不覆盖 DSH 原生。`CLAUDE.md` / `AGENTS.md` 由 DSH 内置的 `dsh-agent-instructions` 处理，**本插件不碰**。
+
+## 功能（实现细节）
 
 | `.claude/` 路径 | 机制 | 行为 |
 |---|---|---|
@@ -46,6 +82,8 @@
 | `/cc-plugin` | 完整 Claude Code 插件管理：`list`、`install <名>[@市场]`、`uninstall`、`enable`、`disable`、`update [名]`、`search <词>`、`marketplace list\|add\|remove\|update`。一键语法 `/cc-plugin <名>@<市场>` 直接安装。引擎：有 `claude` CLI 时优先调度，否则内置降级（直接操作 JSON + git，被改文件自动时间戳备份）。状态全部落在 Claude 原生位置（`~/.claude/plugins`、`~/.claude/settings.json` 的 `enabledPlugins`），Claude Code 与 DSH 读同一份真相。 |
 | `/reload-cc-plugins` | 热重载 skill catalog：清缓存并广播变更，新装/卸载的插件技能**当前会话**立即可见 —— 无需重启、无需新会话。 |
 | `/reload-skills` | `/reload-cc-plugins` 的别名。 |
+| `/cc-export` | 把 DSH 原生 skill（`.dsh/skills`）导出为 Claude Code `.claude/skills/<name>/SKILL.md`，frontmatter 保留。`list` / `export [--overwrite] [--target]`。 |
+| `/cc-resume` | 列出当前项目的 Claude Code 会话（`~/.claude/projects/`），并把任意一个导入 DSH —— 完整 user/assistant/工具历史。导入会话以 `cc: <预览>` 标题出现在 DSH 会话列表，可像原生会话一样恢复。`list` / `import <sessionId>` / `--limit-turns N`（大会话只导最近 N 轮）。 |
 
 典型闭环：`/cc-plugin install ralph-loop@claude-plugins-official` → `/reload-cc-plugins` → 新技能立即可见。插件自带的 MCP 服务器仍需重启 DSH（进程级挂载）。
 
@@ -109,6 +147,15 @@ dsh plugin --profile web add github:biedongbin/dsh-claude-compat
 
 ## 故障排查
 
+### 已知限制：通过 skill 工具调用 `/cc-resume`
+
+部分 DSH 运行时配置下，`skill` 工具在 agent scoped 层解析，看不到全局层注册的 provider —— 即使 catalog 列表里有，调用仍返回 `skill "cc-resume" is unknown or no longer available`。这是 DSH 运行时分层行为，非插件缺陷。skill 本体只是指导模型跑 CLI，CLI 始终可用：
+
+```bash
+node node_modules/dsh-claude-compat/scripts/cc-resume.mjs list
+node node_modules/dsh-claude-compat/scripts/cc-resume.mjs import <sessionId>
+```
+
 **重启后 DSH 起不来 / 3080 端口卡死。** 旧进程占着端口（日志特征 `EADDRINUSE`）。用自带重启脚本 —— 干净等待停止、SIGKILL 兜底、探活端口后才报成功：
 
 ```bash
@@ -121,8 +168,14 @@ bash scripts/dsh-restart.sh --no-patch   # 跳过 prompt 补丁，只重启
 
 **`/cc-plugin` 装了插件但技能没出现。** 先 `/reload-cc-plugins`。仍没有 → 重启 DSH（插件自带 MCP 服务器必须重启）。
 
+**`/cc-resume` 导入时报压缩错误。** 导入器需要 `zstd` 二进制（macOS：`brew install zstd`；多数 Linux 镜像自带）。
+
 **`/cc-plugin` 提示 claude CLI 不可用。** 降级引擎已覆盖 install/enable/disable；marketplace add/update 需要安装 Claude Code（`npm install -g @anthropic-ai/claude-code`）或直接在 Claude Code 里管理市场。
 
+## Release notes
+
+- **[更新日志](CHANGELOG.zh-CN.md)（[English](CHANGELOG.md)）** — 0.1.0 至最新版本的完整发布历史。
+
 ## 社区鸣谢
 
 - [Linux.do](https://linux.do) —— 社区
@@ -133,6 +186,12 @@ bash scripts/dsh-restart.sh --no-patch   # 跳过 prompt 补丁，只重启
 
 [MIT](LICENSE)
 
+## 📈 NPM 下载趋势
+
+![NPM Downloads](.github/assets/downloads.svg)
+
+[Data: api.npmjs.org](https://www.npmjs.com/package/dsh-claude-compat) · [npmtrends](https://npmtrends.com/dsh-claude-compat/)
+
 ## ⭐ Star History
 
 如果这个项目对你有帮助，请给个 ⭐ —— 这是我们持续改进的动力。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-claude-compat",
-  "version": "0.6.2",
+  "version": "0.8.0",
   "description": "DeepSeek Harness plugin: bridge Claude Code's .claude/ directories (project and ~/.claude: skills, commands, rules) into DSH native skill registry and message-stream rules injection.",
   "type": "module",
   "main": "src/index.js",

package/scripts/cc-export.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+// cc-export.mjs — export DSH-native skills (.dsh/skills) into Claude Code
+// .claude/skills format, closing the loop: DSH → Claude Code.
+//
+//   node cc-export.mjs list                     [--cwd <dir>]
+//   node cc-export.mjs export [--cwd <dir>]     [--target <dir>] [--overwrite]
+//
+// "list" prints one line per DSH skill found under <projectRoot>/.dsh/skills.
+//
+// "export" rewrites each DSH skill into <projectRoot>/.claude/skills/<name>/SKILL.md
+// (Claude Code convention: one directory per skill, containing SKILL.md with
+// YAML frontmatter name/description and the markdown body). DSH skill names are
+// already kebab-case, which is valid for Claude Code too. Existing files are
+// skipped unless --overwrite.
+//
+// DSH .dsh/skills layout mirrors the filesystem provider: <name>/SKILL.md under
+// the .dsh/skills root. Frontmatter is the same YAML dialect as Claude Code
+// (name, description, whenToUse), so a DSH skill round-trips with no body edit.
+
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { findProjectRootSync, parseFrontmatter, stringField } from '../src/lib.js';
+
+// ---- helpers ---------------------------------------------------------------
+
+function walkSkills(root) {
+  // Returns [{ name, dir, file }] for every SKILL.md directly under root/<name>/.
+  const out = [];
+  let entries;
+  try { entries = readdirSync(root, { withFileTypes: true }); } catch { return out; }
+  for (const e of entries) {
+    if (!e.isDirectory() || e.name.startsWith('.')) continue;
+    const file = join(root, e.name, 'SKILL.md');
+    if (!existsSync(file)) continue;
+    out.push({ name: e.name, dir: join(root, e.name), file });
+  }
+  out.sort((a, b) => a.name.localeCompare(b.name));
+  return out;
+}
+
+// YAML value emitter: multiline strings become literal blocks (readable),
+// everything else is double-quoted. Multiline frontmatter is otherwise escaped
+// into a single `\n`-quoted line, which parses but loses readability.
+function yamlValue(v) {
+  if (typeof v === 'string' && v.includes('\n')) {
+    return `|-\n${v.split('\n').map((l) => `  ${l}`).join('\n')}`;
+  }
+  return JSON.stringify(v);
+}
+
+function dshSkillsDir(cwd, markers) {
+  const root = findProjectRootSync(cwd, markers);
+  if (root === undefined) return { root: undefined, dir: undefined };
+  return { root, dir: join(root, '.dsh', 'skills') };
+}
+
+function claudeSkillsDir(root) {
+  return join(root, '.claude', 'skills');
+}
+
+// ---- CLI -------------------------------------------------------------------
+
+const invokedDirectly = process.argv[1]?.endsWith('cc-export.mjs') ?? false;
+if (invokedDirectly) {
+const [cmd, ...rest] = process.argv.slice(2);
+const flag = (name) => {
+  const i = rest.indexOf(`--${name}`);
+  return i >= 0 ? rest[i + 1] : undefined;
+};
+const cwd = flag('cwd') ?? process.cwd();
+const markers = ['.git'];
+
+if (cmd === 'list') {
+  const { root, dir } = dshSkillsDir(cwd, markers);
+  if (root === undefined) { console.log('No project root found (no .git)'); process.exit(0); }
+  const skills = walkSkills(dir);
+  if (skills.length === 0) { console.log(`No DSH skills in ${dir}`); process.exit(0); }
+  for (const s of skills) console.log(`${s.name}\t${relative(root, s.file)}`);
+  console.log(`\n${skills.length} skill(s). Export with: node cc-export.mjs export --cwd ${cwd}`);
+} else if (cmd === 'export') {
+  const { root, dir } = dshSkillsDir(cwd, markers);
+  if (root === undefined) { console.error('No project root found (no .git)'); process.exit(1); }
+  const skills = walkSkills(dir);
+  if (skills.length === 0) { console.log(`No DSH skills to export in ${dir}`); process.exit(0); }
+  const overwrite = flag('overwrite') !== undefined;
+  const targetBase = flag('target') ?? claudeSkillsDir(root);
+  let written = 0, skipped = 0, failed = 0;
+  for (const s of skills) {
+    const raw = readFileSync(s.file, 'utf8');
+    const parsed = parseFrontmatter(raw);
+    // Preserve original frontmatter keys; ensure name/description present for
+    // Claude Code. Body-only files get a synthesized frontmatter.
+    const data = parsed?.data ?? {};
+    const body = parsed?.body ?? raw.trim();
+    const name = stringField(data, 'name') ?? s.name;
+    const description = stringField(data, 'description')
+      ?? `Imported from DSH skill "${s.name}"`;
+    const fm = { ...data, name, description };
+    if (!data.whenToUse) fm.whenToUse = 'Exported from DSH via cc-export.';
+    const yaml = Object.entries(fm)
+      .map(([k, v]) => `${k}: ${yamlValue(v)}`)
+      .join('\n');
+    const targetDir = join(targetBase, s.name);
+    const targetFile = join(targetDir, 'SKILL.md');
+    if (existsSync(targetFile) && overwrite === false) {
+      console.log(`skip (exists, no --overwrite): ${targetFile}`);
+      skipped += 1;
+      continue;
+    }
+    try {
+      mkdirSync(targetDir, { recursive: true });
+      writeFileSync(targetFile, `---\n${yaml}\n---\n\n${body}\n`);
+      written += 1;
+    } catch (error) {
+      console.error(`fail: ${targetFile} — ${error?.message ?? error}`);
+      failed += 1;
+    }
+  }
+  console.log(`exported ${written} skill(s), skipped ${skipped}, failed ${failed} → ${targetBase}`);
+  if (written > 0) console.log('Claude Code will pick them up under .claude/skills/ — restart Claude Code or reload.');
+} else {
+  console.error('usage: cc-export.mjs list|export [--cwd dir] [--target dir] [--overwrite]');
+  process.exit(2);
+}
+}

package/scripts/cc-resume.mjs

@@ -0,0 +1,278 @@
+#!/usr/bin/env node
+// cc-resume.mjs — list and import Claude Code sessions into DeepSeek Harness.
+//
+//   node cc-resume.mjs list   [--cwd <dir>] [--limit N]
+//   node cc-resume.mjs import <sessionId> [--cwd <dir>] [--limit-turns N]
+//
+// "list" prints one line per Claude session found under
+// ~/.claude/projects/<munged-cwd>/: id, date, message count, first-user-text
+// preview, and whether it is already imported into DSH.
+//
+// "import" translates a Claude Code session JSONL into a DSH event-sourced
+// session log (~/.dsh/sessions/<munged>/session-cc-<id>/session.jsonl.zstd)
+// so `dsh --resume` / the Web GUI can open the conversation with full
+// history: user messages, assistant text, tool calls and results.
+//
+// Translation rules:
+//   Claude user message      → DSH user/message + turn + step wrapper
+//   Claude assistant text    → DSH assistant/message (content block "text")
+//   Claude thinking          → skipped (DSH reasoning blocks are stream chunks;
+//                              reconstructed reasoning would confuse replay)
+//   Claude tool_use          → DSH tool/call
+//   Claude tool_result       → DSH tool/result (as a tool-sourced user message)
+//   Sidechain (subagent)     → skipped; only the main thread is imported
+//
+// The imported session gets `delegationDepth: 0`, preset `standard`, and a
+// session/title event ("cc: <first user text>") so it is recognizable in the
+// DSH session list. Idempotent: importing twice reuses the same target dir
+// (events are truncated and rewritten).
+
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { zstdFramesSync } from './zstd-compat.mjs';
+
+// ── helpers ──────────────────────────────────────────────────────────────────
+
+function munge(dir) {
+  return dir.replaceAll('/', '-');
+}
+
+function claudeProjectDir(cwd) {
+  return join(homedir(), '.claude', 'projects', munge(cwd));
+}
+
+function dshSessionsDir(cwd) {
+  // DSH munges /Users/x/proj → --Users-x-proj-- (leading '-' for the empty
+  // segment before the absolute path's first '/'), unlike Claude's
+  // -Users-x-proj (no leading '-'). Both keep a trailing '-'.
+  return join(homedir(), '.dsh', 'sessions', `-${munge(cwd)}--`);
+}
+
+function targetSessionDir(sessionId, cwd) {
+  return join(dshSessionsDir(cwd), `session-cc-${sessionId}`);
+}
+
+/** Parse a Claude JSONL into ordered main-thread turns. */
+export function parseClaudeSession(path) {
+  const turns = [];
+  let pendingAssistantBlocks = null; // blocks of the assistant message in flight
+  let title = null;
+  let createdAt = null;
+  let cwd = null;
+  let msgCount = 0;
+  for (const line of readFileSync(path, 'utf8').split('\n')) {
+    if (line.trim() === '') continue;
+    let d;
+    try { d = JSON.parse(line); } catch { continue; }
+    if (d.cwd && !cwd) cwd = d.cwd;
+    if (d.timestamp && !createdAt) createdAt = Date.parse(d.timestamp);
+    if (d.type === 'custom-title' && d.title) title = d.title;
+    if (d.isSidechain) continue;
+    if (d.type === 'user') {
+      const content = d.message?.content;
+      // Tool-result-only user messages continue the pending assistant turn;
+      // only a real text message closes it and starts a new turn.
+      const isToolResultOnly = Array.isArray(content) && content.length > 0
+        && content.every((b) => b.type === 'tool_result');
+      if (isToolResultOnly) {
+        for (const b of content) pendingAssistantBlocks?.toolResults.push(b);
+        continue;
+      }
+      if (pendingAssistantBlocks) { flushAssistant(); }
+      const text = typeof content === 'string'
+        ? content
+        : Array.isArray(content)
+          ? content.filter((b) => b.type === 'text').map((b) => b.text).join('\n')
+          : '';
+      if (text.trim() === '') continue;
+      turns.push({ kind: 'user', text, time: Date.parse(d.timestamp) || Date.now() });
+      msgCount += 1;
+    } else if (d.type === 'assistant') {
+      const content = d.message?.content ?? [];
+      if (!Array.isArray(content)) continue;
+      if (!pendingAssistantBlocks) pendingAssistantBlocks = { text: [], toolUses: [], toolResults: [], time: Date.parse(d.timestamp) || Date.now() };
+      else if (pendingAssistantBlocks.toolUses.length > 0 && pendingAssistantBlocks.toolResults.length >= pendingAssistantBlocks.toolUses.length) flushAssistant(),
+        pendingAssistantBlocks = { text: [], toolUses: [], toolResults: [], time: Date.parse(d.timestamp) || Date.now() };
+      for (const b of content) {
+        if (b.type === 'text' && b.text.trim() !== '') pendingAssistantBlocks.text.push(b.text);
+        if (b.type === 'tool_use') pendingAssistantBlocks.toolUses.push(b);
+      }
+      msgCount += 1;
+    }
+  }
+  flushAssistant();
+  return { turns, title, createdAt, cwd, msgCount };
+
+  function flushAssistant() {
+    if (!pendingAssistantBlocks) return;
+    const { text, toolUses, toolResults, time } = pendingAssistantBlocks;
+    if (text.length > 0 || toolUses.length > 0) {
+      turns.push({ kind: 'assistant', text: text.join('\n'), toolUses, toolResults, time });
+    }
+    pendingAssistantBlocks = null;
+  }
+}
+
+/** Build a DSH event log (array of plain events, seq assigned) from parsed turns. */
+export function buildDshEvents(parsed, { limitTurns } = {}) {
+  const events = [];
+  let seq = 0;
+  const t0 = parsed.createdAt ?? Date.now();
+  const push = (type, data, dt = 0) => {
+    events.push({ type, seq, time: t0 + dt, data });
+    seq += 1;
+  };
+  push('permission/preset', { preset: 'workspace-write' });
+  push('sandbox/mode', { mode: 'workspace-write' });
+  push('approval/policy', { policy: 'ask' });
+
+  const turns = Number.isFinite(limitTurns) && limitTurns > 0 ? parsed.turns.slice(-limitTurns * 2) : parsed.turns;
+  let turnNo = 0;
+  let dt = 1000;
+  let turnOpen = false;
+  for (const t of turns) {
+    if (t.kind === 'user') {
+      if (turnOpen) { push('turn/end', { turn: turnNo, reason: { kind: 'completed' } }, dt); dt += 10; }
+      turnNo += 1;
+      turnOpen = true;
+      push('turn/start', { turn: turnNo }, dt); dt += 10;
+      push('step/start', { turn: turnNo, step: 1 }, dt); dt += 10;
+      push('user/message', { content: [{ type: 'text', text: t.text }] }, dt); dt += 50;
+      push('step/end', { turn: turnNo, step: 1 }, dt); dt += 10;
+    } else {
+      // Assistant reply continues the preceding user message's turn
+      // (user path already emitted turn/end? no — we defer turn/end to here).
+      const turn = turnNo;
+      if (turn === 0) { turnNo += 1; push('turn/start', { turn }, dt); dt += 10; }
+      push('step/start', { turn, step: 2 }, dt); dt += 10;
+      const content = [];
+      if (t.text) content.push({ type: 'text', text: t.text });
+      for (const u of t.toolUses) content.push({ type: 'tool_use', id: u.id, name: u.name, input: u.input ?? {} });
+      if (content.length > 0) {
+        push('assistant/message', { turn, step: 2, message: { role: 'assistant', content } }, dt);
+        dt += 50;
+      }
+      let callSeq = 0;
+      for (const r of t.toolResults) {
+        const callId = r.tool_use_id ?? `imported-${turn}-${callSeq}`;
+        const rc = typeof r.content === 'string'
+          ? [{ type: 'text', text: r.content }]
+          : Array.isArray(r.content)
+            ? r.content.map((b) => ({ type: 'text', text: b.type === 'text' ? b.text : JSON.stringify(b) }))
+            : [{ type: 'text', text: String(r.content ?? '') }];
+        push('tool/result', {
+          turn, step: 2,
+          message: {
+            id: `imported-${callId}-${callSeq}`,
+            role: 'user',
+            source: { kind: 'tool', callId },
+            content: [{ type: 'tool-result', toolCallId: callId, isError: Boolean(r.is_error), content: rc }],
+          },
+        }, dt);
+        callSeq += 1;
+        dt += 10;
+      }
+      push('step/end', { turn, step: 2 }, dt); dt += 10;
+    }
+  }
+  if (turnOpen) { push('turn/end', { turn: turnNo, reason: { kind: 'completed' } }, dt); dt += 10; }
+  // Title from first real user text.
+  const firstUser = parsed.turns.find((t) => t.kind === 'user' && !t.text.startsWith('<'));
+  const titleText = parsed.title ?? (firstUser ? firstUser.text.slice(0, 60) : 'claude session');
+  push('session/title', { title: `cc: ${titleText}`, messageSeqs: [], source: { kind: 'user' } });
+  push('session/end-seed', {});
+  return events;
+}
+
+/** Write events as the DSH session log (header + events, zstd-compressed). */
+export function writeDshSession(sessionDir, id, cwd, events) {
+  mkdirSync(sessionDir, { recursive: true });
+  const logPath = join(sessionDir, 'session.jsonl.zstd');
+  rmSync(logPath, { force: true });
+  const header = {
+    type: 'session',
+    version: 0,
+    id,
+    createdAt: events[0]?.time ?? Date.now(),
+    cwd,
+    delegationDepth: 0,
+    agentPreset: 'standard',
+  };
+  const headerLine = JSON.stringify(header) + '\n';
+  const body = events.map((e) => JSON.stringify(e)).join('\n') + (events.length ? '\n' : '');
+  writeFileSync(logPath, zstdFramesSync(headerLine, body));
+  return logPath;
+}
+
+/** List Claude sessions for a cwd. */
+export function listClaudeSessions(cwd, limit = 30) {
+  const dir = claudeProjectDir(cwd);
+  if (!existsSync(dir)) return [];
+  const out = readdirSync(dir)
+    .filter((f) => f.endsWith('.jsonl'))
+    .map((f) => {
+      const id = f.replace(/\.jsonl$/, '');
+      const full = join(dir, f);
+      try {
+        const parsed = parseClaudeSession(full);
+        const st = statSync(full);
+        return {
+          id,
+          path: full,
+          mtime: st.mtimeMs,
+          createdAt: parsed.createdAt,
+          messages: parsed.msgCount,
+          title: parsed.title ?? (parsed.turns.find((t) => t.kind === 'user' && !t.text.startsWith('<'))?.text ?? '').slice(0, 60),
+          turns: parsed.turns.length,
+          imported: existsSync(targetSessionDir(id, cwd)),
+        };
+      } catch { return null; }
+    })
+    .filter(Boolean)
+    .sort((a, b) => (b.mtime ?? 0) - (a.mtime ?? 0))
+    .slice(0, limit);
+  return out;
+}
+
+// ── CLI (guarded: only when run directly, not imported for tests) ──────────
+
+const invokedDirectly = process.argv[1]?.endsWith('cc-resume.mjs') ?? false;
+if (invokedDirectly) {
+const [cmd, ...rest] = process.argv.slice(2);
+const flag = (name) => {
+  const i = rest.indexOf(`--${name}`);
+  return i >= 0 ? rest[i + 1] : undefined;
+};
+const cwd = flag('cwd') ?? process.cwd();
+
+if (cmd === 'list') {
+  const sessions = listClaudeSessions(cwd, Number(flag('limit') ?? 30));
+  if (sessions.length === 0) {
+    console.log(`No Claude sessions found for ${cwd} (looked in ${claudeProjectDir(cwd)})`);
+    process.exit(0);
+  }
+  for (const s of sessions) {
+    const date = s.createdAt ? new Date(s.createdAt).toISOString().slice(0, 16).replace('T', ' ') : '?';
+    console.log(`${s.imported ? '*' : ' '} ${s.id}  ${date}  ${String(s.messages).padStart(4)}msg  ${s.title || '(no text)'}`);
+  }
+  console.log(`\nImport with: node cc-resume.mjs import <sessionId> --cwd ${cwd}`);
+} else if (cmd === 'import') {
+  const sessionId = rest.find((a) => !a.startsWith('--'));
+  if (!sessionId) { console.error('usage: import <sessionId> [--cwd dir] [--limit-turns N]'); process.exit(2); }
+  const src = join(claudeProjectDir(cwd), `${sessionId}.jsonl`);
+  if (!existsSync(src)) { console.error(`not found: ${src}`); process.exit(1); }
+  const parsed = parseClaudeSession(src);
+  if (parsed.turns.length === 0) { console.error('session has no importable turns'); process.exit(1); }
+  const events = buildDshEvents(parsed, { limitTurns: Number(flag('limit-turns')) });
+  const id = `session-cc-${sessionId}`;
+  const dir = targetSessionDir(sessionId, cwd);
+  const logPath = writeDshSession(dir, id, cwd, events);
+  console.log(`imported ${parsed.turns.length} turns (${events.length} events) → ${logPath}`);
+  console.log(`session id: ${id}`);
+  console.log('Open it in the DSH session list (refresh the GUI), or: dsh --profile web --resume ' + id);
+} else {
+  console.error('usage: cc-resume.mjs list|import [<sessionId>] [--cwd dir] [--limit N] [--limit-turns N]');
+  process.exit(2);
+}
+}

package/scripts/gen-downloads-chart.mjs

@@ -0,0 +1,36 @@
+// gen-downloads-chart.mjs — fetch last 30 days of npm downloads and render a
+// simple SVG bar chart to .github/assets/downloads.svg. Run by CI daily.
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+const PKG = 'dsh-claude-compat';
+const DAYS = 30;
+const iso = (d) => d.toISOString().slice(0, 10);
+const end = new Date();
+const start = new Date(Date.now() - (DAYS - 1) * 86400000);
+const res = await fetch(`https://api.npmjs.org/downloads/range/${iso(start)}:${iso(end)}/${PKG}`);
+if (!res.ok) throw new Error(`npm API ${res.status}`);
+const { downloads } = await res.json();
+const days = downloads.map((d) => ({ date: d.day, n: d.downloads }));
+const total = days.reduce((s, d) => s + d.n, 0);
+const max = Math.max(1, ...days.map((d) => d.n));
+
+const W = 760, H = 180, PAD = 30, CW = (W - PAD * 2) / days.length;
+const bars = days.map((d, i) => {
+  const h = Math.round((d.n / max) * (H - 70));
+  const x = PAD + i * CW, y = H - 40 - h;
+  return `<rect x="${x.toFixed(1)}" y="${y}" width="${(CW - 2).toFixed(1)}" height="${h}" rx="2" fill="#22c55e"><title>${d.date}: ${d.n}</title></rect>`;
+}).join('\n  ');
+
+const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${H}" viewBox="0 0 ${W} ${H}" font-family="-apple-system,Segoe UI,Helvetica,Arial,sans-serif">
+  <text x="${PAD}" y="24" font-size="15" font-weight="600" fill="#1f2937">${PKG} — npm downloads (last ${DAYS} days)</text>
+  <text x="${W - PAD}" y="24" font-size="13" text-anchor="end" fill="#374151">total ${total.toLocaleString()} · max ${max.toLocaleString()}/day</text>
+  ${bars}
+  <text x="${PAD}" y="${H - 15}" font-size="11" fill="#6b7280">${days[0].date}</text>
+  <text x="${W - PAD}" y="${H - 15}" font-size="11" text-anchor="end" fill="#6b7280">${days[days.length - 1].date}</text>
+</svg>\n`;
+
+const out = new URL('../.github/assets/downloads.svg', import.meta.url);
+mkdirSync(dirname(out.pathname), { recursive: true });
+writeFileSync(out.pathname, svg);
+console.log(`chart written: total=${total} max=${max}`);

package/scripts/zstd-compat.mjs

@@ -0,0 +1,19 @@
+// zstd-compat.mjs — compress strings with the `zstd` binary via stdin.
+// (macOS: `brew install zstd`; most Linux CI images and the DSH runtime
+// environment already ship it — DSH itself shell-outs to zstd for its own
+// session logs.)
+import { execFileSync } from 'node:child_process';
+
+export function zstdSync(text) {
+  return execFileSync('zstd', ['-3', '-T0', '-q', '-'], {
+    input: text,
+    maxBuffer: 1 << 28,
+    stdio: ['pipe', 'pipe', 'inherit'],
+  });
+}
+
+// DSH session logs require the first zstd frame to hold exactly the header
+// line (assertZstdHeaderFrame); events must be in separate frames.
+export function zstdFramesSync(...texts) {
+  return Buffer.concat(texts.map((t) => zstdSync(t)));
+}

package/src/cc-export-skill.mjs

@@ -0,0 +1,33 @@
+// Skill body for /cc-export — instructs the model to drive scripts/cc-export.mjs.
+export const CC_EXPORT_SKILL_BODY = `# Export DSH Skills to Claude Code
+
+Export DSH-native skills (\`.dsh/skills\`) into Claude Code's
+\`.claude/skills/\` format, closing the DSH → Claude loop. Each DSH skill becomes
+\`.claude/skills/<name>/SKILL.md\` with name/description frontmatter, so Claude
+Code picks it up with zero edits.
+
+## Commands
+Run from the session's working directory (or pass \`--cwd <dir>\`):
+
+1. **List** DSH skills available to export:
+   \`\`\`bash
+   node <plugin-root>/scripts/cc-export.mjs list
+   \`\`\`
+
+2. **Export** them into \`.claude/skills/\`:
+   \`\`\`bash
+   node <plugin-root>/scripts/cc-export.mjs export
+   \`\`\`
+   Options: \`--overwrite\` replaces existing files (default: skip existing),
+   \`--cwd <dir>\` overrides the project directory, \`--target <dir>\` writes
+   somewhere other than \`.claude/skills\`.
+
+3. Tell the user: Claude Code will pick up the exported skills under
+   \`.claude/skills/\` on next load (or after /reload-skills if running).
+
+## Behavior notes
+- Existing target files are skipped unless \`--overwrite\` is passed.
+- DSH skill names are already kebab-case, so they map 1:1 to Claude skill names.
+- Skills without frontmatter get a synthesized name/description so Claude Code
+  accepts them.
+- Other frontmatter keys (e.g. \`author\`) are preserved through the round-trip.`;

package/src/cc-resume-skill.mjs

@@ -0,0 +1,35 @@
+// Skill body for /cc-resume — instructs the model to drive scripts/cc-resume.mjs.
+export const CC_RESUME_SKILL_BODY = `# Claude Code Session Resume
+
+List and import Claude Code conversation sessions into DSH. Imported sessions
+appear in the DSH session list (refresh the GUI) with full user/assistant/tool
+history and can be resumed like any native session.
+
+## Commands
+Run from the session's working directory (or pass \`--cwd <dir>\`):
+
+1. **List** Claude sessions for the current project:
+   \`\`\`bash
+   node <plugin-root>/scripts/cc-resume.mjs list --limit 20
+   \`\`\`
+   Output: one line per session — imported marker (\`*\`), id, date, message
+   count, first-user-text preview. Pick the \`sessionId\` the user wants.
+
+2. **Import** a session:
+   \`\`\`bash
+   node <plugin-root>/scripts/cc-resume.mjs import <sessionId>
+   \`\`\`
+   Options: \`--limit-turns N\` imports only the last N turns (useful for huge
+   sessions), \`--cwd <dir>\` overrides the project directory.
+
+3. Tell the user: refresh the DSH GUI session list and open the session titled
+   \`cc: <preview>\`, or the imported id can be resumed directly.
+
+## Behavior notes
+- Imports are main-thread only (Claude sidechain/subagent messages skipped).
+- Thinking blocks are dropped (DSH reasoning is stream-based; replaying
+  reconstructed reasoning would corrupt the log).
+- Re-importing the same session is idempotent (same target, events rewritten).
+- The imported conversation is static history — continuing it starts a fresh
+  DSH turn flow on top of that context.
+- Requires the \`zstd\` binary on PATH (macOS: \`brew install zstd\`).`;

package/src/hooks.js

@@ -165,7 +165,36 @@ function runHookCommand(command, stdin, { timeoutMs = 60_000 } = {}) {
 
 // ----- settings loading ------------------------------------------------------
 
-const EVENTS = { PreToolUse: 'pre-tool-use', PostToolUse: 'post-tool-use', UserPromptSubmit: 'user-prompt-submit' };
+const EVENTS = {
+  PreToolUse: 'pre-tool-use',
+  PostToolUse: 'post-tool-use',
+  UserPromptSubmit: 'user-prompt-submit',
+  // SessionStart / SessionEnd are notification-style hooks: DSH has no
+  // `agent/notification` event (Claude Code's Notification hook has no DSH
+  // equivalent), but SessionStart → agent/session-start and SessionEnd →
+  // agent/disposed map cleanly. These run fire-and-forget (their output is
+  // logged, never fed back into the loop).
+  SessionStart: 'session-start',
+  SessionEnd: 'session-end',
+};
+
+// Session hooks are async (not decision-bearing). They run best-effort:
+// a non-zero exit is logged, never blocks a session start/end.
+// Exported for hermetic tests.
+export function sessionStartPayload(agent) {
+  const cwd = agent?.session?.header?.cwd ?? process.cwd();
+  const sessionId = agent?.session?.id ?? 'unknown';
+  return JSON.stringify({ session_id: sessionId, cwd });
+}
+
+function sessionEndPayload(agent) {
+  const cwd = agent?.session?.header?.cwd ?? process.cwd();
+  const sessionId = agent?.session?.id ?? 'unknown';
+  return JSON.stringify({ session_id: sessionId, cwd, reason: 'session_end' });
+}
+
+// Re-export for hermetic tests (keeps the single definition above authoritative).
+export { sessionEndPayload };
 
 // Combined hooks map. Project .claude/settings.json is applied LAST so it wins
 // same (event, matcher, command) keys against ~/.claude/settings.json.
@@ -255,6 +284,48 @@ export function registerHooks(ctx, config) {
       return { kind: 'enter', messages: decision.messages.concat(extra) };
     });
   }
+
+  // SessionStart / SessionEnd: fire-and-forget. Run hooks on session lifecycle,
+  // log stdout/stderr, never block or feed output back into the loop.
+  // NB: DSH agent events dispatch (carrier, name, payload). The agent is NOT
+  // in a fixed position: agent-loop's emitAgentEvent fuses it onto the payload
+  // (payload.agent), while the headless path passes it on the carrier
+  // (carrier.agent). Read both defensively.
+  const startHooks = Object.values(settings).filter((h) => h.event === 'session-start');
+  if (startHooks.length > 0) {
+    ctx.on('agent/session-start', (carrier, name, payload) => {
+      const agent = carrier?.agent ?? payload?.agent;
+      const hookPayload = sessionStartPayload(agent);
+      for (const hook of startHooks) {
+        runHookCommand(hook.command, hookPayload, { timeoutMs: config.hooksTimeoutMs ?? 60_000 })
+          .then((run) => {
+            if (run.exitCode !== 0) {
+              console.warn(`dsh-claude-compat: SessionStart hook exited ${run.exitCode}: ${hook.command}`);
+            } else if (run.stdout.trim() !== '') {
+              console.log(`dsh-claude-compat: SessionStart hook output: ${run.stdout.trim()}`);
+            }
+          });
+      }
+    });
+  }
+
+  const endHooks = Object.values(settings).filter((h) => h.event === 'session-end');
+  if (endHooks.length > 0) {
+    ctx.on('agent/disposed', (carrier, name, payload) => {
+      const agent = carrier?.agent ?? payload?.agent;
+      const hookPayload = sessionEndPayload(agent);
+      for (const hook of endHooks) {
+        runHookCommand(hook.command, hookPayload, { timeoutMs: config.hooksTimeoutMs ?? 60_000 })
+          .then((run) => {
+            if (run.exitCode !== 0) {
+              console.warn(`dsh-claude-compat: SessionEnd hook exited ${run.exitCode}: ${hook.command}`);
+            } else if (run.stdout.trim() !== '') {
+              console.log(`dsh-claude-compat: SessionEnd hook output: ${run.stdout.trim()}`);
+            }
+          });
+      }
+    });
+  }
 }
 
 async function runPromptHooks(hooks, agent, config) {

package/src/index.js

@@ -95,9 +95,28 @@ export const Config = z.object({
   pluginSkillSource: z.string().default('claude-plugin'),
   pluginsRoot: z.string().default('~/.claude/plugins'),
   enablePluginMcp: z.boolean().default(false),
+  // Print a one-shot "star it" nudge on the first activation (default true).
+  enableStarNudge: z.boolean().default(true),
 });
 
+const STAR_URL = 'https://github.com/biedongbin/dsh-claude-compat';
+// Module-level once-flag: nudge exactly once per process, on the first profile
+// that activates the plugin, so it never repeats across restarts of the same
+// session. Deliberately NOT persistent — a fresh process nudges again, which
+// is the intended "did this help? star it" cadence without spamming.
+let starNudged = false;
+
 export function apply(ctx, config = {}) {
+  // One-shot "found this useful? star it" nudge, surfaced exactly where the
+  // value lands: the first profile activation of this process.
+  try {
+    if (config.enableStarNudge !== false && !starNudged) {
+      starNudged = true;
+      console.log(
+        `\n⭐ dsh-claude-compat works for you?\n   Show some love: ${STAR_URL}\n`);
+    }
+  } catch { /* the nudge must never break plugin activation */ }
+
   if (config.enableSkills !== false) {
     ctx.skills.registerProvider((control) =>
       new ClaudeCompatSkillProvider(ctx, control, config));
@@ -175,6 +194,14 @@ class ClaudeCompatSkillProvider {
         'Hot-reload the skill catalog: pick up newly installed/removed Claude Code plugin skills without a new session.'));
       candidates.push(this.reloadSkillDef('reload-skills',
         'Hot-reload the skill catalog (alias of /reload-cc-plugins).'));
+      candidates.push(this.managerSkillCandidate('cc-resume',
+        'List and import Claude Code sessions into DSH: browse ~/.claude/projects history and resume any conversation.',
+        'User wants to resume, list, or import a Claude Code conversation/session into DSH. Usage: /cc-resume list, /cc-resume import <sessionId>.',
+        (await import('./cc-resume-skill.mjs')).CC_RESUME_SKILL_BODY));
+      candidates.push(this.managerSkillCandidate('cc-export',
+        'Export DSH-native skills (.dsh/skills) into Claude Code .claude/skills format, closing the DSH → Claude loop.',
+        'User wants to export DSH skills to Claude Code, or bridge DSH-native skills into .claude/skills. Usage: /cc-export list, /cc-export export [--overwrite].',
+        (await import('./cc-export-skill.mjs')).CC_EXPORT_SKILL_BODY));
     }
     if (this.config.enablePlugins !== false) {
       const pluginCandidates = await discoverPluginContent(