Skip to content
Back to search

chat-history-import

Use when the user wants to import external chat exports into OpenClaw. This skill normalizes raw chat history into conversation-archive-compatible JSONL, then guides the model to distill daily memory and `MEMORY.md` candidates before applying merges with user confirmation.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/dashhuang--openclaw-chat-history-import/badge.svg)](/listings/dashhuang--openclaw-chat-history-import)

HTML

<a href="/listings/dashhuang--openclaw-chat-history-import"><img src="/api/listings/dashhuang--openclaw-chat-history-import/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Install `chat-history-import`

安装 `chat-history-import`

Copy the repository root into:

把仓库根目录复制到:

<workspace>/skills/chat-history-import

Install `conversation-history`

安装 `conversation-history`

Copy the companion skill directory into:

把配套 skill 目录复制到:

<workspace>/skills/conversation-history

Shared on one machine

单机共享安装

For shared install, copy:

如果想做共享安装,复制到:

~/.openclaw/skills/chat-history-import
~/.openclaw/skills/conversation-history

Then start a new OpenClaw session or run:

然后启动一个新的 OpenClaw session,或者运行:

openclaw skills info chat-history-import
openclaw skills info conversation-history

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 362 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ---
  2. name: chat-history-import
  3. description: Use when the user wants to import external chat exports into OpenClaw. This skill normalizes raw chat history into conversation-archive-compatible JSONL, then guides the model to distill daily memory and `MEMORY.md` candidates before applying merges with user confirmation.
  4. metadata: { "openclaw": { "emoji": "🗂️", "homepage": "https://github.com/dashhuang/openclaw-chat-history-import", "requires": { "bins": ["python3"] } } }
  5. ---
  6. # Chat History Import
  7. Use this skill when a user wants to import chat history from Claude, ChatGPT, Telegram Desktop exports, Slack exports, markdown logs, JSON/JSONL transcripts, or similar archives into an OpenClaw workspace.
  8. The most common source formats for this skill are ChatGPT exports and Claude exports.
  9. Telegram Desktop HTML exports are also supported when the user wants to backfill a Telegram direct chat or group into OpenClaw's raw archive.
  10. If the user has not exported data yet, suggest the usual official export entry points first:
  11. - ChatGPT: `Settings -> Data Controls -> Export`
  12. - Claude: `Settings -> Privacy -> Export data`
  13. These exports usually arrive as ZIP files and are good candidates for the built-in import flow.
  14. ## What This Skill Owns
  15. - raw archive import into `logs/message-archive-raw/`
  16. - daily memory distillation into `memory/YYYY-MM-DD.md`
  17. - `MEMORY.md` candidate generation
  18. - review and apply workflow for memory merges
  19. ## Related OpenClaw Components
  20. This skill is not a replacement for the live archive plugin or archive search skill.
  21. - `conversation-archive` plugin
  22. - Recommended when the workspace wants future live chats written into the same `logs/message-archive-raw/` tree.
  23. - This skill should emit archive files that are fully compatible with that plugin's raw archive layout.
  24. - `conversation-history` skill
  25. - Strongly recommended when the user wants agents to search imported history after import.
  26. - This import skill writes archive files; it does not replace archive recall/search workflows on its own.
  27. Preferred combined setup:
  28. 1. use `chat-history-import` to backfill old history
  29. 2. use `conversation-archive` to keep new history flowing in
  30. 3. use `conversation-history` to search both imported and live archive data
  31. ## What Scripts Do vs. What The Model Does
  32. Scripts handle deterministic work:
  33. - inspect the source archive
  34. - normalize messages into the archive schema
  35. - validate archive compatibility
  36. - write review artifacts
  37. - apply approved memory merges
  38. Validation must be reported in two layers when relevant:
  39. - `import-batch validation`: whether the files written by this import are valid
  40. - `full-archive validation`: whether the entire existing archive tree is valid
  41. If full-archive validation fails because of pre-existing files outside this import batch, do not describe the new import itself as failed. Report the historical archive issue separately.
  42. The model handles semantic work:
  43. - decide what each day is worth remembering
  44. - rewrite imported history into the style of existing OpenClaw daily memory
  45. - decide what belongs in `MEMORY.md`
  46. - compare imported `MEMORY.md` candidates against existing `MEMORY.md`
  47. Do not try to replace this semantic step with Python heuristics.
  48. Also do not assume the bundled Python parsers can recognize every source format.
  49. For unknown input formats, the model may need to inspect the source and write a temporary format-specific parser.
  50. ## Core Rules
  51. 1. Do not import external history into `agents/<agentId>/sessions/`.
  52. 2. Treat `logs/message-archive-raw/` as the canonical destination for imported raw chat history.
  53. 3. Imported archive output must pass `{baseDir}/scripts/validate_archive.py` and stay compatible with the `conversation-archive` plugin's archive contract.
  54. 4. Daily memory should merge into the existing `memory/YYYY-MM-DD.md` file for that date.
  55. 5. Daily memory body should look like normal OpenClaw memory: concise Chinese bullets, minimal metadata, no “Claude 备份里显示” phrasing.
  56. 6. Use a short HTML comment only to mark import provenance.
  57. 7. `MEMORY.md` is the default memory file here and is always review-required before apply.
  58. ## Large Export Handling
  59. If the user says they already uploaded an archive, but the current chat channel only exposes a placeholder or incomplete file payload, treat that as a transport limitation first.
  60. For large ChatGPT or similar exports, guide the user toward a smaller text-focused package before retrying upload:
  61. 1. unzip the export locally
  62. 2. keep the conversation JSON files first
  63. 3. keep optional small metadata files only when useful
  64. 4. remove bulky attachments such as images, audio, video, PDFs, Office files, and other binary artifacts
  65. 5. re-zip the reduced package and retry import
  66. For ChatGPT-style exports, the most important files are usually:
  67. - `conversations.json`
  68. - `conversations-*.json`
  69. - optional: `group_chats.json`
  70. - optional: `export_manifest.json`
  71. If the reduced archive still cannot be uploaded through the chat channel, ask for one of these instead:
  72. - a direct download URL
  73. - a host-local file path
  74. - a cloud storage link that can be fetched from the host
  75. Use a temp path or another host-local staging path for large imports rather than polluting `workspace/`.
  76. ## Import Workflow
  77. ### 1. Inspect
  78. Start by inspecting the source:
  79. ```bash
  80. python3 {baseDir}/scripts/inspect_import.py /path/to/archive-or-file
  81. ```
  82. Use local file structure first. Use web research only as fallback for unclear formats.
  83. When helpful, check whether the current workspace already has `conversation-archive` and `conversation-history` available, so the user can be told what will happen after import:
  84. - archive-only import
  85. - import plus future live archive
  86. - import plus searchable archive recall
  87. ### 2. Normalize Raw Archive
  88. Normalize the source into the archive schema described in `{baseDir}/references/schema.md`:
  89. ```bash
  90. python3 {baseDir}/scripts/normalize_import.py /path/to/archive --archive-root logs/message-archive-raw --workspace workspace --agent-id main --apply
  91. python3 {baseDir}/scripts/validate_archive.py logs/message-archive-raw
  92. ```
  93. After validation, explicitly separate these outcomes:
  94. 1. whether the newly written files from this import batch are valid
  95. 2. whether the pre-existing archive tree is fully valid
  96. If validation errors point to old archive files unrelated to the current import, report that clearly as a historical archive issue rather than an import-batch failure.
  97. ## Unknown Format Handling
  98. When the bundled parser does not recognize the input format, use this fallback sequence:
  99. 1. Inspect the source files directly.
  100. 2. Determine whether the structure is simple enough to map by hand.
  101. 3. If not, write a temporary Python parser under a temp directory.
  102. 4. Make that parser output the canonical archive JSONL shape from `{baseDir}/references/schema.md`.
  103. 5. Run `{baseDir}/scripts/validate_archive.py` on the result before claiming success.
  104. Preferred order:
  105. 1. bundled parser
  106. 2. model-assisted direct mapping
  107. 3. model-authored temporary parser
  108. Guardrails for temporary parsers:
  109. - only transform source data into canonical archive JSONL
  110. - do not write directly into `MEMORY.md`
  111. - do not bypass the archive validator
  112. - keep source-specific logic isolated; do not pollute the skill with one-off code unless the format is worth supporting permanently
  113. If a bundled parser is missing for a format that seems broadly reusable, mention that it may be worth promoting the temporary parser into a maintained parser later.
  114. ### 3. Distill Daily Memory
  115. This step is model-driven.
  116. Before writing any daily memory, switch into Plan Mode (or an equivalent explicit checklist workflow) and review the import one date at a time.
  117. When the runtime supports subAgents or delegated parallel review, prefer using them to review imported dates one by one or in very small date batches.
  118. The goal is coverage and auditability, not speed alone.
  119. Use the helper script to build the review checklist whenever possible:
  120. ```bash
  121. python3 {baseDir}/scripts/build_review_checklist.py logs/message-archive-raw \
  122. --source-archive <archive-name> \
  123. --source-provider <provider> \
  124. --md-out tmp/chat-import-review-checklist.md \
  125. --json-out tmp/chat-import-review-checklist.json
  126. ```
  127. This helper gives you a date-by-date checklist with entry counts so the Plan Mode review can be explicit and auditable.
  128. Required review process:
  129. 1. list every imported `YYYY-MM-DD.jsonl` date file first
  130. 2. create a checklist covering all imported dates
  131. 3. when subAgents are available, assign imported dates one by one, or in very small date batches, so every date has an explicit review owner
  132. 4. read each date fully before deciding what to write
  133. 5. do not infer from titles, conversation names, or sampling alone
  134. 6. do not apply `MEMORY.md` standards when deciding daily memory
  135. 7. after finishing review for one date, mark that checklist item as done immediately
  136. 8. only claim daily-memory completion after every imported date has been marked reviewed
  137. 9. when a date already has a local daily memory file, still check for missing imported bullets before deciding no change is needed
  138. Checklist discipline is part of the workflow, not an optional nicety.
  139. If a date was reviewed, the checklist should show that review explicitly.
  140. Before writing any memory, first read the local memory rules from the current OpenClaw environment.
  141. Read in this order when available:
  142. 1. local `openclaw.json`
  143. - focus on `agents.defaults.compaction.memoryFlush.prompt`
  144. - focus on `agents.defaults.compaction.memoryFlush.systemPrompt`
  145. 2. workspace `AGENTS.md`
  146. - look for memory-writing rules, what counts as worth remembering, and what to exclude
  147. 3. existing `MEMORY.md`
  148. - learn the default memory style already in use
  149. 4. recent `memory/YYYY-MM-DD.md`
  150. - learn the local daily memory writing style from actual files, not assumptions
  151. Use these local rules as the primary source of truth.
  152. If local rules conflict with anything in this skill, follow the local rules.
  153. The generic guidance in this skill is not an equal second source of truth; it is fallback-only scaffolding for cases where the local environment is missing rules or is still too vague to decide.
  154. For ready-to-use prompt templates, read `{baseDir}/references/prompts.md`.
  155. For each relevant date:
  156. - read the imported archive entries for that day
  157. - decide what is important enough to preserve in that day's log by applying the local OpenClaw memory rules first
  158. - only if those local rules are missing or too vague, fall back to the generic daily-memory heuristics bundled with this skill
  159. - write only the few items that survive that local-rule-first judgment
  160. - match existing OpenClaw daily memory style
  161. Daily memory is a day log, not a default-memory summary. Do not over-filter it using long-term-memory standards.
  162. Good output shape:
  163. ```md
  164. # 2024-04-14
  165. <!-- imported-memory provider=claude archive=data-...zip -->
  166. - 开始用 Claude 辅助起草中文股东信,采用“逐段整理,最后整合全文”的工作方式。
  167. ```
  168. Bad output shape:
  169. - profile dumps
  170. - long autobiographical summaries
  171. - “Claude 备份显示……”
  172. - verbose provenance in the body
  173. ### 4. Distill `MEMORY.md` Candidates
  174. Choose one of these modes explicitly:
  175. 1. `source-memory only`
  176. Use a dedicated memory-like file from the import source when available, such as Claude `memories.json`.
  177. 2. `archive-distill only`
  178. Distill `MEMORY.md` candidates directly from the imported archive.
  179. 3. `hybrid`
  180. Use source memory as the base, then refine or supplement it from archive evidence.
  181. Default:
  182. - if source memory exists, prefer `source-memory only`
  183. - only use `archive-distill only` or `hybrid` when the user explicitly wants the heavier path
  184. Before choosing wording and granularity, read local `MEMORY.md` and recent daily memory files so the imported candidates match the current workspace style.
  185. Preferred user-facing wording:
  186. - call `MEMORY.md` the default memory or 默认记忆
  187. - only use “长期记忆” when needed to contrast it with daily logs
  188. - avoid treating “long-term memory” as the canonical product term
  189. Warn the user that archive-wide `MEMORY.md` distillation is slower and more dependent on model quality.
  190. ### 5. Stage Review Payload
  191. After the model writes daily memory bullets and `MEMORY.md` bullets, save them in a JSON payload with this shape:
  192. ```json
  193. {
  194. "daily_memory": [
  195. {
  196. "date": "2024-04-14",
  197. "source_provider": "claude",
  198. "source_archive": "claude-export.zip",
  199. "bullets": [
  200. "开始用外部模型辅助起草正式中文文稿,采用“逐段整理,最后整合全文”的工作方式。"
  201. ]
  202. }
  203. ],
  204. "memory_md": [
  205. {
  206. "section": "关于用户",
  207. "source_provider": "claude",
  208. "source_archive": "claude-export.zip",
  209. "bullets": [
  210. "用户可在多语言环境中自然切换,个人交流常偏好中文。",
  211. "长期关注科技、游戏与时事。"
  212. ]
  213. }
  214. ]
  215. }
  216. ```
  217. Then stage or apply with:
  218. ```bash
  219. python3 {baseDir}/scripts/memory_merge.py /path/to/payload.json --review-root tmp/chat-history-import-review
  220. ```
  221. Use `memory_md` as the preferred payload key.
  222. `long_term_memory` is still accepted for compatibility, but new work should use `memory_md`.
  223. ### 6. Apply
  224. Daily memory can be applied directly:
  225. ```bash
  226. python3 {baseDir}/scripts/memory_merge.py /path/to/payload.json --memory-root memory --apply-daily
  227. ```
  228. `MEMORY.md` candidates must be confirmed first:
  229. ```bash
  230. python3 {baseDir}/scripts/memory_merge.py /path/to/payload.json --memory-file MEMORY.md --apply-long-term
  231. ```
  232. After a successful import, ask the user whether they want to delete the source archive, extracted source directory, and temp files to save disk space.
  233. Do not delete them without explicit confirmation.
  234. ## Output Expectations
  235. When reporting progress or completion, include:
  236. - detected source format
  237. - archive root written
  238. - import-batch validation result
  239. - full-archive validation result (if checked)
  240. - reviewed dates / total imported dates
  241. - which daily memory dates were updated
  242. - whether `MEMORY.md` candidates were only staged or also applied
  243. ## Guardrails
  244. - Do not claim imported archive compatibility unless validation passes.
  245. - Do not describe the current import as failed when only pre-existing archive files failed full-archive validation.
  246. - Do not imply that imported history will automatically be searchable unless the workspace also has an archive-retrieval workflow such as `conversation-history`.
  247. - Do not imply that future live chats will keep flowing into the same archive tree unless `conversation-archive` or equivalent live archive plumbing is enabled.
  248. - Do not let imported daily memory read like a profile summary.
  249. - Do not silently overwrite existing `MEMORY.md` facts.
  250. - Do not add bulky metadata into daily memory bodies.
  251. - Do not skip daily-memory review based only on titles, thread names, or sparse sampling.
  252. - Do not apply `MEMORY.md` filtering standards to daily memory distillation.
  253. - Do not assume unknown source formats can be handled safely without inspection.
  254. - Do not promote a temporary parser into the skill unless it is stable and broadly reusable.
  255. - Do not invent memory-writing preferences when the local OpenClaw environment already exposes them in config or existing memory files.
  256. Read `{baseDir}/references/schema.md` before changing archive output.
README.md · README · 325 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # OpenClaw Chat History Import
  2. I’m [Dash](https://x.com/DashHuang), CEO of [XD Inc.](https://2400.hk/).
  3. 我是 [Dash](https://x.com/DashHuang),[心动公司](https://2400.hk/) CEO。
  4. I built this skill because I do not want valuable long-term AI chat history and memory to stay scattered across third-party products forever. They should be brought back into an environment we control, manage, customize, and keep evolving over time.
  5. 我做这个 skill,是因为我不希望长期有价值的 AI 聊天记录和记忆信息,一直分散在各种第三方产品里。它们应该被逐步收回到一个由自己控制、可管理、可定制、也能持续演进的环境里。
  6. This skill helps import past conversations from tools like ChatGPT and Claude into OpenClaw, so that old chat history can become OpenClaw's own raw archive and memory.
  7. 这个 skill 的作用,就是把 ChatGPT、Claude 等工具里的过往聊天记录导入 OpenClaw,让这些历史逐步变成 OpenClaw 自己的 raw archive 和记忆。
  8. Today that system may be OpenClaw. In the future it may be something else. The important part is keeping the data in a state we control.
  9. 今天这个承接系统可以是 OpenClaw,将来也可能是别的产品。关键不是某一个具体产品,而是这些数据始终处在自己可控的状态里。
  10. An OpenClaw skill bundle for turning your past AI chat history into OpenClaw's own memory.
  11. 这是一个 OpenClaw skill bundle,核心用途是把你过去在其他 AI 工具里的聊天记录,导入到 OpenClaw 里,变成龙虾自己的记忆。
  12. It helps migrate old conversations from tools like ChatGPT and Claude into OpenClaw, so that past chat history can become:
  13. 它适合把 ChatGPT、Claude 等工具里的旧聊天迁移进 OpenClaw,让这些历史记录变成:
  14. - searchable raw archive
  15. - daily memory
  16. - `MEMORY.md`
  17. - 可搜索的原始 archive
  18. - 每日记忆
  19. - `MEMORY.md`
  20. In short: instead of leaving your old AI conversations stranded across different products, this bundle helps bring them into OpenClaw's own memory system.
  21. 一句话说:它不是把旧聊天继续留在别的 AI 产品里,而是把它们收进 OpenClaw 自己的记忆系统里。
  22. The bundle currently includes two companion skills:
  23. 这个仓库目前包含两个互相配合的 skill:
  24. - `chat-history-import`
  25. - `conversation-history`
  26. `chat-history-import` imports external history into:
  27. `chat-history-import` 会把外部聊天历史导入到:
  28. - `logs/message-archive-raw/`
  29. - `memory/YYYY-MM-DD.md`
  30. - `MEMORY.md`
  31. `conversation-history` searches archive files later, so agents can recall old decisions, links, wording, and chronology.
  32. `conversation-history` 用来在导入后搜索 archive 文件,方便 agent 回忆旧决策、旧链接、原话和时间线。
  33. This bundle is designed for interactive, review-first migration from Claude exports, ChatGPT exports, Slack-style transcripts, and other structured or semi-structured chat archives.
  34. 这个 bundle 面向交互式、先审阅再落盘的迁移流程,适合 Claude 导出、ChatGPT 导出、Slack 风格转储,以及其他结构化或半结构化聊天存档。
  35. ## Common Sources
  36. ## 常见来源
  37. The most common use case is importing history from previous AI chat tools, especially ChatGPT and Claude.
  38. It now also supports Telegram Desktop HTML exports when you want to backfill a Telegram direct chat or group into the same archive tree used by OpenClaw's live `conversation-archive` plugin.
  39. 最常见的使用场景,是把你在其他 AI 聊天工具里的旧历史导入进来,尤其是 ChatGPT 和 Claude。
  40. ### ChatGPT export
  41. ### ChatGPT 导出
  42. As of now, the usual path is:
  43. 截至目前,常见导出路径是:
  44. - ChatGPT
  45. - `Settings`
  46. - `Data Controls`
  47. - `Export`
  48. That export usually arrives as a ZIP and commonly includes files such as `conversations.json`.
  49. 导出的结果通常是一个 ZIP,里面常见会有 `conversations.json` 之类的文件。
  50. ### Claude export
  51. ### Claude 导出
  52. As of now, the usual path is:
  53. 截至目前,常见导出路径是:
  54. - Claude
  55. - `Settings`
  56. - `Privacy`
  57. - `Export data`
  58. That export also typically arrives as a ZIP and may include files such as `conversations.json`, `memories.json`, `projects.json`, and account metadata.
  59. 导出的结果通常也是一个 ZIP,里面可能包含 `conversations.json`、`memories.json`、`projects.json` 以及账户元数据。
  60. If the source is not ChatGPT or Claude, this bundle can still help, but the import may need model-assisted format inspection or a temporary parser.
  61. 如果来源不是 ChatGPT 或 Claude,这个 bundle 也仍然可以尝试导入,只是更可能需要模型辅助识别格式,或者临时写一个 parser。
  62. ### Telegram Desktop export
  63. ### Telegram Desktop 导出
  64. Telegram Desktop exports usually arrive as a directory containing `messages.html`, `messages2.html`, and so on.
  65. Telegram Desktop 的导出通常是一个目录,里面包含 `messages.html`、`messages2.html` 等文件。
  66. Use the normal inspect and normalize flow, but provide the target OpenClaw chat identity explicitly so the imported history lands in the canonical Telegram archive path:
  67. 检查和导入时,额外提供目标 OpenClaw chat identity,这样历史才会落到正确的 Telegram archive 路径里:
  68. ```bash
  69. python3 scripts/inspect_import.py /path/to/ChatExport_xxx
  70. python3 scripts/normalize_import.py /path/to/ChatExport_xxx \
  71. --workspace workspace-food-group \
  72. --agent-id food-group \
  73. --chat-type group \
  74. --peer-id -1003778432310 \
  75. --assistant-name Cindy \
  76. --apply
  77. ```
  78. ## Included Skills
  79. ## 包含的 Skills
  80. ### `chat-history-import`
  81. The main import workflow.
  82. 主导入工作流。
  83. Use it to inspect export files, normalize raw history into `logs/message-archive-raw/`, distill daily memory, and stage `MEMORY.md` candidates for review.
  84. 它负责检查导出文件、把原始聊天规范化写入 `logs/message-archive-raw/`、提炼 daily memory,并生成待审阅的 `MEMORY.md` 候选内容。
  85. ### `conversation-history`
  86. The companion retrieval workflow.
  87. 配套的历史检索工作流。
  88. Use it after import when an agent needs to search old decisions, exact wording, old links, or chronology from raw archive files.
  89. 在导入完成后,如果 agent 需要查找旧决策、原话、旧链接或时间线,就使用它来搜索 raw archive 文件。
  90. ## Recommended Companion Components
  91. ## 推荐搭配组件
  92. ### `conversation-archive` plugin
  93. Recommended, but not required.
  94. 推荐安装,但不是硬依赖。
  95. Use it when you want imported history and future live chat history to live under the same archive layout.
  96. 如果你希望“导入的旧历史”和“未来实时聊天历史”都落到同一套 archive 目录结构里,就应该搭配它使用。
  97. In practice:
  98. 实际效果是:
  99. - `chat-history-import` backfills old history
  100. - `conversation-archive` keeps new history flowing in
  101. - `conversation-history` searches both imported and live archive data
  102. - `chat-history-import` 负责补历史
  103. - `conversation-archive` 负责持续写入新消息
  104. - `conversation-history` 负责搜索导入历史和实时归档
  105. ## Requirements
  106. ## 依赖
  107. - OpenClaw
  108. - `python3`
  109. ## Install
  110. ## 安装
  111. ### Install `chat-history-import`
  112. ### 安装 `chat-history-import`
  113. Copy the repository root into:
  114. 把仓库根目录复制到:
  115. ```text
  116. <workspace>/skills/chat-history-import
  117. ```
  118. ### Install `conversation-history`
  119. ### 安装 `conversation-history`
  120. Copy the companion skill directory into:
  121. 把配套 skill 目录复制到:
  122. ```text
  123. <workspace>/skills/conversation-history
  124. ```
  125. ### Shared on one machine
  126. ### 单机共享安装
  127. For shared install, copy:
  128. 如果想做共享安装,复制到:
  129. ```text
  130. ~/.openclaw/skills/chat-history-import
  131. ~/.openclaw/skills/conversation-history
  132. ```
  133. Then start a new OpenClaw session or run:
  134. 然后启动一个新的 OpenClaw session,或者运行:
  135. ```bash
  136. openclaw skills info chat-history-import
  137. openclaw skills info conversation-history
  138. ```
  139. ## Duplicate Install Notes
  140. ## 重复安装说明
  141. If OpenClaw already provides `conversation-history` from a plugin or shared skills directory, avoid installing a second copy into the same scope.
  142. 如果 OpenClaw 已经通过插件或 shared skills 目录提供了 `conversation-history`,就不要在同一个 scope 里再装第二份。
  143. Practical rule:
  144. 实践上建议这样处理:
  145. - one `conversation-history` per scope is best
  146. - workspace-local copies typically override shared copies
  147. - if both exist, check `openclaw skills info conversation-history` to see which source is active
  148. - 每个 scope 最好只保留一份 `conversation-history`
  149. - workspace-local 通常会覆盖 shared 版本
  150. - 如果两份都在,运行 `openclaw skills info conversation-history` 看当前实际生效的是哪一份
  151. ## Publish To ClawHub
  152. ## 发布到 ClawHub
  153. For the import skill at repo root:
  154. 发布仓库根目录的导入 skill:
  155. ```bash
  156. clawhub publish . \
  157. --slug chat-history-import \
  158. --name "Chat History Import" \
  159. --version 0.1.0 \
  160. --tags latest \
  161. --changelog "Initial public release."
  162. ```
  163. For the companion retrieval skill:
  164. 发布配套的检索 skill:
  165. ```bash
  166. clawhub publish ./conversation-history \
  167. --slug conversation-history \
  168. --name "Conversation History" \
  169. --version 0.1.0 \
  170. --tags latest \
  171. --changelog "Initial public release."
  172. ```
  173. ## Validate Locally
  174. ## 本地校验
  175. ```bash
  176. python3 -m py_compile scripts/*.py
  177. python3 -m py_compile conversation-history/scripts/*.py
  178. openclaw skills info chat-history-import
  179. ```
  180. ## Repository Layout
  181. ## 仓库结构
  182. - `SKILL.md`
  183. OpenClaw skill entrypoint and workflow instructions for `chat-history-import`.
  184. - `conversation-history/`
  185. Companion archive retrieval skill.
  186. - `references/`
  187. Archive schema and memory distillation prompt templates.
  188. - `scripts/`
  189. Deterministic helpers for inspect, normalize, validate, and merge.
  190. - `SKILL.md`
  191. `chat-history-import` 的 OpenClaw skill 入口和工作流说明。
  192. - `conversation-history/`
  193. 配套的 archive 检索 skill。
  194. - `references/`
  195. archive schema 与 memory 提炼提示词模板。
  196. - `scripts/`
  197. 用于 inspect、normalize、validate 和 merge 的确定性辅助脚本。
  198. ## License
  199. ## 许可证
  200. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.