@horizon_works/banto 0.5.0

package/server.js

@@ -0,0 +1,1671 @@
+#!/usr/bin/env node
+/**
+ * 番頭ゲート MCP サーバー（最小版 v0.1）
+ *
+ * 目的: 「AIに中身を見せずに、AIに検査させる」が本当に成立するかを実測するための1本。
+ *
+ * 設計の要:
+ *   - check_file は、パスだけを受け取る。ファイルを読むのは**このサーバー**であって、AIではない
+ *   - 戻り値は「件数」「種別」「判定」だけ。★該当行・該当語・本文は一切返さない
+ *   - つまり、検査対象の中身は AIプロバイダのクラウドを一度も通らない
+ *
+ * 依存ゼロ（MCP SDKを使わず、stdio上の改行区切りJSON-RPCを直接扱う）。
+ * 利用者環境で npm install を要求しないため。
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const readline = require('readline');
+
+const REPO = path.resolve(__dirname, '../../..');
+
+// ★検査の本体（＝フリー版）。2026-08-20、配った形で起動したら**落ちた**。
+//   原因＝隣のフォルダを相対で呼んでいた。配布先に隣は無い。
+//   → 自分の中（./gate_core.js）を先に見る。開発中は隣を使う。
+const FREE = (() => {
+  for (const p of ['./gate_core.js', '../bantou_gate_free/server.js']) {
+    try { return require(p); } catch (_) {}
+  }
+  return null;
+})();
+if (!FREE) {
+  process.stderr.write('検査の本体が見つかりません（gate_core.js）\n');
+  process.exit(1);
+}
+
+// ★うちの辞書つきチェッカー。**配布版には入れない**（顧客名が71語入っている）。
+//   2026-08-20、単体起動が落ちたおかげで気づいた。落ちなければ同梱していた。
+//   → 「あれば使う／無ければフリー版の3系統だけで動く」。無いことを異常にしない。
+const CHECKER = (() => {
+  const p = path.join(REPO, 'skills', 'utils', 'check_anonymization.js');
+  try { return fs.existsSync(p) ? p : null; } catch (_) { return null; }
+})();
+
+// ---------------------------------------------------------------- 検査の実体
+
+/**
+ * 匿名化ゲートを走らせ、★件数と種別だけを取り出す。
+ * 出力本文（該当行に固有名が載っている）は、ここで捨てる。呼び出し元へ返さない。
+ */
+function inspect(targetPath) {
+  // ★辞書つきチェッカーが無い環境（＝配った先）では、フリー版の3系統だけで検査する。
+  //   「辞書が無い」は異常ではない。利用者が自分の辞書を育てる形が既定。
+  if (!CHECKER) return inspectWithoutDictionary(targetPath);
+
+  let raw;
+  try {
+    raw = execFileSync(process.execPath, [CHECKER, targetPath], {
+      cwd: REPO,
+      encoding: 'utf8',
+      maxBuffer: 32 * 1024 * 1024,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+  } catch (e) {
+    // チェッカーは検出時に非0で終わることがある。stdout は取れているので使う
+    raw = (e.stdout || '') + (e.stderr || '');
+    if (!raw) return { error: '検査を実行できませんでした' };
+  }
+
+  const files = (raw.match(/走査\s+(\d+)\s*ファイル/) || [])[1];
+  const hits = (raw.match(/ヒット\s+(\d+)\s*件/) || [])[1];
+
+  // ❌行から「種別（辞書の語）」だけを数える。★行の本文は捨てる
+  const kinds = {};
+  for (const line of raw.split('\n')) {
+    const m = line.match(/^\s*❌\s+\S+\s+\[([^\]]+)\]/);
+    if (m) kinds[m[1]] = (kinds[m[1]] || 0) + 1;
+  }
+
+  const candidates = (raw.match(/辞書に無い固有名の候補[：: ]?\s*(\d+)/) || [])[1];
+  const internal = (raw.match(/内部メモらしき記述\s*(\d+)\s*件/) || [])[1];
+  // ★辞書そのものの健康状態。検査対象の中身ではないので返してよい。
+  //   生のチェッカーは0件でも毎回出す設計なのに、初版のゲートはこれを落としていた
+  //   （＝「0件のときも出す」と決めた警告が、ゲート経由で消えていた）。
+  const oneSided = (raw.match(/辞書に片側だけの語が\s*(\d+)\s*件/) || [])[1];
+
+  // ★★ ここが「見せない設計」の要。
+  // 検出された語そのもの（＝顧客名・相手のAI名）は、絶対に戻り値へ入れない。
+  // 2026-08-20 の初回実装では kinds に語を並べており、実測で「相手のAI名」「顧客名」が
+  // AIの文脈へ流れていた。便利にしようとすると漏れる、の実例。
+  // 詳細は人が手元で読む。AIは件数しか受け取らない。
+  const detail = raw
+    .split('\n')
+    .filter((l) => /^\s*(❌|🔎|📝|\s+・|\s+\[)/.test(l))
+    .join('\n');
+
+  let reportPath = null;
+  if (detail.trim()) {
+    reportPath = path.join(
+      require('os').tmpdir(),
+      'bantou_gate_report_' + Date.now() + '.txt'
+    );
+    fs.writeFileSync(
+      reportPath,
+      '検査対象: ' + targetPath + '\n' +
+      '★このファイルはあなた（人）が手元で開くためのものです。AIはこの中身を読んでいません。\n' +
+      '─'.repeat(60) + '\n' + detail + '\n',
+      'utf8'
+    );
+  }
+
+  // ★★ verdict は3軸で決める。初版は hit_count しか見ておらず、
+  //   「内部メモ3件・固有名0件」のファイルに合格を出していた（＝2026-08-03 に実際に起きた
+  //   規約ページの内部メモ公開と同じ中身で通る）。判定だけ読む人には、その穴が見えない。
+  const nHit = hits ? Number(hits) : 0;
+  const nCand = candidates ? Number(candidates) : 0;
+  const nInternal = internal ? Number(internal) : 0;
+
+  // ★★ 検査器を2本走らせて、どちらかが鳴ったら鳴らす（2026-08-20）。
+  //   由来＝この日の通し検品で、うちの版だけが「田中さんの件は保留中です」を見逃した。
+  //   check_anonymization.js とフリー版のパターン検査は、拾う層が違う。
+  //   片方だけを合格の根拠にしない（→ output-gate.md「1つの✅を全体の合格にしない」）。
+  const second = secondOpinion(targetPath);
+
+  // ★2本目が拾ったものも、同じ「人が読むファイル」へ入れる（読む場所を分けない）
+  if (second.detail.trim()) {
+    if (!reportPath) {
+      reportPath = path.join(require('os').tmpdir(), 'bantou_gate_report_' + Date.now() + '.txt');
+      fs.writeFileSync(
+        reportPath,
+        '検査対象: ' + targetPath + '\n' +
+        '★このファイルはあなた（人）が手元で開くためのものです。AIはこの中身を読んでいません。\n',
+        'utf8'
+      );
+    }
+    fs.appendFileSync(
+      reportPath,
+      '\n' + '─'.repeat(60) + '\n■ パターン検査（辞書を使わない側）\n\n' + second.detail + '\n',
+      'utf8'
+    );
+  }
+
+  const nInternalAll = Math.max(nInternal, second.internal);
+  const nCandAll = Math.max(nCand, second.candidates);
+
+  const reasons = [];
+  if (nHit > 0) reasons.push('辞書の固有名');
+  if (nInternalAll > 0) reasons.push('内部メモらしき記述');
+  if (nCandAll > 0) reasons.push('辞書に無い固有名の候補（要目視）');
+
+  return {
+    files_scanned: files ? Number(files) : 0,
+    hit_count: nHit,
+    kind_count: Object.keys(kinds).length,        // ★種類の「数」だけ。語は返さない
+    dictionary_free_candidates: nCandAll,
+    internal_note_count: nInternalAll,
+    dictionary_one_sided: oneSided ? Number(oneSided) : 0,
+    // ★2本のうちどちらが何件拾ったか（数だけ。語は含まない）
+    detectors: {
+      '辞書チェッカー': { 内部メモ: nInternal, 固有名候補: nCand },
+      'パターン検査': { 内部メモ: second.internal, 固有名候補: second.candidates },
+    },
+    verdict: reasons.length ? '要確認' : 'この2つの検査では検出なし',
+    verdict_reasons: reasons,                     // ★何で引っかかったかの「系統」。語は含まない
+    detail_report: reportPath
+      ? '詳細は ' + reportPath + ' に書きました。★人が手元で開いてください（AIは読みません）'
+      : null,
+    note:
+      'この結果は「この2つの検査で引っかかった数」です。辞書に無い綴りは辞書側では永遠に0件になります。' +
+      '0件は「検査して問題なし」ではありません。' +
+      '★検出された語そのものは、意図的にこの結果へ含めていません（中身をクラウドへ渡さないため）。',
+  };
+}
+
+/**
+ * 辞書つきチェッカーが無いときの検査（＝配った先での既定の姿）。
+ * ★フリー版と同じ3系統。利用者の辞書は フリー版側の loadDict が拾う。
+ */
+function inspectWithoutDictionary(targetPath) {
+  const dict = FREE.loadDict();
+  const files = FREE.walk(targetPath, [], 0);
+  if (!files.length) throw new Error('検査できるファイルがありません: ' + targetPath);
+  const merged = { dictHits: [], internal: [], candidates: [] };
+  for (const f of files) {
+    const r = FREE.inspectText(fs.readFileSync(f, 'utf8'), dict);
+    merged.dictHits.push(...r.dictHits);
+    merged.internal.push(...r.internal);
+    merged.candidates.push(...r.candidates);
+  }
+  const out = FREE.summarize(merged, dict, targetPath);
+  out.files_scanned = files.length;
+  return out;
+}
+
+/**
+ * フリー版（＝正本）のパターン検査を、同じ対象に当てる。
+ * ★返すのは件数だけ。詳細は人向けのファイルへ追記する。
+ */
+function secondOpinion(targetPath) {
+  const empty = { path: null, words: [] };   // 辞書は上の本体が見ているので、ここでは使わない
+  try {
+    const files = FREE.walk(targetPath, [], 0);
+    let internal = 0, candidates = 0;
+    const detail = [];
+    for (const f of files) {
+      const r = FREE.inspectText(fs.readFileSync(f, 'utf8'), empty);
+      internal += r.internal.length;
+      candidates += r.candidates.length;
+      if (r.internal.length || r.candidates.length) {
+        detail.push(FREE.report(f, r, empty));
+      }
+    }
+    return { internal, candidates, detail: detail.join('\n\n') };
+  } catch (_) {
+    return { internal: 0, candidates: 0, detail: '' };
+  }
+}
+
+// ---------------------------------------------------------------- 道具の定義
+
+const TOOLS = [
+  {
+    name: 'check_file',
+    description:
+      'ファイル（またはフォルダ）に、外へ出してはいけない固有名・内部メモが含まれていないかを検査します。' +
+      '★ファイルを読むのはこのサーバーであって、あなた（AI）ではありません。' +
+      '返るのは件数と種別だけで、本文・該当行・該当語の周辺は返りません。' +
+      '顧客名の入った下書きを、中身をクラウドへ渡さずに検査できます。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: {
+          type: 'string',
+          description: '検査するファイルまたはフォルダのパス（このサーバーが読みます）',
+        },
+      },
+      required: ['path'],
+    },
+  },
+  {
+    name: 'remember',
+    description:
+      '気づいたこと・失敗・学びを1行だけ記録します。★会話を止めずに使ってください（記録は促しであって関所ではありません）。' +
+      '同じ型キーが3件たまったら「ルールか手順に落とす番」だと返します。★溜めるのが目的ではありません。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        text: { type: 'string', description: '何が起きたか・なぜか（1行）' },
+        tag: { type: 'string', description: 'failure（失敗）／insight（発見）／value（価値観）／fact（事実）' },
+        sig: { type: 'string', description: '型キー。同じ失敗を数えるための短い名前（例: 確かめる前に断定した）' },
+      },
+      required: ['text'],
+    },
+  },
+  {
+    name: 'recall',
+    description: '最近の記録を引きます。★一日の終わりに見て、ルールに落とすものを選んでください。番号（id）が返るので settle で片づけられます。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        days: { type: 'number', description: '何日ぶんか（既定7）' },
+        only_open: { type: 'boolean', description: '未処理だけに絞る' },
+      },
+    },
+  },
+  {
+    name: 'review',
+    description:
+      '溜まったものを型ごとに数えて、★**次に何をするか**を返します。3件たまった型は「ルールにする番」、' +
+      'ルールにした後で再発した型は「ルールが効いていない」と出ます。★一日の終わりに呼んでください。',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'settle',
+    description:
+      '片づけた記録に印を付けます。★鳴った音を閉じる口です。ルールに落としたときは sig と ruled_to を渡してください。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        ids: { type: 'array', items: { type: 'number' }, description: '片づけた記録の番号' },
+        sig: { type: 'string', description: 'ルールにした型キー' },
+        ruled_to: { type: 'string', description: 'どこに書いたか' },
+      },
+    },
+  },
+  {
+    name: 'checkup',
+    description: '番頭がちゃんと入っているかを自己点検します。',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'install',
+    description:
+      '★スキルと道具の**実体**を、利用者のフォルダへ置きます。' +
+      'これを一度やれば、スキルを持っていない方でも、そのまま使えるようになります。' +
+      '（画像・スライド・文字起こし・自己健診・週次メンテ・スキルの作り方・文章の関所・引っ越し手順）' +
+      '★同じ名前のファイルは飛ばします。入れ替えるときも元は .bak へ寄せて、消しません。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        to: { type: 'string', description: '置き場所（仕事のフォルダ）' },
+        overwrite: { type: 'boolean', description: '同じ名前があっても入れ替える（元は .bak へ寄せます）' },
+      },
+      required: ['to'],
+    },
+  },
+  {
+    name: 'list_installable',
+    description: '★install で置けるものの一覧を見ます。置く前に、何が入るか確かめられます。',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'policy',
+    description:
+      '★機密の扱いをどの段にするかを見る／変えます。' +
+      '段0＝そのまま渡す（絶対層だけ止める） / 段1＝伏せて渡す / 段2＝判定だけ返す。' +
+      '★秘密鍵・パスワード・カード番号などの「絶対層」は、どの段でも必ず止まります（選べません）。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        dir: { type: 'string', description: '仕事のフォルダ（省略すると今の場所）' },
+        level: { type: 'number', description: '0 / 1 / 2。省略すると、いまの段を見るだけ' },
+      },
+    },
+  },
+  {
+    name: 'make_dict',
+    description:
+      '★伏せたい言葉の辞書を、一緒に作ります。フォルダを検査して**候補を手元のファイルへ書き出し**、' +
+      'AIには件数だけ返します。★様式（ひな形）も一緒に置くので、あとはご自身で選んでください。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        from: { type: 'string', description: '見に行くフォルダ（普段の仕事の場所）' },
+        to: { type: 'string', description: '辞書を置く場所（省略すると from と同じ）' },
+      },
+      required: ['from'],
+    },
+  },
+  {
+    name: 'mask_file',
+    description:
+      '★ファイルを「伏せた版」にします。AIへ返すのは**伏せた版の場所と件数だけ**で、' +
+      '対応表も実名も渡りません。★この伏せた版だけを読んで、直してください。' +
+      '鍵やパスワードは伏せずに**削除**します（戻しません）。',
+    inputSchema: {
+      type: 'object',
+      properties: { path: { type: 'string', description: '正本のファイル' } },
+      required: ['path'],
+    },
+  },
+  {
+    name: 'unmask_file',
+    description:
+      '★直した「伏せた版」を、正本へ戻します。' +
+      '戻す前に3つ確かめます（表に無い印／使われなかった印／★AIが新しく書いた固有名）。' +
+      'ひとつでも合わなければ**書きません**。元のファイルは .bak として残します。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: '直した「伏せた版」のファイル' },
+        to: { type: 'string', description: '書き先（省略すると元の正本）' },
+        force: { type: 'boolean', description: '★確かめで止まっても進める（おすすめしません）' },
+      },
+      required: ['path'],
+    },
+  },
+  {
+    name: 'render',
+    description:
+      '★AIが書いた「伏せたままの文」を、実名に戻して手元のファイルに出します。' +
+      'AIは印しか見ていません。**開くのは人**です。' +
+      '（チャット欄そのものは書き換えられないので、すぐ横のファイルに出す形です）',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mask_id: { type: 'string', description: '伏せた版の先頭にある印（bantou-mask:◯◯）' },
+        text: { type: 'string', description: '伏せたままの文（★印のまま渡してください）' },
+        to: { type: 'string', description: '書き先（省略すると自動）' },
+        dir: { type: 'string', description: '対応表のあるフォルダ（省略すると今の場所）' },
+      },
+      required: ['mask_id', 'text'],
+    },
+  },
+  {
+    name: 'list_supplements',
+    description:
+      '★お使いいただけるサプリの一覧を見ます（給与・規程・助成金・36協定など）。' +
+      '名前・版・大きさと、いま入っているかどうかが分かります。★中身はまだ取りません。',
+    inputSchema: {
+      type: 'object',
+      properties: { to: { type: 'string', description: '仕事のフォルダ（入っているかを見るため）' } },
+    },
+  },
+  {
+    name: 'about_me',
+    description:
+      '★主のこと（北極星・呼び方・大事にしていること）を見ます。' +
+      '北極星がまだなら、決め方をご案内します。★ここが空のまま使い続けないでください。',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'set_polaris',
+    description:
+      '★北極星（何のためにいるか）を決めて、書き留めます。' +
+      '「いま、いちばん面倒だと思っていることは何ですか」→「それが無くなったら、その時間で何をしたいですか」' +
+      '→「逆に、人の手でやりたいことは何ですか」の順で聞いてから呼んでください。★「効率化」で止めないこと。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        text: { type: 'string', description: '北極星（1〜2行）' },
+        why: { type: 'string', description: 'そう決めた理由（本人の言葉で）' },
+      },
+      required: ['text'],
+    },
+  },
+  {
+    name: 'learn',
+    description:
+      '★主のことを覚えます。★出所を必ず添えてください（本人／資料／実測／推測）。' +
+      'これが無いと、私の推測が、いつのまにかご本人の言葉として残ります。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        kind: { type: 'string', description: '呼び方 / 価値観 / 手を出さない / 事実' },
+        text: { type: 'string', description: '覚える中身' },
+        source: { type: 'string', description: '出所：本人 / 資料 / 実測 / 推測' },
+      },
+      required: ['kind', 'text'],
+    },
+  },
+  {
+    name: 'check_env',
+    description:
+      '★下ごしらえ（Node.js / Python / Playwright）が揃っているかを見て、**次の一手だけ**をご案内します。' +
+      '★Playwright は「作った画面を目で見て確かめる」ために使います。全部そろっていなくても、他の道具は使えます。',
+    inputSchema: {
+      type: 'object',
+      properties: { want: { type: 'array', items: { type: 'string' }, description: 'node / python / playwright' } },
+    },
+  },
+  {
+    name: 'setup_google',
+    description:
+      '★Googleのやること（Tasks）とつなぐ手順を、**いま止まっているところだけ**ご案内します。' +
+      '★あとからで構いません。つながなくても、番頭の他の道具は全部使えます。',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'connect_google',
+    description:
+      '★Googleにつなぎます（ブラウザが開いて、ご本人が許可します）。' +
+      'つながると「番頭のやること」というリストを1本だけ作ります。★ふだんのリストは触りません。',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'list_tasks',
+    description: '★やることを見ます。期限の近い順に出ます。終わったものは complete_task で閉じてください。',
+    inputSchema: {
+      type: 'object',
+      properties: { all: { type: 'boolean', description: '終わったものも含める' } },
+    },
+  },
+  {
+    name: 'add_task',
+    description:
+      '★やることを登録します。「あとで」「忘れないで」「来週まで」と言われたら、その場で登録してください。' +
+      '★人に覚えておかせない。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'やることの中身' },
+        due: { type: 'string', description: '期限（YYYY-MM-DD）' },
+        notes: { type: 'string', description: '覚え書き' },
+      },
+      required: ['title'],
+    },
+  },
+  {
+    name: 'complete_task',
+    description: '★やることを終わりにします。題の一部でも探せます。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: '題（一部でよい）' },
+        id: { type: 'string', description: '分かっていれば' },
+      },
+    },
+  },
+  {
+    name: 'sync_core',
+    description:
+      '★番頭の核（安全境界・仕事の型・記憶のしかた）とルールを取ってきて、お手元に控えます。' +
+      '鍵が要ります。★一度取れば、切れてもお手元の控えは読めます（新しい版だけが来なくなります）。' +
+      '取ったあとは、AIの窓を開き直してください。',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'open_shelf',
+    description:
+      '★サプリの棚を、ブラウザで開きます。一覧を見て、入れる／外すを選べます。' +
+      'ボタンを押すと「番頭ゲートで◯◯を入れて」がコピーされるので、そのまま貼ってください。' +
+      '★このページは利用者のパソコンの中にできます（外につながりません）。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        to: { type: 'string', description: '仕事のフォルダ' },
+        no_open: { type: 'boolean', description: '開かずに、置いた場所だけ返す' },
+      },
+    },
+  },
+  {
+    name: 'add_supplement',
+    description:
+      '★サプリを1本、仕事のフォルダへ入れます。' +
+      'お手元で書き換えられているファイルには触りません。★入れたあと SKILL.md をお読みください。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'サプリの名前（list_supplements で見た名前）' },
+        to: { type: 'string', description: '仕事のフォルダ' },
+      },
+      required: ['name'],
+    },
+  },
+  {
+    name: 'remove_supplement',
+    description:
+      '★サプリを外します。**消しません**。「_外したサプリ」へ移すだけなので、あとで戻せます。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'サプリの名前' },
+        to: { type: 'string', description: '仕事のフォルダ' },
+      },
+      required: ['name'],
+    },
+  },
+  {
+    name: 'tidy',
+    description:
+      '★フォルダの散らかりを診て、片づけます。**apply を付けないと何も動きません**。' +
+      '寄せるのは「同じ中身のファイルの2つ目以降」と「作業の残骸（.bak / .old / ~$）」だけです。' +
+      '★「古い」「大きい」「空」は動かしません（使っていないことと、要らないことは別なので）。' +
+      '★消しません。「_かたづけ」へ移すだけで、tidy_undo で全部戻せます。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        dir: { type: 'string', description: '診るフォルダ' },
+        days: { type: 'number', description: '何日さわっていないものを「古い」とするか（既定180・報告のみ）' },
+        apply: { type: 'boolean', description: '実際に寄せる（付けないと下見だけ）' },
+      },
+      required: ['dir'],
+    },
+  },
+  {
+    name: 'tidy_undo',
+    description: '★片づけで寄せたものを、記録から全部元に戻します。',
+    inputSchema: {
+      type: 'object',
+      properties: { dir: { type: 'string', description: '片づけたフォルダ' } },
+      required: ['dir'],
+    },
+  },
+  {
+    name: 'update',
+    description:
+      '★置いてあるスキルや道具を、新しい版にします。' +
+      '**お手元で書き換えられたものには触りません**（新しい版を隣に .new として置くだけ）。' +
+      '入れ替えたものも、元を .bak として残します。★まず apply なしで下見してください。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        to: { type: 'string', description: '置いてある場所（install したフォルダ）' },
+        apply: { type: 'boolean', description: '実際に入れ替える（付けないと下見だけ）' },
+      },
+      required: ['to'],
+    },
+  },
+  {
+    name: 'check_text',
+    description:
+      '渡された文字列を検査します。★この道具は文字列を引数に取るので、その文字列はあなたの文脈に入ります。' +
+      '機密を含む可能性があるものは check_file を使ってください。',
+    inputSchema: {
+      type: 'object',
+      properties: { text: { type: 'string', description: '検査する文字列' } },
+      required: ['text'],
+    },
+  },
+];
+
+// ★常に効く核。コードに埋めず別ファイルにする（resources でも同じものを出すため）
+// ★核とルールの置き場（2026-08-21 主の裁定「C」）
+//   FL＝踏んだ穴の記録。**サプリより価値がある**ので、鍵の内側に置く。
+//   npm には器だけを入れ、核は鍵で取ってくる。取ったら手元に控える。
+//   ★切れ方＝**控えは読める／新しい版は来ない**。払い続ける理由が「更新」になる。
+const CORE_HOME = path.join(
+  process.env.BANTO_HOME || path.join(require('os').homedir(), '.banto'), 'core');
+
+function coreFile(rel) { return path.join(CORE_HOME, rel.split('/').join(path.sep)); }
+
+function loadInstructions() {
+  let core = null;
+  // ① 手元の控え（★鍵が切れても読める）
+  try { core = fs.readFileSync(coreFile('instructions.md'), 'utf8'); } catch (_) {}
+  // ② 開発中は同じフォルダのものを使う（配布物には入っていない）
+  if (!core) { try { core = fs.readFileSync(path.join(__dirname, 'instructions.md'), 'utf8'); } catch (_) {} }
+  const 核なし = !core;
+  if (核なし) {
+    // ★無いなら、無いと言う。番頭のふりをさせない
+    //   ★ただし「いまの状態」は下で必ず足す（核が無くても、記録と下ごしらえは動くので）
+    core = [
+      'このMCPは「番頭ゲート」です。いまは**検査と記録だけ**が使えます。',
+      '',
+      '★番頭の核（安全境界・仕事の型・記憶のしかた）とルールは、まだ入っていません。',
+      'お手元に鍵がある場合は、次のように頼んでください。',
+      '',
+      '    「番頭の核を取ってきて」（sync_core）',
+      '',
+      '鍵が無い場合、使えるのは次だけです。',
+      '  ・check_file … ★中身をAIに見せずにファイルを検査する',
+      '  ・remember / recall / review / settle … 気づいたことを1行ずつ記録し、3件たまったら知らせる',
+      '  ・tidy … 散らかりを診る（★何も動かしません）',
+      '',
+      '★これらは鍵が無くてもお使いいただけます。',
+    ].join('\n');
+  }
+
+  // ★起動のたびの自己診断を、ここへ足す（2026-08-21）。
+  //   MCPは常駐しないので定期実行はできないが、**instructions は毎回作られる**。
+  //   ここに載せれば「番頭が自分から言い出す」形になり、**人が覚えておく必要がなくなる**。
+  //   （→ tooling-check.md「自走する仕組みを作ったら、人に届く口を必ず作る」）
+  const 行 = [];
+
+  // ① ★北極星（2026-08-21 主「北極星を決めても更新されない」）
+  //    ★決まるまで毎回出す。空のまま使い続けさせない
+  //    ★核が無いときは出さない（番頭になっていないので、北極星を聞く場面ではない）
+  try {
+    const me = ME.quick();
+    if (!核なし && (!me.ある || !me.北極星)) {
+      行.push('★**北極星がまだ決まっていません。** 何のためにこの番頭がいるのかを、最初に決めてください。');
+      行.push('　「いま、いちばん面倒だと思っていることは何ですか」から始めて、');
+      行.push('　「それが無くなったら、その時間で何をしたいですか」まで聞いてから set_polaris を呼びます。');
+      行.push('　★「効率化」で止めないこと。その先まで聞けて、初めて判断の基準になります。');
+    }
+  } catch (_) {}
+
+  // ② ★やること（2026-08-21 主「タスク連携後は、新規タブでタスクも見るようにする」）
+  try {
+    const t = GT.quickCount();
+    if (t) {
+      行.push('やること ' + t.残り + ' 件' + (t.期限切れ ? '（★期限切れ ' + t.期限切れ + ' 件）' : '') +
+        '　→「やること見せて」で開きます');
+    } else if (!GT.state().つながっている) {
+      行.push('やること：まだGoogleとつながっていません（「Googleの手順を教えて」で1手ずつご案内します。★あとで構いません）');
+    }
+  } catch (_) {}
+
+  // ③ 記録（3件たまったら鳴る）
+  try { const d = FREE.selfDiagnosis(); if (d) 行.push(d); } catch (_) {}
+
+  // ④ 下ごしらえ（★足りないものを1つだけ）
+  try {
+    const e = ENV.guide();
+    if (e.足りないもの) 行.push('下ごしらえ：' + e.次にすること.何が + '（「下ごしらえを見て」で手順が出ます）');
+  } catch (_) {}
+
+  if (行.length) core += '\n\n---\n\n## ★いまの状態（起動のたびに自動で診ています）\n\n' + 行.join('\n') + '\n';
+  return core;
+}
+
+// ★詳しいルールは resources で出す。instructions は長さに限りがあるので核だけ。
+// ★毎回作り直す（sync_core で増えたぶんを、次の起動から拾うため）
+function resources() {
+  const out = [];
+  const seen = new Set();
+  const add = (rel, abs, name, desc) => {
+    if (seen.has(rel)) return;
+    seen.add(rel);
+    out.push({ uri: 'banto://' + rel, name, description: desc, mimeType: 'text/markdown', _path: abs });
+  };
+  // ① 手元の控え（★鍵で取ってきたもの。切れても読める）
+  // ② 同じフォルダ（開発中だけ）
+  for (const base of [CORE_HOME, __dirname]) {
+    try {
+      if (fs.existsSync(path.join(base, 'instructions.md'))) {
+        add('core', path.join(base, 'instructions.md'), '番頭の核（常に効く分）', '安全境界・仕事の型・記憶のしかた');
+      }
+      const rd = path.join(base, 'rules');
+      for (const f of fs.readdirSync(rd)) {
+        if (!/\.md$/i.test(f)) continue;
+        const n = f.replace(/\.md$/i, '');
+        add('rules/' + encodeURIComponent(n), path.join(rd, f), n, '番頭のルール');
+      }
+    } catch (_) { /* 無くても動く */ }
+  }
+  return out;
+}
+
+// ───────────────────────────────── 実体を利用者の手元へ置く（install）
+//
+// ★コンセプト（2026-08-21 主が確認）＝
+//   **利用者がスキルを持っていなくても、このMCPがあればスキルを使える。**
+//   ルールと核は resources / instructions で配れるが、
+//   ★**プログラムの実体（gen.js・Python・lint.js）は、ファイルとして手元に無いと動かない。**
+//   その1本だけが足りていなかった。
+//
+// ★正本の置き場を分ける（2か所に同じものを置かない）
+//   核・ルール  → MCP（instructions / resources）
+//   実体・作法  → ここ（利用者のフォルダ）
+//   記憶        → MCP（tools）
+const PAYLOAD = path.join(__dirname, 'payload');
+// ★版は package.json だけに書く（2026-08-21）。
+//   コードにも書くと、上げ忘れて**別々の版を名乗る**。正本は1つ。
+const VERSION = (() => {
+  for (const p of ['./package.json', '../package.json']) {
+    try { return require(p).version; } catch (_) {}
+  }
+  return '0.0.0-dev';
+})();
+
+// ★見せ方の段と、伏せる／戻す（2026-08-21）
+const PRIV = require('./privacy.js');
+const GT = require('./gtasks.js');       // やること（Google Tasks）
+const ENV = require('./env.js');         // 下ごしらえ（Node / Python / Playwright）
+const ME = require('./subconscious.js'); // 主のこと（北極星・価値観）
+function stamp() {
+  const d = new Date(), p = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
+}
+
+// ★別に用意が要るもの。**黙って置かない**（動かないものを置いて「入れました」と言わない）
+const NEEDS = {
+  'skills/transcribe': 'Python と Whisper が別に要ります（★入っていません）',
+  'skills/image-gen': '画像生成サービスの鍵が別に要ります（★利用者ご自身のもの）',
+  'skills/remember': 'Googleカレンダー・ToDoと繋ぐ場合だけ、別に設定が要ります',
+};
+
+function listPayload() {
+  const out = [];
+  if (!fs.existsSync(PAYLOAD)) return out;
+  (function w(d) {
+    for (const e of fs.readdirSync(d)) {
+      const p = path.join(d, e);
+      fs.statSync(p).isDirectory() ? w(p) : out.push(path.relative(PAYLOAD, p).split('\\').join('/'));
+    }
+  })(PAYLOAD);
+  return out.sort();
+}
+
+// ★置いたときの中身を控えておく。**あとで「利用者が書き換えたか」を見分けるため**。
+//   これが無いと update は「全部上書き」か「何もしない」の二択になり、
+//   育てたものを壊すか、古いまま置き去るかのどちらかになる。
+const MANIFEST = '.bantou-install.json';
+const digest = (p) => {
+  try { return require('crypto').createHash('sha256').update(fs.readFileSync(p)).digest('hex').slice(0, 16); }
+  catch (_) { return null; }
+};
+function readManifest(dest) {
+  try { return JSON.parse(fs.readFileSync(path.join(dest, MANIFEST), 'utf8')); }
+  catch (_) { return { version: null, files: {} }; }
+}
+function writeManifest(dest, m) {
+  m.updated_at = stamp();
+  fs.writeFileSync(path.join(dest, MANIFEST), JSON.stringify(m, null, 2), 'utf8');
+}
+
+function install(to, overwrite) {
+  const files = listPayload();
+  if (!files.length) throw new Error('配るものが見つかりません（payload が空です）');
+  const dest = path.resolve(String(to || '').trim());
+  if (!dest || dest === path.parse(dest).root) throw new Error('置き場所を指定してください');
+
+  const m = readManifest(dest);
+  const placed = [], skipped = [], backed = [];
+  for (const f of files) {
+    const src = path.join(PAYLOAD, f);
+    const dst = path.join(dest, f);
+    if (fs.existsSync(dst)) {
+      if (!overwrite) { skipped.push(f); continue; }
+      // ★上書きするときも消さない。控えへ寄せる
+      const bak = dst + '.bak-' + stampCompact();
+      try { fs.renameSync(dst, bak); backed.push(f); } catch (_) { skipped.push(f); continue; }
+    }
+    fs.mkdirSync(path.dirname(dst), { recursive: true });
+    fs.copyFileSync(src, dst);
+    m.files[f] = digest(src);     // ★配った時点の中身
+    placed.push(f);
+  }
+  m.version = VERSION;
+  try { writeManifest(dest, m); } catch (_) {}
+
+  // 置いたものに対応する「別に要るもの」だけを出す
+  const needs = Object.entries(NEEDS)
+    .filter(([k]) => placed.some((f) => f.indexOf(k) === 0))
+    .map(([k, v]) => k + '：' + v);
+
+  return {
+    置き場所: dest,
+    置いた件数: placed.length,
+    飛ばした件数: skipped.length,
+    控えへ寄せた件数: backed.length,
+    置いたもの: placed,
+    飛ばしたもの: skipped.length ? skipped : undefined,
+    別に要るもの: needs.length ? needs : undefined,
+    note:
+      (skipped.length
+        ? '★同じ名前のファイルがあったので飛ばしました。入れ替えるなら overwrite を付けてください（元は .bak へ寄せます）。'
+        : '') +
+      '★ルールと番頭の核は、このMCPが持っています（ファイルとして置いていません）。' +
+      '★置いたものは利用者のものです。書き換えて構いません。',
+  };
+}
+
+/**
+ * 新しい版に入れ替える。
+ * ★鉄則＝**利用者が書き換えたものには触らない。**
+ *   置いたときの中身（マニフェスト）と、いまの中身を比べて判定する。
+ *   ・同じ    → 触っていない → 入れ替えてよい
+ *   ・違う    → ★書き換えている → **触らない**。新しい版を隣に `.new` として置くだけ
+ *   ・無い    → 新しく足す
+ * ★消さない・上書きしない・黙って変えない。この3つを守る。
+ */
+function update(to, apply) {
+  const dest = path.resolve(String(to || '').trim());
+  if (!fs.existsSync(dest)) throw new Error('見つかりません: ' + dest);
+  const m = readManifest(dest);
+  const files = listPayload();
+  if (!files.length) throw new Error('配るものが見つかりません（payload が空です）');
+
+  const 入れ替える = [], 新しく足す = [], 触らない = [], 変わっていない = [];
+  for (const f of files) {
+    const src = path.join(PAYLOAD, f);
+    const dst = path.join(dest, f);
+    const now = digest(src);
+    if (!fs.existsSync(dst)) { 新しく足す.push(f); continue; }
+    const here = digest(dst);
+    const when = m.files[f] || null;
+    if (here === now) { 変わっていない.push(f); continue; }
+    if (when && here === when) 入れ替える.push(f);      // 配ったまま＝触っていない
+    else 触らない.push(f);                               // ★書き換えている（または記録が無い）
+  }
+
+  const result = {
+    置き場所: dest,
+    いまの版: m.version || '（記録なし）',
+    新しい版: VERSION,
+    入れ替える件数: 入れ替える.length,
+    新しく足す件数: 新しく足す.length,
+    触らない件数: 触らない.length,
+    変わっていない件数: 変わっていない.length,
+    触らないもの: 触らない.length ? 触らない : undefined,
+  };
+
+  if (!apply) {
+    result.note =
+      '★まだ何もしていません（下見です）。' +
+      (触らない.length
+        ? '★' + 触らない.length + '件は、お手元で書き換えられているので触りません。新しい版を見たい場合は apply を付けると、隣に .new として置きます。'
+        : '') +
+      ' 実行するときは apply を付けてください。';
+    return result;
+  }
+
+  const done = [], added = [], asNew = [];
+  for (const f of 入れ替える) {
+    const dst = path.join(dest, f);
+    try {
+      fs.renameSync(dst, dst + '.bak-' + stampCompact());   // ★消さずに控えへ
+      fs.copyFileSync(path.join(PAYLOAD, f), dst);
+      m.files[f] = digest(path.join(PAYLOAD, f));
+      done.push(f);
+    } catch (_) {}
+  }
+  for (const f of 新しく足す) {
+    const dst = path.join(dest, f);
+    fs.mkdirSync(path.dirname(dst), { recursive: true });
+    fs.copyFileSync(path.join(PAYLOAD, f), dst);
+    m.files[f] = digest(path.join(PAYLOAD, f));
+    added.push(f);
+  }
+  for (const f of 触らない) {
+    // ★元は動かさない。新しい版を隣に置くだけ。見比べて、要るところだけ写してもらう
+    try { fs.copyFileSync(path.join(PAYLOAD, f), path.join(dest, f + '.new')); asNew.push(f + '.new'); } catch (_) {}
+  }
+  m.version = VERSION;
+  try { writeManifest(dest, m); } catch (_) {}
+
+  result.入れ替えた = done.length;
+  result.足した = added.length;
+  result.隣に置いた新しい版 = asNew.length ? asNew : undefined;
+  result.note =
+    '★入れ替えたものは、元を .bak として残しています（消していません）。' +
+    (asNew.length
+      ? '★お手元で書き換えられていた ' + asNew.length + ' 件は、**元のまま**です。新しい版を .new として隣に置いたので、見比べて必要なところだけ写してください。'
+      : '');
+  return result;
+}
+
+/**
+ * 辞書づくりの伴走。
+ * ★候補は**手元のファイルへ書き出す**。AIには件数だけ返す（候補そのものが顧客名なので）。
+ *   様式（ひな形）も一緒に置いて、あとは人が選ぶ。★機械に決めさせない。
+ */
+function makeDict(from, to) {
+  const src = path.resolve(String(from || '').trim());
+  if (!fs.existsSync(src)) throw new Error('見つかりません: ' + src);
+  const dst = path.resolve(String(to || src).trim());
+  const dict = FREE.loadDict();
+
+  const files = FREE.walk(src, [], 0);
+  const count = new Map();
+  for (const f of files) {
+    let r;
+    try { r = FREE.inspectText(fs.readFileSync(f, 'utf8'), dict); } catch (_) { continue; }
+    for (const c of r.candidates) count.set(c.text, (count.get(c.text) || 0) + c.count);
+  }
+  // ★出現の多い順（よく出る名前ほど、伏せる価値がある）
+  const list = [...count.entries()].sort((a, b) => b[1] - a[1]);
+
+  const draft = path.join(dst, '辞書の候補.txt');
+  const lines = [
+    '伏せたい言葉の候補',
+    '★この一覧は、あなたが読むためのものです。AIには件数しか渡していません。',
+    '─'.repeat(50),
+    '',
+    '使い方：',
+    '  1. 下の一覧から、伏せたい言葉に印（★）を付けてください',
+    '  2. 印を付けたものを bantou-gate-dict.json の "words" に書き写します',
+    '  3. ★人の名前・会社名は、表記ゆれも一緒に入れてください',
+    '     （例：「山田」「山田様」「山田さん」「ヤマダ」）',
+    '',
+    '★機械は「名前らしい形」を拾っただけです。名前でないものも混ざっています。',
+    '★逆に、形が違う名前は拾えていません。ご自身で足してください。',
+    '',
+    '─'.repeat(50),
+    '',
+  ];
+  list.forEach(([w, n]) => lines.push('[ ] ' + w + '   （' + n + '回）'));
+  fs.mkdirSync(dst, { recursive: true });
+  fs.writeFileSync(draft, lines.join('\n'), 'utf8');
+
+  // 様式（ひな形）。★既にあれば触らない
+  const tpl = path.join(dst, 'bantou-gate-dict.json');
+  let tplMade = false;
+  if (!fs.existsSync(tpl)) {
+    fs.writeFileSync(tpl, JSON.stringify({
+      _説明: '伏せたい言葉をここに並べます。表記ゆれも1つずつ入れてください。',
+      words: ['（ここに書きます）'],
+    }, null, 2), 'utf8');
+    tplMade = true;
+  }
+
+  return {
+    見たファイル数: files.length,
+    候補の数: list.length,
+    候補の一覧: draft + '  ★人が開いてください（AIは中身を読んでいません）',
+    辞書の様式: tpl + (tplMade ? '（新しく置きました）' : '（既にあったので触っていません）'),
+    いまの辞書: dict.path ? dict.path + '（' + dict.words.length + '語）' : '★まだありません',
+    note: '★候補そのものは返していません。一覧を開いて、伏せたいものを選んでください。' +
+      '★1回で完成させなくて構いません。使いながら足していくものです。',
+  };
+}
+
+/**
+ * 散らかりを診る。★読むだけ。何も動かさない。
+ *   （動かす機能は作らない。人のフォルダで消す・移すのは、後戻りできない）
+ */
+function tidy(dir, days) {
+  const root = path.resolve(String(dir || '').trim());
+  if (!fs.existsSync(root)) throw new Error('見つかりません: ' + root);
+  const oldDays = Number(days) || 180;
+  const now = Date.now();
+
+  const files = [], emptyDirs = [];
+  (function w(d, depth) {
+    if (depth > 8) return;
+    let es;
+    try { es = fs.readdirSync(d); } catch (_) { return; }
+    if (!es.length) { emptyDirs.push(path.relative(root, d)); return; }
+    for (const e of es) {
+      if (e === 'node_modules' || e.startsWith('.git')) continue;
+      const p = path.join(d, e);
+      let st;
+      try { st = fs.statSync(p); } catch (_) { continue; }
+      if (st.isDirectory()) w(p, depth + 1);
+      else files.push({ p, size: st.size, mtime: st.mtimeMs });
+    }
+  })(root, 0);
+
+  // 同じ中身（★大きさが同じものだけハッシュする。全部やると遅い）
+  const bySize = {};
+  for (const f of files) (bySize[f.size] = bySize[f.size] || []).push(f);
+  let dupGroups = 0, dupFiles = 0, dupBytes = 0;
+  for (const list of Object.values(bySize)) {
+    if (list.length < 2 || list[0].size === 0) continue;
+    const h = {};
+    for (const f of list) {
+      const d = digest(f.p);
+      if (d) (h[d] = h[d] || []).push(f);
+    }
+    for (const g of Object.values(h)) {
+      if (g.length < 2) continue;
+      dupGroups++; dupFiles += g.length - 1;
+      dupBytes += g[0].size * (g.length - 1);
+    }
+  }
+
+  const old = files.filter((f) => now - f.mtime > oldDays * 86400000);
+  const big = files.filter((f) => f.size > 20 * 1024 * 1024);
+  const mb = (n) => Math.round(n / 1048576 * 10) / 10;
+
+  const 気づき = [];
+  if (dupGroups) 気づき.push('★同じ中身のファイルが ' + dupGroups + ' 組（' + dupFiles + '件・約' + mb(dupBytes) + 'MB）あります。**どれが正本かを決めてください**');
+  if (old.length) 気づき.push(oldDays + '日さわっていないものが ' + old.length + ' 件あります');
+  if (big.length) 気づき.push('20MBを超えるものが ' + big.length + ' 件あります');
+  if (emptyDirs.length) 気づき.push('空のフォルダが ' + emptyDirs.length + ' 件あります');
+  if (!気づき.length) 気づき.push('気になるところはありませんでした');
+
+  return {
+    見たフォルダ: root,
+    ファイル数: files.length,
+    合計の大きさ: mb(files.reduce((s, f) => s + f.size, 0)) + 'MB',
+    同じ中身の組: dupGroups,
+    余分な件数: dupFiles,
+    古いもの: old.length,
+    大きいもの: big.length,
+    空のフォルダ: emptyDirs.length,
+    気づき,
+    note:
+      '★診ただけです。**何も動かしていません。**' +
+      '★片づけるときは、消さずに「使わないもの」フォルダへ移すところから始めてください。' +
+      '★同じ中身が複数あるときは、消す前に**どれが正本か**を決めるのが先です。',
+  };
+}
+
+// ───────────────────────────────── サプリ（配布口から取る）
+//
+// ★正本はうちの薬局（git管理）。ここは**取ってくるだけ**。書き戻さない。
+// ★通信するのは「一覧」と「取得」のときだけ。**中身は送らない**（鍵のハッシュと名前だけ）。
+// ★取れなくても番頭は動く（基本セットは同梱してある）。
+
+function supEndpoint(fn) {
+  const { url } = licenseConfig();
+  if (!url) return null;
+  return url.replace(/\/rpc\/[^/]+$/, '/rpc/' + fn);
+}
+function licenseConfig() {
+  const c = { key: process.env.BANTOU_LICENSE_KEY || '', url: process.env.BANTOU_LICENSE_URL || '',
+              anonKey: process.env.BANTOU_LICENSE_ANON || '' };
+  try {
+    const j = JSON.parse(fs.readFileSync(path.join(__dirname, 'license', 'config.json'), 'utf8'));
+    c.key = c.key || j.key || '';
+    c.url = c.url || j.url || '';
+    c.anonKey = c.anonKey || j.anonKey || '';
+  } catch (_) {}
+  return c;
+}
+
+function supPost(fn, body) {
+  const { key, anonKey } = licenseConfig();
+  const url = supEndpoint(fn);
+  if (!key || !url || !anonKey) {
+    throw new Error('鍵が設定されていません。サプリは鍵をお預かりしてからお使いいただけます');
+  }
+  const keyHash = require('crypto').createHash('sha256').update(key).digest('hex');
+  const https = require('https');
+  const data = JSON.stringify(Object.assign({ p_key_hash: keyHash }, body));
+  return new Promise((resolve, reject) => {
+    const u = new URL(url);
+    const req = https.request({
+      hostname: u.hostname, path: u.pathname + u.search, method: 'POST',
+      headers: {
+        'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data),
+        apikey: anonKey, Authorization: 'Bearer ' + anonKey,
+      },
+    }, (res) => {
+      let b = '';
+      res.on('data', (d) => (b += d));
+      res.on('end', () => {
+        let j;
+        try { j = JSON.parse(b); } catch (_) { return reject(new Error('応答を読めません')); }
+        if (res.statusCode >= 400) {
+          return reject(new Error((j && (j.message || j.hint)) || ('HTTP ' + res.statusCode)));
+        }
+        resolve(j);
+      });
+    });
+    req.setTimeout(20000, () => req.destroy(new Error('時間切れ（配布口につながりません）')));
+    req.on('error', reject);
+    req.write(data);
+    req.end();
+  });
+}
+
+const SUP_STATE = '.bantou-supplements.json';
+function supState(dir) {
+  try { return JSON.parse(fs.readFileSync(path.join(dir, SUP_STATE), 'utf8')); }
+  catch (_) { return { installed: {} }; }
+}
+function saveSupState(dir, s) {
+  s.updated_at = stamp();
+  fs.writeFileSync(path.join(dir, SUP_STATE), JSON.stringify(s, null, 2), 'utf8');
+}
+
+/**
+ * 番頭の核とルールを、鍵で取ってきて手元に控える。
+ * ★切れ方（C）＝**控えは読める／新しい版は来ない**。
+ *   だから取れなかったときも、控えがあれば「使えます」と言う。無いときだけ「入っていません」。
+ */
+async function syncCore() {
+  const 控え = CORE_HOME;
+  const 前 = (() => { try { return JSON.parse(fs.readFileSync(path.join(控え, '.version.json'), 'utf8')).version; } catch (_) { return null; } })();
+
+  let rows;
+  try {
+    rows = await supPost('get_core', {});
+  } catch (e) {
+    const ある = fs.existsSync(path.join(控え, 'instructions.md'));
+    return {
+      取れませんでした: String(e.message),
+      手元の控え: ある ? '✅ あります（版 ' + (前 || '不明') + '）' : '❌ ありません',
+      note: ある
+        ? '★お手元の控えはそのままお使いいただけます。新しい版だけが来ていません。'
+        : '★核がまだ入っていません。鍵をご確認ください（検査と記録は鍵が無くても使えます）。',
+    };
+  }
+  if (!rows.length) throw new Error('配布口に核がありません');
+
+  fs.mkdirSync(控え, { recursive: true });
+  const 置いた = [];
+  for (const r of rows) {
+    const dst = coreFile(r.path);
+    fs.mkdirSync(path.dirname(dst), { recursive: true });
+    fs.writeFileSync(dst, r.content, 'utf8');
+    置いた.push(r.path);
+  }
+  let 版 = null;
+  try { 版 = await supPost('core_version', {}); } catch (_) {}
+  fs.writeFileSync(path.join(控え, '.version.json'),
+    JSON.stringify({ version: 版, at: stamp(), files: 置いた.length }, null, 2), 'utf8');
+
+  return {
+    取ってきた件数: 置いた.length,
+    版: 版 || '不明',
+    前の版: 前 || '（初めて）',
+    控えの場所: 控え,
+    note: '★次にこの窓を開き直すと、番頭の核が効きます（いまの窓には反映されません）。' +
+      '★控えはお手元に残ります。鍵が切れても読めます（新しい版だけが来なくなります）。',
+  };
+}
+
+async function listSupplements(to) {
+  const rows = await supPost('list_supplements', {});
+  const dir = to ? path.resolve(to) : null;
+  const st = dir ? supState(dir) : { installed: {} };
+  return {
+    使えるサプリ: rows.map((r) => ({
+      名前: r.name, 版: r.version,
+      層: r.tier === 'limited' ? '★限定' : '一般',
+      ファイル数: r.file_count,
+      大きさ: Math.round(r.bytes / 1024) + 'KB',
+      いまの状態: st.installed[r.name]
+        ? (st.installed[r.name].version === r.version ? '入っています' : '★新しい版があります（' + st.installed[r.name].version + '→' + r.version + '）')
+        : '未導入',
+      説明: r.description || null,
+    })),
+    合計: rows.length,
+    note: '★入れるときは add_supplement、外すときは remove_supplement です。' +
+      '★中身はまだ取っていません（名前と大きさだけ見ています）。',
+  };
+}
+
+async function addSupplement(name, to) {
+  const n = String(name || '').trim();
+  if (!n) throw new Error('サプリの名前を指定してください');
+  const dir = path.resolve(String(to || process.cwd()).trim());
+  const rows = await supPost('get_supplement', { p_name: n });
+  if (!rows.length) throw new Error('中身がありません: ' + n);
+
+  const base = path.join(dir, 'supplements', n);
+  const st = supState(dir);
+  const placed = [], skipped = [];
+  for (const r of rows) {
+    const dst = path.join(base, r.path);
+    // ★利用者が書き換えたものは触らない（install / update と同じ考え）
+    if (fs.existsSync(dst)) {
+      const prev = st.installed[n] && st.installed[n].files && st.installed[n].files[r.path];
+      const now = require('crypto').createHash('sha256').update(fs.readFileSync(dst)).digest('hex').slice(0, 16);
+      if (prev && prev !== now) { skipped.push(r.path); continue; }
+    }
+    fs.mkdirSync(path.dirname(dst), { recursive: true });
+    fs.writeFileSync(dst, r.content, 'utf8');
+    placed.push(r.path);
+  }
+  const files = {};
+  for (const r of rows) files[r.path] = require('crypto').createHash('sha256').update(Buffer.from(r.content, 'utf8')).digest('hex').slice(0, 16);
+  const meta = (await supPost('list_supplements', {})).find((x) => x.name === n) || {};
+  st.installed[n] = { version: meta.version || '?', at: stamp(), files };
+  saveSupState(dir, st);
+
+  return {
+    入れたサプリ: n, 版: meta.version || '?',
+    置き場所: base,
+    置いた件数: placed.length,
+    触らなかった件数: skipped.length,
+    触らなかったもの: skipped.length ? skipped : undefined,
+    note: '★お手元で書き換えられていたものは触っていません。' +
+      '★使い方は置き場所の SKILL.md / README.md をお読みください。',
+  };
+}
+
+function removeSupplement(name, to) {
+  const n = String(name || '').trim();
+  const dir = path.resolve(String(to || process.cwd()).trim());
+  const base = path.join(dir, 'supplements', n);
+  if (!fs.existsSync(base)) throw new Error('入っていません: ' + n);
+  // ★消さない。控えへ寄せる（後戻りできる形）
+  const bin = path.join(dir, '_外したサプリ', n + '_' + stampCompact());
+  fs.mkdirSync(path.dirname(bin), { recursive: true });
+  fs.renameSync(base, bin);
+  const st = supState(dir);
+  delete st.installed[n];
+  saveSupState(dir, st);
+  return {
+    外したサプリ: n,
+    寄せた先: bin,
+    note: '★消していません。' + bin + ' に移してあります。要らなければ、ご自身で捨ててください。',
+  };
+}
+
+// ───────────────────────────────── 片づける（★消さない・戻せる）
+//
+// ★2026-08-21 主「ファイルやフォルダがごちゃごちゃになってる人も MCP 使うと整うのが良いよね」
+// ★動かしてよいのは、**人が見なくても判断できるもの**だけにする。
+//   ・同じ中身が複数ある → 1つ残して、残りを寄せる（★どれを残したかと、その理由を出す）
+//   ・作業の残骸（.bak / .old / ~$ / Thumbs.db） → 寄せる
+//   ★「古い」「大きい」は動かさない。使っていないことと、要らないことは別。
+// ★消さない。寄せるだけ。**記録を残して、tidy_undo で全部戻せる**。
+
+const 片づけ先 = '_かたづけ';
+const 片づけ記録 = '_片づけの記録.json';
+const 残骸 = [/\.bak(-[\dA-Za-z-]+)?$/i, /\.old$/i, /^~\$/, /\.tmp$/i, /^Thumbs\.db$/i, /^\.DS_Store$/i, /\.orig$/i];
+
+function tidyPlan(root, oldDays) {
+  const files = [];
+  const emptyDirs = [];
+  (function w(d, depth) {
+    if (depth > 8) return;
+    let es;
+    try { es = fs.readdirSync(d); } catch (_) { return; }
+    if (!es.length) { emptyDirs.push(d); return; }
+    for (const e of es) {
+      if (e === 'node_modules' || e.startsWith('.git') || e === 片づけ先) continue;
+      const p = path.join(d, e);
+      let st;
+      try { st = fs.statSync(p); } catch (_) { continue; }
+      if (st.isDirectory()) w(p, depth + 1);
+      else files.push({ p, name: e, size: st.size, mtime: st.mtimeMs, depth });
+    }
+  })(root, 0);
+
+  // ① 作業の残骸
+  const junk = files.filter((f) => 残骸.some((re) => re.test(f.name)));
+
+  // ② 同じ中身（★大きさが同じものだけハッシュする）
+  const bySize = {};
+  for (const f of files) {
+    if (junk.includes(f) || f.size === 0) continue;
+    (bySize[f.size] = bySize[f.size] || []).push(f);
+  }
+  const dups = [];
+  for (const list of Object.values(bySize)) {
+    if (list.length < 2) continue;
+    const h = {};
+    for (const f of list) {
+      const d = digest(f.p);
+      if (d) (h[d] = h[d] || []).push(f);
+    }
+    for (const g of Object.values(h)) {
+      if (g.length < 2) continue;
+      // ★残すもの＝浅い場所／新しい／名前が短い、の順で選ぶ。**理由を出す**
+      const keep = g.slice().sort((a, b) =>
+        a.depth - b.depth || b.mtime - a.mtime || a.p.length - b.p.length)[0];
+      const why = g.every((f) => f.depth === keep.depth)
+        ? (g.every((f) => f.mtime === keep.mtime) ? '名前がいちばん短い' : 'いちばん新しい')
+        : 'いちばん浅い場所にある';
+      dups.push({ keep, move: g.filter((f) => f !== keep), why });
+    }
+  }
+
+  const now = Date.now();
+  const old = files.filter((f) => !junk.includes(f) && now - f.mtime > (Number(oldDays) || 180) * 86400000);
+  const big = files.filter((f) => f.size > 20 * 1024 * 1024);
+  return { files, junk, dups, old, big, emptyDirs };
+}
+
+function tidy(dir, days, apply) {
+  const root = path.resolve(String(dir || '').trim());
+  if (!fs.existsSync(root)) throw new Error('見つかりません: ' + root);
+  const pl = tidyPlan(root, days);
+  const mb = (n) => Math.round(n / 1048576 * 10) / 10;
+  const rel = (p) => path.relative(root, p).split('\\').join('/');
+
+  const 動かすもの = [];
+  for (const j of pl.junk) 動かすもの.push({ from: j.p, kind: '残骸' });
+  for (const d of pl.dups) for (const m of d.move) 動かすもの.push({ from: m.p, kind: '重複', keep: d.keep.p, why: d.why });
+
+  const 気づき = [];
+  if (pl.dups.length) 気づき.push('同じ中身のファイルが ' + pl.dups.length + ' 組（余分 ' + pl.dups.reduce((s, d) => s + d.move.length, 0) + '件）');
+  if (pl.junk.length) 気づき.push('作業の残骸が ' + pl.junk.length + ' 件（.bak / .old / ~$ など）');
+  if (pl.old.length) 気づき.push((Number(days) || 180) + '日さわっていないものが ' + pl.old.length + ' 件 ★動かしません');
+  if (pl.big.length) 気づき.push('20MBを超えるものが ' + pl.big.length + ' 件 ★動かしません');
+  if (pl.emptyDirs.length) 気づき.push('空のフォルダが ' + pl.emptyDirs.length + ' 件 ★動かしません');
+  if (!気づき.length) 気づき.push('気になるところはありませんでした');
+
+  const base = {
+    見たフォルダ: root,
+    ファイル数: pl.files.length,
+    合計の大きさ: mb(pl.files.reduce((s, f) => s + f.size, 0)) + 'MB',
+    気づき,
+  };
+
+  if (!apply) {
+    return Object.assign(base, {
+      寄せる予定: 動かすもの.length,
+      内訳: 動かすもの.slice(0, 40).map((m) =>
+        m.kind === '重複'
+          ? rel(m.from) + '  →  重複（' + rel(m.keep) + ' を残します：' + m.why + '）'
+          : rel(m.from) + '  →  残骸'),
+      note:
+        '★診ただけです。**何も動かしていません。**' +
+        (動かすもの.length
+          ? ' 寄せるときは apply を付けてください。★消さずに「' + 片づけ先 + '」へ移すだけで、tidy_undo で全部戻せます。'
+          : '') +
+        ' ★「古い」「大きい」「空」は動かしません。使っていないことと、要らないことは別です。',
+    });
+  }
+
+  // ★実行。消さない・寄せるだけ・記録を残す
+  const bin = path.join(root, 片づけ先);
+  const recFile = path.join(bin, 片づけ記録);
+  let rec = { moves: [] };
+  try { rec = JSON.parse(fs.readFileSync(recFile, 'utf8')); } catch (_) {}
+
+  let moved = 0;
+  const failed = [];
+  for (const m of 動かすもの) {
+    const dst = path.join(bin, m.kind === '重複' ? '重複' : '残骸', rel(m.from));
+    try {
+      fs.mkdirSync(path.dirname(dst), { recursive: true });
+      if (fs.existsSync(dst)) { failed.push(rel(m.from) + '（寄せ先に同じ名前）'); continue; }
+      fs.renameSync(m.from, dst);
+      rec.moves.push({ from: m.from, to: dst, kind: m.kind, at: stamp() });
+      moved++;
+    } catch (e) { failed.push(rel(m.from) + '（' + e.message + '）'); }
+  }
+  rec.updated_at = stamp();
+  try { fs.mkdirSync(bin, { recursive: true }); fs.writeFileSync(recFile, JSON.stringify(rec, null, 2), 'utf8'); } catch (_) {}
+
+  return Object.assign(base, {
+    寄せた件数: moved,
+    寄せられなかった: failed.length ? failed : undefined,
+    寄せ先: bin,
+    note: '★消していません。' + bin + ' に移してあります。' +
+      '元に戻すときは tidy_undo を呼んでください（記録から全部戻します）。' +
+      '★中身を見て要らないと決めたら、そのフォルダごと、ご自身で捨ててください。',
+  });
+}
+
+function tidyUndo(dir) {
+  const root = path.resolve(String(dir || '').trim());
+  const recFile = path.join(root, 片づけ先, 片づけ記録);
+  if (!fs.existsSync(recFile)) throw new Error('片づけの記録がありません（まだ寄せていないか、記録が消えています）');
+  const rec = JSON.parse(fs.readFileSync(recFile, 'utf8'));
+  let back = 0;
+  const failed = [];
+  // ★新しいものから戻す
+  for (const m of rec.moves.slice().reverse()) {
+    try {
+      if (!fs.existsSync(m.to)) { failed.push(path.basename(m.to) + '（寄せ先に無い）'); continue; }
+      if (fs.existsSync(m.from)) { failed.push(path.basename(m.from) + '（元の場所に同じ名前がある）'); continue; }
+      fs.mkdirSync(path.dirname(m.from), { recursive: true });
+      fs.renameSync(m.to, m.from);
+      back++;
+    } catch (e) { failed.push(path.basename(m.to) + '（' + e.message + '）'); }
+  }
+  const left = rec.moves.length - back;
+  fs.writeFileSync(recFile, JSON.stringify({ moves: [], updated_at: stamp(), 戻せなかった: failed }, null, 2), 'utf8');
+  return {
+    戻した件数: back,
+    戻せなかった件数: left,
+    戻せなかったもの: failed.length ? failed : undefined,
+    note: '★元の場所へ戻しました。' + (left ? '戻せなかったものは「' + 片づけ先 + '」に残っています。' : ''),
+  };
+}
+
+function stampCompact() {
+  const d = new Date(), p = (n) => String(n).padStart(2, '0');
+  return '' + d.getFullYear() + p(d.getMonth() + 1) + p(d.getDate()) + '-' + p(d.getHours()) + p(d.getMinutes());
+}
+
+// ★鍵が切れたときに、どの道具を止めるか（2026-08-20 決定）
+//   「溜めるのが止まる／引くのは残る」。recall だけは期限後も通す。
+//   ★片づける口（settle）も残す。閉じられないまま終わらせない。
+const ALLOWED_WHEN_EXPIRED = new Set(['recall', 'review', 'settle', 'checkup']);
+
+// ---------------------------------------------------------------- 道具の実行
+
+function callTool(name, args) {
+  if (name === 'check_file') {
+    const p = String(args && args.path || '');
+    if (!p) throw new Error('path が指定されていません');
+    const abs = path.isAbsolute(p) ? p : path.join(REPO, p);
+    if (!fs.existsSync(abs)) throw new Error('見つかりません: ' + p);
+    return inspect(abs);
+  }
+
+  if (name === 'remember') {
+    return FREE.remember(args && args.text, args && args.tag, args && args.sig);
+  }
+
+  if (name === 'recall') {
+    return FREE.recall(args && args.days, args && args.only_open);
+  }
+
+  if (name === 'review') return FREE.review(true);
+
+  if (name === 'settle') {
+    return FREE.settle(args && args.ids, args && args.sig, args && args.ruled_to);
+  }
+
+  if (name === 'checkup') return FREE.checkup();
+
+  if (name === 'install') {
+    return install(args && args.to, args && args.overwrite);
+  }
+
+  if (name === 'update') {
+    return update(args && args.to, args && args.apply);
+  }
+
+  if (name === 'policy') {
+    const dir = (args && args.dir) || process.cwd();
+    if (args && args.level !== undefined && args.level !== null) {
+      const r = PRIV.setPolicy(dir, args.level);
+      r.note = '★秘密鍵・パスワード・カード番号などは、どの段でも必ず止まります（選べません）。';
+      return r;
+    }
+    const p = PRIV.getPolicy(dir);
+    return {
+      いまの段: p.level, 意味: PRIV.LEVELS[p.level],
+      選べる段: PRIV.LEVELS,
+      変えられない層: PRIV.ALWAYS.map(([k]) => k),
+      note: '★段を変えるときは level を渡してください。',
+    };
+  }
+
+  if (name === 'make_dict') return makeDict(args && args.from, args && args.to);
+
+  if (name === 'mask_file') return PRIV.maskFile(FREE, args && args.path);
+
+  if (name === 'unmask_file') {
+    return PRIV.unmaskFile(FREE, args && args.path, args && args.to, args && args.force);
+  }
+
+  if (name === 'render') {
+    return PRIV.render(FREE, args && args.mask_id, args && args.text, args && args.to, args && args.dir);
+  }
+
+  if (name === 'tidy') return tidy(args && args.dir, args && args.days, args && args.apply);
+  if (name === 'tidy_undo') return tidyUndo(args && args.dir);
+
+  // ★通信する道具（Promiseを返す。受け口で待つ）
+  if (name === 'about_me') return ME.aboutMe();
+  if (name === 'set_polaris') return ME.setPolaris(args && args.text, args && args.why);
+  if (name === 'learn') return ME.learn(args && args.kind, args && args.text, args && args.source);
+  if (name === 'check_env') return ENV.guide(args && args.want);
+  if (name === 'setup_google') return GT.setupGuide();
+  if (name === 'connect_google') return GT.connect();
+  if (name === 'list_tasks') {
+    return GT.listTasks(args && args.all).then((r) => {
+      GT.saveCount(r['残っているもの'], r['期限切れ']);   // ★次の窓で最初に出すため
+      return r;
+    });
+  }
+  if (name === 'add_task') return GT.addTask(args && args.title, args && args.due, args && args.notes);
+  if (name === 'complete_task') return GT.completeTask(args && args.id, args && args.title);
+  if (name === 'sync_core') return syncCore();
+  if (name === 'list_supplements') return listSupplements(args && args.to);
+
+  if (name === 'open_shelf') {
+    const dir = (args && args.to) || process.cwd();
+    return listSupplements(dir).then((l) => {
+      const r = require('./shelf.js').openShelf(l['使えるサプリ'], dir, args && args.no_open);
+      r.note = '★このページを開いて、要るものを選んでください。' +
+        'ボタンを押すと頼み方がコピーされるので、そのまま私に貼ってください。' +
+        (r.開きました ? '' : '★自動では開けませんでした。上のパスを開いてください。');
+      return r;
+    });
+  }
+  if (name === 'add_supplement') return addSupplement(args && args.name, args && args.to);
+  if (name === 'remove_supplement') return removeSupplement(args && args.name, args && args.to);
+
+  if (name === 'list_installable') {
+    const files = listPayload();
+    const groups = {};
+    for (const f of files) {
+      const g = f.split('/').slice(0, 2).join('/').replace(/\.[^.]+$/, '');
+      (groups[g] = groups[g] || []).push(f);
+    }
+    return {
+      置けるもの: Object.entries(groups).map(([g, fs2]) => ({ 名前: g, 件数: fs2.length })),
+      合計: files.length,
+      別に要るもの: Object.entries(NEEDS).map(([k, v]) => k + '：' + v),
+      note: '★ルールと番頭の核は、このMCPが持っています。置く必要はありません。',
+    };
+  }
+
+  if (name === 'check_text') {
+    const text = String(args && args.text || '');
+    const tmp = path.join(
+      require('os').tmpdir(),
+      'bantou_gate_' + process.pid + '_' + Math.random().toString(36).slice(2) + '.md'
+    );
+    fs.writeFileSync(tmp, text, 'utf8');
+    try {
+      return inspect(tmp);
+    } finally {
+      try { fs.unlinkSync(tmp); } catch (_) {}
+    }
+  }
+
+  throw new Error('未知の道具: ' + name);
+}
+
+// ---------------------------------------------------------------- JSON-RPC
+
+function send(msg) {
+  process.stdout.write(JSON.stringify(msg) + '\n');
+}
+
+// ★通信する道具（サプリの一覧・取得）があるので、受け口ごと待てる形にする。
+//   同期のまま Promise を JSON.stringify すると {} が返り、**黙って空の結果**になる。
+async function handle(req) {
+  const { id, method, params } = req;
+
+  if (method === 'initialize') {
+    return {
+      jsonrpc: '2.0',
+      id,
+      result: {
+        protocolVersion: (params && params.protocolVersion) || '2025-06-18',
+        capabilities: { tools: {}, resources: {} },
+        serverInfo: { name: 'banto', version: VERSION },
+        // ★ここが「貼り付け」の代わり（2026-08-20）。
+        //   MCP の initialize は instructions を返せて、クライアントはそれを
+        //   システムプロンプトへ入れる。labor-law / tax-law MCP が実際にそうしている。
+        //   ★これが無いと、道具は配れてもルールは配れない＝zipと貼り付けが要る。
+        instructions: loadInstructions(),
+      },
+    };
+  }
+
+  if (method === 'resources/list') {
+    return { jsonrpc: '2.0', id, result: { resources: resources() } };
+  }
+
+  if (method === 'resources/read') {
+    const uri = params && params.uri;
+    const r = resources().find((x) => x.uri === uri);
+    if (!r) {
+      return { jsonrpc: '2.0', id, error: { code: -32602, message: '見つかりません: ' + uri } };
+    }
+    let text;
+    try { text = fs.readFileSync(r._path, 'utf8'); }
+    catch (e) { text = '（読めませんでした: ' + e.message + '）'; }
+    return {
+      jsonrpc: '2.0', id,
+      result: { contents: [{ uri, mimeType: 'text/markdown', text }] },
+    };
+  }
+
+  if (method === 'tools/list') {
+    return { jsonrpc: '2.0', id, result: { tools: TOOLS } };
+  }
+
+  if (method === 'tools/call') {
+    const name = params && params.name;
+    try {
+      // ★鍵の確認。未設定なら素通り（＝自社利用・導入前はいまの動作のまま）
+      //   期限切れでも「手元の記録は読める」＝止まるのは検査だけ
+      const lic = LICENSE_STATE;
+      if (lic && lic.allowed === false && !ALLOWED_WHEN_EXPIRED.has(name)) {
+        return {
+          jsonrpc: '2.0', id,
+          result: { content: [{ type: 'text', text: JSON.stringify({
+            verdict: '実行していません', reason: lic.status, message: lic.message,
+            still_available: ['recall'],   // ★引くのは残る
+          }, null, 2) }] },
+        };
+      }
+      const out = await callTool(name, params && params.arguments);
+      if (lic && lic.message) out.license_notice = lic.message;
+      return {
+        jsonrpc: '2.0',
+        id,
+        result: { content: [{ type: 'text', text: JSON.stringify(out, null, 2) }] },
+      };
+    } catch (e) {
+      return {
+        jsonrpc: '2.0',
+        id,
+        result: {
+          content: [{ type: 'text', text: 'エラー: ' + e.message }],
+          isError: true,
+        },
+      };
+    }
+  }
+
+  if (method === 'ping') return { jsonrpc: '2.0', id, result: {} };
+
+  // 通知（idなし）は返さない
+  if (id === undefined) return null;
+
+  return {
+    jsonrpc: '2.0',
+    id,
+    error: { code: -32601, message: 'Method not found: ' + method },
+  };
+}
+
+// ★鍵の状態。起動時に1回だけ確かめ、以後は使い回す（1日1回の問い合わせは client 側で制御）
+//   確認に失敗しても止めない（通信不可で仕事ができなくなるのを避ける）
+let LICENSE_STATE = { allowed: true, status: 'unconfigured', message: '', daysLeft: null };
+(async () => {
+  try {
+    const { check } = require('./license/client.js');
+    LICENSE_STATE = await check('0.1.0');
+  } catch (_) {
+    // license モジュールが無い構成でも動く
+  }
+})();
+
+// ★1つずつ順に処理する（2026-08-21）。
+//   待てる形（async）にした途端、**要求が同時に走る**ようになり、
+//   「入れる」の途中で「一覧」が走って『未導入』と返った。
+//   道具どうしが同じファイルを触るので、順番が崩れると結果が狂う。
+//   ★待てるようにしたら、必ず「順番」も決める。
+let 順番 = Promise.resolve();
+readline.createInterface({ input: process.stdin }).on('line', (line) => {
+  const s = line.trim();
+  if (!s) return;
+  let req;
+  try {
+    req = JSON.parse(s);
+  } catch (_) {
+    return;
+  }
+  順番 = 順番.then(async () => {
+    let res;
+    try { res = await handle(req); }
+    catch (e) {
+      // ★黙って落ちない。待っている相手に必ず返す
+      res = { jsonrpc: '2.0', id: req.id, result: { content: [{ type: 'text', text: 'エラー: ' + e.message }], isError: true } };
+    }
+    if (res) send(res);
+  });
+});