linksee-memory 0.0.6 → 0.0.8

package/README.md

@@ -48,6 +48,18 @@ claude mcp add -s user linksee -- npx -y linksee-memory
 
 Restart Claude Code. Tools appear as `mcp__linksee__remember`, `mcp__linksee__recall`, `mcp__linksee__recall_file`, `mcp__linksee__read_smart`, `mcp__linksee__forget`, `mcp__linksee__consolidate`.
 
+### Recommended: install the skill (auto-invocation)
+
+Installing the MCP alone doesn't teach Claude Code *when* to call `recall` / `remember`. The bundled skill fixes that:
+
+```bash
+npx -y linksee-memory-install-skill
+```
+
+This copies a `SKILL.md` to `~/.claude/skills/linksee-memory/`. Claude Code auto-discovers it and fires the skill on phrases like "前に…", "また同じエラー", "覚えておいて", new task starts, file edits, and so on — no need to say "use linksee-memory".
+
+Flags: `--dry-run`, `--force`, `--help`.
+
 ### Optional: auto-capture every session (Stop hook)
 
 Add to `~/.claude/settings.json` to record every Claude Code session to your local brain automatically:
@@ -179,6 +191,95 @@ Aggregated MCP-usage data helps the [KanseiLink](https://kansei-link.com) projec
 
 The full payload schema and validation logic is open-source — read `src/lib/telemetry.ts` if you want to verify exactly what leaves your machine.
 
+## Pricing
+
+**Free forever.**
+
+linksee-memory is local-first and runs entirely on your machine. There is no hosted component you need to pay for. The SQLite DB lives in your home directory; backup = file copy.
+
+No account, no credit card, no API key. Just install and use.
+
+## Troubleshooting
+
+<details>
+<summary><b>The skill isn't firing — Claude Code doesn't call <code>recall</code> when I ask about past work.</b></summary>
+
+1. Verify the skill was installed:
+   ```bash
+   ls ~/.claude/skills/linksee-memory/SKILL.md
+   ```
+   If absent, run `npx -y linksee-memory-install-skill`.
+2. Restart Claude Code. Skills are indexed on session start.
+3. Check that the MCP is registered under the name `linksee` (the skill expects `mcp__linksee__*` tool names):
+   ```bash
+   claude mcp list | grep linksee
+   ```
+   If it's registered as something else, either re-register or edit `~/.claude/skills/linksee-memory/SKILL.md` to match.
+</details>
+
+<details>
+<summary><b>Stop hook isn't recording my sessions.</b></summary>
+
+1. Check the hook log: `cat ~/.linksee-memory/hook.log`
+2. Run a manual test:
+   ```bash
+   echo '{"session_id":"test","transcript_path":"/path/to/some.jsonl"}' | npx linksee-memory-sync
+   ```
+3. Make sure the `Stop` hook in `~/.claude/settings.json` points to `npx -y linksee-memory-sync` (not the old `-import`).
+</details>
+
+<details>
+<summary><b>Upgrading from v0.0.5 or earlier — my recalls are mostly tagged "Card_Navi" or my project-dir name.</b></summary>
+
+v0.0.6+ fixed the entity detection bug that collapsed all memories into the session's starting cwd. To re-index existing history with correct project attribution, run:
+
+```bash
+npx linksee-memory-import --all
+```
+
+The importer is idempotent (wipes existing session data before re-inserting). Typical runtime: a few minutes for hundreds of sessions. Expect a dramatic improvement in `recall` precision afterward.
+</details>
+
+<details>
+<summary><b><code>recall</code> returns too much — the context window fills up fast.</b></summary>
+
+Reduce `max_tokens`:
+```
+recall({ query: "...", max_tokens: 800 })   // default is 2000
+```
+Or narrow with `entity_name` and `layer`:
+```
+recall({ query: "...", entity_name: "my-project", layer: "caveat" })
+```
+</details>
+
+<details>
+<summary><b>How do I reset / delete all memory?</b></summary>
+
+```bash
+rm -rf ~/.linksee-memory   # nuke everything; next run creates a fresh DB
+```
+
+Or delete individual memories via the `forget` tool with a specific `memory_id`.
+</details>
+
+<details>
+<summary><b>DB is getting large (>100 MB). How do I trim it?</b></summary>
+
+Run consolidate — it clusters old cold memories into compressed learning-layer summaries:
+```
+consolidate({ scope: "all", min_age_days: 7 })
+```
+Caveat and active-goal layers are always preserved. Consider scheduling a weekly run via cron / Task Scheduler.
+</details>
+
+## Support
+
+- **Issues & bug reports**: [github.com/michielinksee/linksee-memory/issues](https://github.com/michielinksee/linksee-memory/issues)
+- **Feature requests**: open an issue with the `enhancement` label
+- **Security concerns**: see [SECURITY.md](./SECURITY.md) if present, or file a private advisory on GitHub
+- **Company**: Synapse Arrows PTE. LTD. (Singapore)
+
 ## License
 
 MIT — Synapse Arrows PTE. LTD.

package/dist/bin/install-skill.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/install-skill.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+// install-skill: copies the bundled SKILL.md into ~/.claude/skills/linksee-memory/
+// so Claude Code can auto-invoke linksee-memory based on user intent.
+//
+// Usage:
+//   npx linksee-memory-install-skill           (safe — won't overwrite without --force)
+//   npx linksee-memory-install-skill --force   (overwrite existing file)
+//   npx linksee-memory-install-skill --dry-run (show what would happen)
+//
+// Why: installing the MCP server alone doesn't teach Claude Code WHEN to call
+// recall/remember/read_smart/etc. The skill provides trigger phrases ("前に...",
+// "また同じエラー", new task start, file edits, etc.) so the agent auto-fires
+// without the user having to type "use linksee-memory".
+import { mkdirSync, existsSync, copyFileSync, readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+const args = process.argv.slice(2);
+const force = args.includes('--force') || args.includes('-f');
+const dryRun = args.includes('--dry-run');
+const showHelp = args.includes('--help') || args.includes('-h');
+if (showHelp) {
+    console.log(`linksee-memory-install-skill
+
+Install the linksee-memory Claude Code skill into ~/.claude/skills/linksee-memory/.
+
+Options:
+  --force, -f    Overwrite an existing skill file
+  --dry-run      Show what would happen without writing
+  --help, -h     This message
+
+After installation, ensure the MCP server is registered in Claude Code:
+  claude mcp add -s user linksee -- npx -y linksee-memory
+
+The skill expects tool names of the form mcp__linksee__*. If you register the
+server under a different name (e.g. "linksee-memory"), edit the skill file
+afterwards.`);
+    process.exit(0);
+}
+// The bundled skill lives next to us in dist/skill/ after build
+const __filename = fileURLToPath(import.meta.url);
+const skillSrc = join(dirname(__filename), '..', 'skill', 'SKILL.md');
+if (!existsSync(skillSrc)) {
+    console.error(`[error] bundled skill not found at ${skillSrc}`);
+    console.error('This is a packaging bug. Please file an issue at:');
+    console.error('  https://github.com/michielinksee/linksee-memory/issues');
+    process.exit(1);
+}
+const targetDir = join(homedir(), '.claude', 'skills', 'linksee-memory');
+const targetFile = join(targetDir, 'SKILL.md');
+const exists = existsSync(targetFile);
+if (dryRun) {
+    console.log('[dry-run] Would install skill:');
+    console.log(`  source: ${skillSrc}`);
+    console.log(`  target: ${targetFile}`);
+    console.log(`  exists: ${exists ? 'yes (would NOT overwrite without --force)' : 'no'}`);
+    process.exit(0);
+}
+mkdirSync(targetDir, { recursive: true });
+if (exists && !force) {
+    try {
+        const bundled = readFileSync(skillSrc, 'utf8');
+        const installed = readFileSync(targetFile, 'utf8');
+        if (bundled === installed) {
+            console.log(`[ok] Skill already installed and up to date:`);
+            console.log(`     ${targetFile}`);
+            process.exit(0);
+        }
+    }
+    catch {
+        /* fall through */
+    }
+    console.log(`[skip] A skill already exists at ${targetFile}`);
+    console.log('       The bundled version differs. To overwrite, run:');
+    console.log('       linksee-memory-install-skill --force');
+    process.exit(0);
+}
+copyFileSync(skillSrc, targetFile);
+console.log(`[ok] Skill installed: ${targetFile}`);
+console.log('');
+console.log('Next steps:');
+console.log('  1. Ensure the linksee-memory MCP server is registered:');
+console.log('       claude mcp add -s user linksee -- npx -y linksee-memory');
+console.log('');
+console.log('  2. Restart Claude Code (the skill auto-loads on next turn).');
+console.log('');
+console.log('  3. Test by saying something like:');
+console.log('       "前にこの問題どう解決したっけ"');
+console.log('       "また同じエラーが出た"');
+console.log('       "覚えておいて: ..."');
+console.log('');
+console.log('The skill will trigger and call recall/remember automatically.');
+//# sourceMappingURL=install-skill.js.map

package/dist/lib/session-extractor.js

@@ -31,9 +31,19 @@ const FAILURE_PATTERNS = [
     /失敗|バグ|エラー|直して|修正|戻して/,
     /error|bug|fail|broken|revert|rollback/i,
 ];
+// Caveats must be EXPLICIT warnings/prohibitions the user wants preserved.
+// Previous bare patterns (/注意/ /やらない/ /避けて/) caught descriptive usage
+// like「一般ユーザーはやらない」「Anthropicがやらない範囲」and turned
+// opinions into protected caveats. Tightened to imperative/prohibitive forms
+// only. Loses some recall, but precision matters more for the "never forget"
+// layer.
 const CAVEAT_PATTERNS = [
-    /注意|気をつけ|避けて|やらない|禁止/,
-    /do not|never|avoid|watch out/i,
+    // Imperative negations: any verb-stem + ないで is a command "don't X".
+    // The 「[ぁ-ん一-龯]ないで」 clause catches 触らないで / 消さないで / 使わないで /
+    // 書かないで etc. while `(?!いる|いない|ほし)` excludes descriptive forms
+    // like 「やらないでいる」 or 「やらないでほしい」 (state / request).
+    /気をつけて|注意して|[！!]注意[！!]|避けて(?!いる|いない)|[ぁ-ん一-龯]ないで(?!いる|いない|ほし)|やめて(?!おく|ほし)|禁止|ダメだ|危険/,
+    /\b(?:don'?t|do\s+not)\s+(?:do|use|run|call|forget|try|send|share|commit|push|paste|edit)\b|\bnever\s+(?:do|use|call|share|commit|paste|run|push|edit)\b|\bavoid(?:ing)?\b|\bwatch\s+out\b/i,
 ];
 function matchesAny(text, patterns) {
     return patterns.some((p) => p.test(text));

package/dist/skill/SKILL.md

@@ -0,0 +1,321 @@
+---
+name: linksee-memory
+description: |
+  エージェントの「過去の自分」への橋。新しい作業・ファイル編集・意思決定・失敗の前後で、linksee-memory から過去の caveat（痛みの記録）/ learning（成長ログ）/ implementation（成功失敗）を recall する。
+  これは Claude Code の「毎セッション記憶喪失」問題を解決する唯一の方法。Mem0/Letta/Zep にはできない「同じ失敗を二度としない」仕組み。
+  以下のタイミングで必ずこのスキルを使うこと：
+  ①作業開始時・新タスク開始時（「実装しよう」「始めよう」「新しく〜作る」）
+  ②ファイル編集する前（同じファイルを過去に触ってる可能性がある）
+  ③エラー・失敗した瞬間（remember で caveat 記録）
+  ④成功した瞬間・新しいこと学んだ瞬間（remember で learning 記録）
+  ⑤ユーザーが「前に」「同じ」「覚えてる？」「覚えておいて」と言ったとき
+  ⑥「なぜそうした」「いつ決めた」「どこで議論した」と聞かれたとき
+  ⑦別プロジェクトから戻ってきたとき・セッション切り替え時
+  トリガー: 記憶/覚えて/忘れて/過去/前回/前に/そういえば/覚えてる/memory/remember/recall/forget
+  エラーキーワード: 失敗/エラー/うまくいかない/ハマった/同じ/また/繰り返し/debug
+  決定キーワード: 決めた/方針/戦略/ピボット/やめよう/方向転換
+---
+
+# Linksee Memory Skill — エージェントの過去と未来をつなぐ
+
+## 🧠 Core Principle
+
+**このスキルは「エージェントの成長が session を跨いで永続するための唯一の手段」**。
+
+Claude Code は session が終わると全部忘れる。Michieさんが昨日教えてくれた解決策、今日やった失敗、3日前の決定——すべて普通は消える。**linksee-memory は「消えない記憶」を作る装置**。
+
+書き込みは Stop hook が自動でやってくれる（もう動いてる）。でも**読み出しはエージェントが能動的にやらないと使われない**。この skill がその「読みにいく習慣」をエージェントに植え付ける。
+
+---
+
+## 📐 6レイヤーの役割分担
+
+どのレイヤーに記録するかで、後の検索精度が変わる。
+
+| レイヤー | いつ使うか | 例 |
+|---|---|---|
+| 🎯 `goal` | ユーザーが明確なゴールを言ったとき | "freeeと連携させたい" "npm publishしたい" |
+| 📍 `context` | いつ・なぜそれをしてるかの背景 | "X社との商談が水曜にあるから" |
+| 💭 `emotion` | ユーザーの温度感・感情 | "疲れた" "嬉しい" "焦ってる" |
+| 🔧 `implementation` | コードを書いた、設定した、動いた/動かなかった | 成功: "OAuth flow が通った" / 失敗: "auth_expired で止まった" |
+| ⚠️ `caveat` | **二度と繰り返したくない教訓**（忘却保護） | "freeeのOAuthは24hで切れる" "このファイルは絶対編集しない" |
+| 📈 `learning` | 新しいこと学んだ、前の考えが更新された | "AST chunking の方が line diff より効く" |
+
+**重要:** `caveat` は自動で忘却保護される。痛みの記録は絶対消えない。
+
+---
+
+## 🔄 実行フロー（5つのタイミング）
+
+### ① Task Start — 作業開始前に必ず recall
+
+新しい作業を始める**前**に、過去のコンテキストを注入する。
+
+```
+mcp__linksee__recall({
+  query: "<現タスクのキーワード。プロジェクト名 + 技術名>",
+  max_tokens: 2000
+})
+```
+
+**例**: ユーザーが「KanseiLinkに新しいツール追加したい」と言ったら：
+```
+recall({ query: "KanseiLink new tool", max_tokens: 2000 })
+```
+
+返ってきた memories から、特に以下に注目：
+- **`caveat` 層** — 絶対避けるべき罠
+- **`learning` 層** — 前に得た結論
+- **`implementation.failure`** — 過去の失敗パターン
+
+**例の結果の使い方:**
+```
+過去の caveat から: "同じMCPのtool名の衝突に気をつけろ"
+→ 新しいツール追加前に既存tool名を確認する流れで作業開始
+```
+
+### ② File Edit — ファイル編集前に recall_file
+
+特定ファイルを触る前に、そのファイルの過去の編集履歴を確認：
+
+```
+mcp__linksee__recall_file({
+  path_substring: "<ファイルのパス or 部分一致する名前>",
+  max_intents: 5
+})
+```
+
+返ってくる: そのファイルの全編集履歴 + **各編集を引き起こしたユーザー発言**
+
+**これがキモ**: Mem0/Lettaにはない機能。「このファイル、前になぜ変更されたか」が残ってる。
+
+### ③ Before Reading — 既読ファイルなら read_smart
+
+ファイルを読む必要があるとき、**Read ツールの代わりに read_smart を使う**:
+
+```
+mcp__linksee__read_smart({
+  path: "<絶対パス>"
+})
+```
+
+**効果**:
+- 初回読み: 通常 Read と同じトークン（chunk metadata 付き）
+- 2回目以降・変更なし: **~50 トークンだけ返る**（99% 節約）
+- 2回目以降・変更あり: 変更 chunk だけ返る（50-90% 節約）
+
+特に大きなファイル（1000行超えるもの）で効果絶大。
+
+### ④ Failure — エラー発生時に caveat 記録
+
+エラー・失敗・「うまくいかない」が発生した瞬間、すぐ記録する：
+
+```
+mcp__linksee__remember({
+  entity_name: "<プロジェクト名 or サービス名>",
+  entity_kind: "project",
+  layer: "caveat",
+  content: '{"rule_or_warning":"<失敗内容 + 回避策>","when":"<ISO日時>"}',
+  importance: 0.8  // 失敗は重要度高め
+})
+```
+
+**例**:
+```json
+{
+  "rule_or_warning": "freee MCPは24時間でOAuth token切れる。refresh_token使って再取得する必要あり。access_tokenを直接使い回すと401で止まる",
+  "from_incident": "session 02759-...で auth_expired エラー",
+  "workaround": "24h毎に refresh token → 新しい access token"
+}
+```
+
+**なぜ重要か**: `caveat` は**自動で忘却保護**される。この記録があれば、別セッションの別エージェントも同じ失敗を避けられる。
+
+### ⑤ Success/Learning — 成功・学習時に記録
+
+新しいこと理解した、アプローチ変えた、問題解決した瞬間：
+
+```
+mcp__linksee__remember({
+  entity_name: "<entity>",
+  entity_kind: "project | concept | ...",
+  layer: "learning",
+  content: '{"at":"<日時>","learned":"<何を学んだか>","prior_belief":"<前はこう思ってた>"}',
+  importance: 0.7
+})
+```
+
+`prior_belief` を書くことで「**信念の更新履歴**」が残る。これは後で「なぜこの決定をしたのか」の根拠になる。
+
+---
+
+## 🎯 絶対ルール
+
+### ✅ やるべきこと
+
+1. **新タスク開始時、必ず最初に `recall` を呼ぶ**（たとえ短くても）
+2. **同じファイルを触る前に `recall_file` で過去履歴を確認**
+3. **大きなファイルは `Read` より `read_smart` を優先**
+4. **エラーが出たら即座に `caveat` 記録**（その場で記録、後回しにしない）
+5. **ユーザーが驚いたり「なるほど」と言ったら `learning` 記録**
+
+### ❌ やってはいけないこと
+
+1. ❌ 作業開始時に recall せず、いきなり手を動かす
+2. ❌ エラーをその場で解決したのに記録しない → 未来の自分（or 他のエージェント）が同じ失敗を繰り返す
+3. ❌ `Read` ばかり使って `read_smart` を使わない（トークン無駄）
+4. ❌ caveat をふざけた軽い tone で書く（真面目に残す）
+5. ❌ 長期作業中は consolidate を忘れない（週1は `consolidate()` 呼ぶべき）
+
+---
+
+## 🔁 Consolidate — 記憶の定期整理
+
+メモリが膨張してきたら（目安: DB 20MB超、memories 15,000件超）：
+
+```
+mcp__linksee__consolidate({
+  scope: "session",
+  min_age_days: 7
+})
+```
+
+これで 7日前より古く、importance低く、cold バンドになった memories が自動でクラスタ化 → learning 層に1件に圧縮 → 元データ削除。
+
+**caveat と active goal は消えない**。睡眠中の脳の記憶整理と同じ。
+
+---
+
+## 🧭 Skill 発火シナリオ集
+
+### Case A: 新しいプロジェクトに入る
+
+ユーザー: "今日は XYZ プロジェクトに戻るよ"
+
+```
+1. recall({ query: "XYZ", max_tokens: 2500 })
+2. 返ってきた caveat/learning/goal を確認
+3. ユーザーに「前回の続きで...」と状況を1行で示す
+4. その文脈の上で作業開始
+```
+
+### Case B: 同じエラーが出た（デジャブ感）
+
+ユーザー: "あれ、このエラー前も見たような..."
+
+```
+1. recall({ query: "<エラーメッセージの核キーワード>", max_tokens: 1000 })
+2. 過去の caveat から workaround 取得
+3. 「前回（日時）同じエラーで、X で解決した」と回答
+4. workaround を適用
+```
+
+### Case C: ファイル編集前の確認
+
+ユーザー: "server.ts を直して"
+
+```
+1. recall_file({ path_substring: "server.ts" })
+2. 過去の編集頻度・理由を確認
+3. 「このファイル過去 N 回編集されてる。最後は ○○ 目的」と報告
+4. その文脈で今回の編集を行う
+5. 編集後、implementation.success / failure で記録
+```
+
+### Case D: 決定した瞬間
+
+ユーザー: "じゃあ Sonnet に切り替えるわ"
+
+```
+1. remember({
+     entity_name: "<プロジェクト>",
+     entity_kind: "project",
+     layer: "learning",
+     content: '{"at":"...", "learned":"このプロジェクトは Sonnet で行く", "prior_belief":"Opus使ってた"}',
+     importance: 0.8
+   })
+2. 「記録しました」と一言
+3. 次からの作業は Sonnet 前提で進める
+```
+
+### Case E: 長時間作業の終盤
+
+ユーザー: "今日はここまで"
+
+```
+1. 今日のハイライトを remember で記録:
+   - 主要な decision を learning 層
+   - 発生した失敗を caveat 層
+   - 完成した成果物を implementation.success
+2. 「記録完了。次回 recall で取れる状態です」と報告
+3. 必要なら consolidate({scope:"session", min_age_days: 14}) を提案
+```
+
+### Case F: ユーザーが「覚えて」と明示
+
+ユーザー: "これは覚えておいて: cloudsign より DocuSign の方が安定"
+
+```
+1. remember({
+     entity_name: "cloudsign vs DocuSign",
+     entity_kind: "concept",
+     layer: "caveat",
+     content: '{"rule_or_warning":"cloudsign (61% success) より DocuSign-JP (100%) の方が安定。カスタマーに提案するときは DocuSign 推奨"}',
+     importance: 0.9  // ユーザー明示指示は高優先度
+   })
+2. 「記憶しました。caveat 層なので忘れません」と確認
+```
+
+---
+
+## 🔐 プライバシー（ユーザーに聞かれたとき）
+
+linksee-memory は **完全ローカル**:
+- DB: `~/.linksee-memory/memory.db` （ユーザーのPC内）
+- 外部送信: なし（telemetry は opt-in、デフォルト OFF）
+- バックアップ: ファイルコピーで完結
+
+「私たちのデータは外に出てる？」と聞かれたら：
+「**デフォルトで一切出てません。** telemetry を明示的に enable していない限り、すべてローカルDB。`~/.linksee-memory/memory.db` のコピーが唯一のバックアップ。」と答える。
+
+---
+
+## 🚀 KanseiLink Skill との連携
+
+KanseiLink skill と linksee-memory skill は**セットで動く**と最大効果：
+
+```
+ユーザー: "freeeで請求書作って"
+↓
+[linksee-memory skill 発火] recall({query: "freee"})
+  → 過去の caveat: "company_id 最初に取る必要あり"
+  → 過去の learning: "OAuth 24h refresh"
+↓
+[kansei-link skill 発火] search_services({intent: "invoice"})
+  → freee verified、trust 0.9
+  → get_service_tips で pitfall 確認
+↓
+両方の集合知を持った状態で実装開始
+```
+
+**KanseiLink = 外部SaaSの集合知 / linksee-memory = 自分の過去の集合知**。両輪。
+
+---
+
+## 📊 使うほど精度が上がる原理
+
+| 時点 | recall 精度 | なぜ |
+|---|---|---|
+| Day 1 | 低（データ少） | Stop hook が貯めてる最中 |
+| Week 1 | 中 | 数千件 memories、FTS5 が効き出す |
+| Month 1 | 高 | heat_score が安定、重要メモリが浮上 |
+| Month 3+ | 最強 | consolidate 走って、learnings が結晶化 |
+
+**「使うほど賢くなる」は時間が味方してくれる**。今日の記録は 3ヶ月後の自分が読む。
+
+---
+
+*このスキルは linksee-memory MCP v0.0.5+ の上で動く。*
+*Stop hook 経由で自動記録、recall 経由で手動取り出し。*
+*MCP Registry 登録済み、Glama/LobeHub 申請中（2026-04-17 時点）*
+*MIT License — Synapse Arrows PTE. LTD.*

package/package.json

@@ -1,24 +1,26 @@
 {
   "name": "linksee-memory",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "mcpName": "io.github.michielinksee/linksee-memory",
   "description": "Local-first agent memory MCP — cross-agent brain with 6-layer structured memory + token-saving file diff cache",
   "type": "module",
   "bin": {
     "linksee-memory": "./dist/mcp/server.js",
     "linksee-memory-import": "./dist/bin/import-sessions.js",
-    "linksee-memory-sync": "./dist/bin/sync-session.js"
+    "linksee-memory-sync": "./dist/bin/sync-session.js",
+    "linksee-memory-install-skill": "./dist/bin/install-skill.js"
   },
   "main": "./dist/mcp/server.js",
   "files": [
     "dist/**/*.js",
     "dist/**/*.d.ts",
     "dist/db/schema.sql",
+    "dist/skill/SKILL.md",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsc && node -e \"require('fs').copyFileSync('src/db/schema.sql','dist/db/schema.sql')\"",
+    "build": "tsc && node -e \"require('fs').copyFileSync('src/db/schema.sql','dist/db/schema.sql'); require('fs').mkdirSync('dist/skill',{recursive:true}); require('fs').copyFileSync('src/skill/SKILL.md','dist/skill/SKILL.md')\"",
     "start": "node dist/mcp/server.js",
     "dev": "tsx src/mcp/server.ts",
     "migrate": "node dist/db/migrate.js",