@funny-booth/agent-core 0.1.45 → 0.1.46

package/dist/vault.d.ts

@@ -7,9 +7,20 @@ export declare class VaultError extends Error {
 }
 export declare function vaultKey(): Buffer;
 export declare function resetVault(): string[];
+/** 人が入れた秘密の目印を入れておく項目。名前の検査（secretNameError）で使えない形にしてあり、秘密の名前とぶつからない。 */
+export declare const META_KEY = "funny-booth:meta";
+export type SecretOrigin = "human" | "model";
 export declare function readSecrets(): Record<string, string>;
-export declare function setSecret(name: string, value: string): void;
+/** 人が入れた秘密の名前（get_secret が値を返さないもの）。 */
+export declare function humanSecretNames(): Set<string>;
+/**
+ * 秘密を入れる。origin が human なら人が入れた目印を付け、model なら外す（AI が値を知っている）。
+ * 鍵の作成も同じロックを使うため、ロックを取る前に鍵を用意しておく（ロックは再入できない）
+ */
+export declare function setSecret(name: string, value: string, origin?: SecretOrigin): void;
 export declare function deleteSecret(name: string): boolean;
+/** 金庫のファイルの場所（Mod が「書き換わったか」を確かめるため。secretPrints.ts）。 */
+export declare function secretsFile(): string;
 export declare function readSecretSites(): Record<string, string[]>;
 /** 入れてよいサイトを決め直す（空の配列なら外す）。サイトはドメイン名にそろえたもの（secretSites.normalizeSite）を渡す。 */
 export declare function setSecretSites(name: string, sites: string[]): void;

package/dist/vault.js

@@ -6,7 +6,7 @@
 //   - 暗号鍵 : OS の鍵保管庫（macOS キーチェーン / Windows 資格情報マネージャー / Linux Secret Service）。
 //              鍵保管庫が無い環境（WSL2・ヘッドレス Linux）では ~/.funny-booth/vault/vault.key に置き、
 //              そのことを表示する。最初に決めた保管先は store.json に記録し、以後はそこだけを使う。
-//   - 秘密   : ~/.funny-booth/vault/secrets.enc（名前→値の JSON を AES-256-CBC で暗号化）
+//   - 秘密   : ~/.funny-booth/vault/secrets.enc（名前→値の JSON を AES-256-CBC で暗号化。人が入れた秘密の目印も中に持つ＝META_KEY）
 //   - ログイン: ~/.{toolName}/portal-token.enc（ツールごとにアカウントが違うのでツール別。鍵は共有）
 //   - 入れてよいサイト: ~/.funny-booth/vault/secret-sites.json（秘密の名前→ドメインの一覧。値ではないので暗号化しない。
 //              ブラウザへ値を見せずに入れる道具が、ここにあるサイトにだけ入れる。secretSites.ts）
@@ -17,7 +17,7 @@
 //   - 旧形式（~/.{toolName}/vault.key + secrets.enc のツール別金庫）は migrateToolVault で共有金庫へ移す。
 // ============================================================================
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VaultError = void 0;
+exports.META_KEY = exports.VaultError = void 0;
 exports.configDir = configDir;
 exports.ensureConfigDir = ensureConfigDir;
 exports.vaultDir = vaultDir;
@@ -26,8 +26,10 @@ exports.decrypt = decrypt;
 exports.vaultKey = vaultKey;
 exports.resetVault = resetVault;
 exports.readSecrets = readSecrets;
+exports.humanSecretNames = humanSecretNames;
 exports.setSecret = setSecret;
 exports.deleteSecret = deleteSecret;
+exports.secretsFile = secretsFile;
 exports.readSecretSites = readSecretSites;
 exports.setSecretSites = setSecretSites;
 exports.fillableSecret = fillableSecret;
@@ -304,45 +306,84 @@ function resetVault() {
     });
 }
 // ── 秘密（全ツール共有）────────────────────────────────────────────────────
-function readSecretsFile(file, key) {
+//
+// 復号した中身は「名前→値」の JSON。人が入れた秘密（ask_secret の画面・CLI の secret set・VS Code の「パスワードを保存」）の
+// 目印は、同じ JSON の中の META_KEY に入れる（暗号化の内側なので、AI がファイルを書き換えて目印を外せない）。
+// 形を変えずに1つの項目を足すだけにしたのは、同じ金庫を古い版の agent-core（別のツール）が読み書きしても壊れないため
+// （古い版には META_KEY が名前の1つに見えるだけで、書き込むときもそのまま残る）。
+// 目印の無い秘密（今までに入れたもの・AI が store_secret で入れたもの）は今までどおり。
+/** 人が入れた秘密の目印を入れておく項目。名前の検査（secretNameError）で使えない形にしてあり、秘密の名前とぶつからない。 */
+exports.META_KEY = "funny-booth:meta";
+function parseVault(obj) {
+    const { [exports.META_KEY]: metaText, ...secrets } = obj;
+    let human = [];
+    if (typeof metaText === "string") {
+        const meta = JSON.parse(metaText);
+        if (Array.isArray(meta.human))
+            human = meta.human.filter((n) => typeof n === "string" && n in secrets);
+    }
+    return { secrets, human: new Set(human) };
+}
+function readVaultFile(file, key) {
     if (!(0, fs_1.existsSync)(file))
-        return {};
+        return { secrets: {}, human: new Set() };
     const plain = decrypt((0, fs_1.readFileSync)(file, "utf-8").trim(), key);
     // 復号できない金庫を空として扱うと、次の書き込みで中身を消してしまう。黙らずに止める
     if (plain === null)
         throw new VaultError(`金庫を復号できません（${file}）。鍵が変わった可能性があります。${RESET_HINT}`);
     const obj = JSON.parse(plain);
-    return obj && typeof obj === "object" ? obj : {};
+    return parseVault(obj && typeof obj === "object" ? obj : {});
 }
-function writeSecretsFile(secrets) {
+function readVault() {
+    return readVaultFile((0, path_1.join)(vaultDir(), SECRETS_FILE), vaultKey());
+}
+function writeVault(v) {
     (0, fs_1.mkdirSync)(vaultDir(), { recursive: true, mode: 0o700 });
-    atomicWrite((0, path_1.join)(vaultDir(), SECRETS_FILE), encrypt(JSON.stringify(secrets), vaultKey()));
+    const human = [...v.human].filter((n) => n in v.secrets);
+    const obj = human.length ? { ...v.secrets, [exports.META_KEY]: JSON.stringify({ human }) } : v.secrets;
+    atomicWrite((0, path_1.join)(vaultDir(), SECRETS_FILE), encrypt(JSON.stringify(obj), vaultKey()));
 }
-// 金庫全体を復号して名前→値のマップで返す（無ければ空）
+// 金庫全体を復号して名前→値のマップで返す（無ければ空。目印の項目は含めない）
 function readSecrets() {
-    return readSecretsFile((0, path_1.join)(vaultDir(), SECRETS_FILE), vaultKey());
+    return readVault().secrets;
+}
+/** 人が入れた秘密の名前（get_secret が値を返さないもの）。 */
+function humanSecretNames() {
+    return readVault().human;
 }
-// 鍵の作成も同じロックを使うため、ロックを取る前に鍵を用意しておく（ロックは再入できない）
-function setSecret(name, value) {
+/**
+ * 秘密を入れる。origin が human なら人が入れた目印を付け、model なら外す（AI が値を知っている）。
+ * 鍵の作成も同じロックを使うため、ロックを取る前に鍵を用意しておく（ロックは再入できない）
+ */
+function setSecret(name, value, origin = "model") {
     vaultKey();
     withVaultLock(() => {
-        const secrets = readSecrets();
-        secrets[name] = value;
-        writeSecretsFile(secrets);
+        const v = readVault();
+        v.secrets[name] = value;
+        if (origin === "human")
+            v.human.add(name);
+        else
+            v.human.delete(name);
+        writeVault(v);
     });
 }
 function deleteSecret(name) {
     vaultKey();
     return withVaultLock(() => {
-        const secrets = readSecrets();
-        if (!(name in secrets))
+        const v = readVault();
+        if (!Object.prototype.hasOwnProperty.call(v.secrets, name))
             return false;
-        delete secrets[name];
-        writeSecretsFile(secrets);
+        delete v.secrets[name];
+        v.human.delete(name);
+        writeVault(v);
         writeSites(name, null); // 入れてよいサイトも一緒に消す
         return true;
     });
 }
+/** 金庫のファイルの場所（Mod が「書き換わったか」を確かめるため。secretPrints.ts）。 */
+function secretsFile() {
+    return (0, path_1.join)(vaultDir(), SECRETS_FILE);
+}
 // ── 入れてよいサイト（秘密の名前 → ドメインの一覧）────────────────────────────
 const SITES_FILE = "secret-sites.json";
 function readSecretSites() {
@@ -457,11 +498,12 @@ function migrateToolVault(toolName) {
             return { migrated: false, conflicts: [] }; // 別プロセスが先に移した
         const oldKey = parseKey((0, fs_1.readFileSync)(oldKeyFile, "utf-8").trim());
         const oldSecretsFile = (0, path_1.join)(dir, SECRETS_FILE);
-        const oldSecrets = readSecretsFile(oldSecretsFile, oldKey);
+        const oldSecrets = readVaultFile(oldSecretsFile, oldKey).secrets;
         const tokenFile = (0, path_1.join)(dir, TOKEN_FILE);
         const oldTokenPlain = (0, fs_1.existsSync)(tokenFile) ? decrypt((0, fs_1.readFileSync)(tokenFile, "utf-8").trim(), oldKey) : null;
-        const { merged, conflicts } = mergeSecrets(readSecrets(), oldSecrets, toolName);
-        writeSecretsFile(merged);
+        const current = readVault();
+        const { merged, conflicts } = mergeSecrets(current.secrets, oldSecrets, toolName);
+        writeVault({ secrets: merged, human: current.human });
         if (oldTokenPlain)
             saveTokens(toolName, parseTokens(oldTokenPlain));
         // 読み戻して一致を確かめてから旧いものを消す（確かめられなければ旧いものは残す）

package/mod/hooks/redact.js

@@ -0,0 +1,98 @@
+// 道具の結果から金庫の秘密の値を伏せる計算（register.js から使う。Mod の外の Node.js でもテストできるよう、Mod の $ は使わない）。
+//
+// Mod は値そのものを持たない。agent-core の secretPrints.js から受け取った「指紋」（名前・長さ・pre・fp）だけで探す:
+//   1. 秘密の長さごとに、文を1文字ずつずらしながら pre（多項式の値を PRE_MOD で割った余り）を計算する（転がし計算で速い）
+//   2. pre が合った所だけ、key とその部分をつないだ SHA-256 を計算し、fp と同じなら秘密（偶然 pre が合っただけなら伏せない）
+//   3. 重なったら長い秘密を優先する（短い値が長い値の一部でも取りこぼさない）
+// PRE_MOD・preBase は agent-core の secretPrints.ts と同じ計算（test/redact.test.mjs で一致を確かめる）。
+
+export const PRE_MOD = 65521
+
+export function preBase(key) {
+  return 256 + (parseInt(key.slice(0, 8), 16) % (PRE_MOD - 256))
+}
+
+/** このセッションだけの key（64 桁の 16 進数）。 */
+export function newKey(random) {
+  return [...random(new Uint8Array(32))].map((b) => b.toString(16).padStart(2, '0')).join('')
+}
+
+/** 指紋から探すための表（長さ → pre → 指紋の一覧）を作る。 */
+export function buildTable(prints) {
+  const table = new Map()
+  for (const p of prints) {
+    if (!table.has(p.len)) table.set(p.len, new Map())
+    const byPre = table.get(p.len)
+    if (!byPre.has(p.pre)) byPre.set(p.pre, [])
+    byPre.get(p.pre).push(p)
+  }
+  return table
+}
+
+async function sha256Hex(digest, text) {
+  const buf = await digest(new TextEncoder().encode(text))
+  return [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, '0')).join('')
+}
+
+/** 文の中の秘密の場所（重ならない。長い秘密が先）。digest は SHA-256 を返す関数（Mod では crypto.subtle.digest）。 */
+export async function findSecrets(text, table, key, digest) {
+  const base = preBase(key)
+  const found = []
+  for (const [len, byPre] of table) {
+    if (text.length < len) continue
+    let pow = 1 // base^(len-1)
+    for (let i = 1; i < len; i++) pow = (pow * base) % PRE_MOD
+    let h = 0
+    for (let i = 0; i < len; i++) h = (h * base + text.charCodeAt(i)) % PRE_MOD
+    for (let i = 0; ; i++) {
+      const candidates = byPre.get(h)
+      if (candidates) {
+        const fp = await sha256Hex(digest, key + text.slice(i, i + len))
+        const hit = candidates.find((c) => c.fp === fp)
+        if (hit) found.push({ start: i, end: i + len, name: hit.name })
+      }
+      if (i + len >= text.length) break
+      h = (((h - ((text.charCodeAt(i) * pow) % PRE_MOD) + PRE_MOD) * base) + text.charCodeAt(i + len)) % PRE_MOD
+    }
+  }
+  found.sort((a, b) => (b.end - b.start) - (a.end - a.start) || a.start - b.start)
+  const taken = []
+  for (const f of found) if (!taken.some((t) => f.start < t.end && t.start < f.end)) taken.push(f)
+  return taken.sort((a, b) => a.start - b.start)
+}
+
+/** 秘密を ●●●●（名前） に置き換えた文。 */
+export async function redactText(text, table, key, digest) {
+  if (table.size === 0 || typeof text !== 'string' || text === '') return text
+  const hits = await findSecrets(text, table, key, digest)
+  if (!hits.length) return text
+  let out = ''
+  let at = 0
+  for (const h of hits) { out += text.slice(at, h.start) + `●●●●（${h.name}）`; at = h.end }
+  return out + text.slice(at)
+}
+
+/** 入れ子の値の中の文をすべて伏せる。changed は1か所でも伏せたか。 */
+export async function redactDeep(value, table, key, digest) {
+  let changed = false
+  const walk = async (v) => {
+    if (typeof v === 'string') {
+      const r = await redactText(v, table, key, digest)
+      if (r !== v) changed = true
+      return r
+    }
+    if (Array.isArray(v)) {
+      const out = []
+      for (const x of v) out.push(await walk(x))
+      return out
+    }
+    if (v && typeof v === 'object') {
+      const out = {}
+      for (const [k, x] of Object.entries(v)) out[k] = await walk(x)
+      return out
+    }
+    return v
+  }
+  const result = await walk(value)
+  return { value: result, changed }
+}

package/mod/hooks/register.js

@@ -11,14 +11,18 @@
 //    金庫の秘密の値（6 文字以上）が道具の結果に出ていれば、記録にも AI にも渡る前に伏せる。
 //    道具の結果は2か所に残るので両方で伏せる: 道具の詳しい記録（記録の toolUseResult）は tool.call で、
 //    AI が読む文（tool_result）とその他の行は session.append で。
-//    値は起動時に agent-core の secretValues.js から受け取り、ここ（メモリ）にだけ持つ。
-// 3. 見た目（入力欄の上の帯・道具の行と作業中の行の日本語化・起動のあいさつと雷の光・豆知識・終わったときのお知らせ）
+//    値そのものは受け取らない。agent-core の secretPrints.js から、このセッションだけの key で作った指紋を受け取り、
+//    指紋で探す（redact.js）。金庫のファイルが書き換わったら（途中で秘密を足した等）指紋を取り直す。
+// 3. 金庫・鍵に触る道具の呼び出しを止める（vaultGate.js。関所であって壁ではない。サブエージェントにも効かせる）
+// 4. 見た目（入力欄の上の帯・道具の行と作業中の行の日本語化・起動のあいさつと雷の光・豆知識・終わったときのお知らせ）
 //    どれも表示だけで、描くのに失敗したら Claude Code の元の表示に戻す（会話は止めない）。
 //    何を出すかの計算は look.js、言葉は words.js。
 
 import { BOLT, FLASH, DONE_MS, TIP_AFTER_MS, TOAST_AFTER_MS, greetingAt, toolLabel, toolDetail, groupSummary, duration, faceOf, bandParts } from './look.js'
 import { knowledgeSection, loadRequest } from './knowledgeText.js'
 import { SPINNER_WORD, GROUP_HINT, TOAST_DONE, TOAST_ASK, TIPS } from './words.js'
+import { buildTable, newKey, redactDeep, redactText } from './redact.js'
+import { GATE_REASON, vaultTouch } from './vaultGate.js'
 
 const LOAD = /^mcp__[a-z0-9-]+__load_knowledge$/
 const knowledge = new Map() // キーワード → 本文（読み込んだ順）
@@ -27,7 +31,9 @@ const knowledge = new Map() // キーワード → 本文（読み込んだ順
 const injected = new Set()
 // 節に入れたのに AI が見当たらないと言うことがある（受付箱 cc03280f）。同じカードを2回目に読まれたら本文を返す
 const stubbed = new Set()
-let secrets = [] // [名前, 値]
+// 伏せるための指紋（値は持たない）。key はこのセッションだけの乱数。file・mtime で金庫の書き換わりを見る
+const prints = { key: newKey((a) => crypto.getRandomValues(a)), table: new Map(), file: '', mtime: -1, loading: null, failedAt: 0 }
+const digest = (bytes) => crypto.subtle.digest('SHA-256', bytes)
 let startKeyword = '' // 起動プログラムが渡したカードのキーワード（公式のエージェントのときだけ）
 
 function stub(keyword) {
@@ -35,40 +41,57 @@ function stub(keyword) {
     `（その節が見当たらないときは、もう一度 load_knowledge で "${keyword}" を読むと本文を返します）`
 }
 
-function redact(text) {
-  let out = text
-  for (const [name, value] of secrets) out = out.split(value).join(`●●●●（${name}）`)
+const redact = (text) => redactText(text, prints.table, prints.key, digest)
+
+async function redactBlocks(content) {
+  const out = []
+  for (const b of content) {
+    if (b.type === 'text' && typeof b.text === 'string') out.push({ ...b, text: await redact(b.text) })
+    else if (b.type === 'tool_result' && typeof b.content === 'string') out.push({ ...b, content: await redact(b.content) })
+    else if (b.type === 'tool_result' && Array.isArray(b.content)) {
+      const inner = []
+      for (const c of b.content) inner.push(c.type === 'text' ? { ...c, text: await redact(c.text) } : c)
+      out.push({ ...b, content: inner })
+    } else out.push(b)
+  }
   return out
 }
 
-function hasSecret(value) {
-  const text = JSON.stringify(value) ?? ''
-  return secrets.some(([, v]) => text.includes(v))
+// agent-core の小さな入口を動かし、標準出力の JSON を返す。失敗したら理由（標準エラー）を添えて例外にする
+async function runJson($, script, stdin) {
+  const r = await $.process.run(['node', `${$.plugin.root}/../dist/${script}`], stdin === undefined ? undefined : { stdin })
+  if (r.exitCode !== 0) throw new Error((r.stderr || `終了コード ${r.exitCode}`).trim())
+  return JSON.parse(r.stdout)
 }
 
-function redactDeep(value) {
-  if (typeof value === 'string') return redact(value)
-  if (Array.isArray(value)) return value.map(redactDeep)
-  if (value && typeof value === 'object') return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, redactDeep(v)]))
-  return value
+async function vaultMtime($) {
+  if (!prints.file) return -1
+  try { return (await $.fs.stat(prints.file)).mtimeMs } catch { return 0 } // まだ金庫が無い
 }
 
-function redactBlocks(content) {
-  return content.map((b) => {
-    if (b.type === 'text' && typeof b.text === 'string') return { ...b, text: redact(b.text) }
-    if (b.type === 'tool_result') {
-      if (typeof b.content === 'string') return { ...b, content: redact(b.content) }
-      if (Array.isArray(b.content)) return { ...b, content: b.content.map((c) => (c.type === 'text' ? { ...c, text: redact(c.text) } : c)) }
-    }
-    return b
-  })
+// 指紋を取る（起動時と、金庫のファイルが書き換わったとき）。読めなければ理由を画面に残し、1分は取り直さない（会話は止めない）
+async function loadPrints($) {
+  if (prints.loading) return prints.loading
+  prints.loading = (async () => {
+    try {
+      const r = await runJson($, 'secretPrints.js', JSON.stringify({ key: prints.key }))
+      prints.file = r.file
+      prints.table = buildTable(r.prints)
+      prints.mtime = await vaultMtime($)
+    } catch (err) {
+      prints.failedAt = Date.now()
+      $.ui.log(`秘密を伏せる準備ができませんでした: ${err.message}`)
+    } finally { prints.loading = null }
+  })()
+  return prints.loading
 }
 
-// agent-core の小さな入口を動かし、標準出力の JSON を返す。失敗したら理由（標準エラー）を添えて例外にする
-async function runJson($, script) {
-  const r = await $.process.run(['node', `${$.plugin.root}/../dist/${script}`])
-  if (r.exitCode !== 0) throw new Error((r.stderr || `終了コード ${r.exitCode}`).trim())
-  return JSON.parse(r.stdout)
+async function freshPrints($) {
+  if (!prints.file) {
+    if (Date.now() - prints.failedAt > 60_000) await loadPrints($)
+    return
+  }
+  if ((await vaultMtime($)) !== prints.mtime) await loadPrints($)
 }
 
 // 見た目の状態（このセッションの間だけ）
@@ -131,12 +154,7 @@ export function register(on) {
         $.ui.log(`手順書をシステムの指示に入れられませんでした（load_knowledge で読みます）: ${err.message}`)
       }
     }
-    try {
-      secrets = await runJson($, 'secretValues.js')
-    } catch (err) {
-      // 金庫を読めなければ伏せる対象が無いだけ（会話は止めない）。理由は画面に残す
-      $.ui.log(`秘密を伏せる準備ができませんでした: ${err.message}`)
-    }
+    await loadPrints($)
     return next(e)
   })
 
@@ -150,15 +168,25 @@ export function register(on) {
     return next(e)
   })
 
+  // 金庫・鍵に触る呼び出しは、道具を動かす前に断る（AI には短い理由だけ。何に触ったかは画面に残す。サブエージェントも同じ）。
   // 秘密が出た道具の結果は、詳しい記録ごと伏せた形で返す（伏せたものを Claude Code が記録し、AI に渡す）
   on('tool.call', async ($, e, next) => {
+    const what = vaultTouch(e)
+    if (what) {
+      $.ui.log(`金庫・鍵に触る呼び出しを止めました（${e.tool}・${what}）`)
+      return { deny: GATE_REASON }
+    }
     // 雷くん: 質問のときは首をかしげ（お知らせも出す）、失敗したら頭をかく
     const mine = !e.agentId
     if (mine && e.tool === 'AskUserQuestion') { setFace($, 'ask'); $.ui.toast(TOAST_ASK) }
     const r = await next(e)
     if (mine) setFace($, r?.isError ? 'fail' : 'work')
-    if (secrets.length === 0 || r.deny || !hasSecret(r.result)) return r
-    return { result: redactDeep(r.result), ...(r.context ? { context: r.context } : {}) }
+    if (r.deny) return r
+    await freshPrints($)
+    if (prints.table.size === 0) return r
+    const red = await redactDeep(r.result, prints.table, prints.key, digest)
+    if (!red.changed) return r
+    return { result: red.value, ...(r.context ? { context: r.context } : {}) }
   })
 
   // 起動のあいさつ（お客さんの画面に出る）には AI への指示を書かないので、「この手順書で始める」はここで伝える
@@ -176,8 +204,9 @@ export function register(on) {
   })
 
   on('session.append', { door: 'tool-result' }, async ($, e, next) => {
-    if (secrets.length === 0) return next(e)
-    return next({ ...e, message: { ...e.message, content: redactBlocks(e.message.content) } })
+    await freshPrints($)
+    if (prints.table.size === 0) return next(e)
+    return next({ ...e, message: { ...e.message, content: await redactBlocks(e.message.content) } })
   })
 
   // あいさつは、お客さんが最初に打つまで出しておく（1回目は起動プログラムが送る最初の一言）

package/mod/hooks/vaultGate.js

@@ -0,0 +1,54 @@
+// 金庫・鍵に触る道具の呼び出しを止める関所（register.js の tool.call から使う。サブエージェントの呼び出しにも効かせる）。
+//
+// これは「関所」であって「壁」ではない。AI は同じ PC の同じ利用者として動くので、名前を組み立て直す・別の書き方をする
+// （例: パスの一部を変数や * に分ける、別のプログラムを書いて動かす）と、ここをすり抜けられる。
+// 狙いは、ページや文書に仕込まれた指示に従って AI が素直に金庫を読みに行く、よくある形を止めることと、
+// 止めたことを画面に残して気づけるようにすること。秘密の値そのものの守りは、金庫の暗号化・人が入れた秘密を返さない
+// get_secret・ブラウザへ入れる前の本人の確認（agent-core）が受け持つ。
+//
+// 調べるのは、ファイルやコマンドを扱う組み込みの道具の入力の文字列すべて（Bash のコマンド・Read のパス・Edit の中身など）。
+// 普段の開発（npm test・git status・プロジェクトのファイルを読む）は止めない（test/vaultGate.test.mjs）。
+
+export const GATE_REASON = '金庫・鍵に触るコマンドは使えません。秘密は金庫の道具（list_secrets・get_secret・ask_secret・browser_fill_secret など）で扱ってください。'
+
+const GATED_TOOLS = new Set(['Bash', 'PowerShell', 'Monitor', 'Read', 'Grep', 'Glob', 'LS', 'Edit', 'MultiEdit', 'Write', 'NotebookEdit', 'NotebookRead'])
+
+// tool.call の入力のうち、道具の引数ではないもの
+const NOT_INPUT = new Set(['tool', 'tool_use_id', 'consent', 'agentId'])
+
+// [何に触るか, 見分け方]。金庫の置き場所は agent-core の vault.ts（~/.funny-booth/vault・Windows は %USERPROFILE%\.funny-booth\vault）
+const RULES = [
+  ['金庫のフォルダ', /\.funny-booth[\\/]+vault/i],
+  ['金庫のファイル', /\b(secrets\.enc|vault\.key|secret-sites\.json)\b/i],
+  ['ログインの保存先', /\bportal-token(\.[a-z0-9-]+)?\.enc\b/i],
+  ['追加した MCP に渡す秘密の一覧', /\bextra-mcps\.json\b/i],
+  // OS の鍵保管庫に置いた金庫の鍵（サービス funny-booth・アカウント vault-key）と、鍵保管庫を読むコマンド
+  ['金庫の鍵', /\bvault-key\b/i],
+  ['macOS のキーチェーン', /\bsecurity\s+(find-generic-password|find-internet-password|dump-keychain|export)\b/i],
+  ['Linux の鍵保管庫', /\bsecret-tool\b/i],
+  ['Windows の資格情報', /\bcmdkey\b|CredentialManager|Get-StoredCredential|PasswordVault|\bCredRead|Windows\.Security\.Credentials/i],
+  ['鍵保管庫の部品', /napi-rs[\\/]+keyring/i],
+  // agent-core の中の、金庫を開く部品（伏せるための指紋の入口を含む）
+  ['金庫を開く部品', /\b(vault|fillSecretHelper|secretPrints)\.js\b/i],
+  // 端末の secret コマンドで、AI が秘密を入れ替える・消す・金庫を作り直す（人が端末で打つのは止めない）
+  ['金庫を書き換えるコマンド', /\b[a-z0-9-]*(agent(os)?|agent-core|index)(\.js)?\s+secret\s+(set|rm|delete|reset)\b/i],
+]
+
+function strings(value, out = []) {
+  if (typeof value === 'string') out.push(value)
+  else if (Array.isArray(value)) for (const v of value) strings(v, out)
+  else if (value && typeof value === 'object') for (const v of Object.values(value)) strings(v, out)
+  return out
+}
+
+/** 金庫・鍵に触る呼び出しなら、何に触るか（画面に残す短い言葉）。触らなければ null。 */
+export function vaultTouch(e) {
+  if (!GATED_TOOLS.has(e.tool)) return null
+  const texts = strings(Object.fromEntries(Object.entries(e).filter(([k]) => !NOT_INPUT.has(k))))
+  for (const t of texts) {
+    // フォルダと名前を分けて書いても（cd ~/.funny-booth && cat vault/…）止める
+    if (/\.funny-booth/i.test(t) && /vault/i.test(t)) return '金庫のフォルダ'
+    for (const [what, re] of RULES) if (re.test(t)) return what
+  }
+  return null
+}

package/mod/hooks/words.js

@@ -49,6 +49,7 @@ export const TOOL_LABELS = {
   ads_my_requests: '出した依頼を確認',
   video_productions: '制作中の動画を確認',
   video_request: '動画を依頼する',
+  video_appeals: '選べる訴求軸を確認',
 }
 
 // 経営ボードなど、表に無い道具は名前の頭で言い分ける（get_tasks → 確認）

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@funny-booth/agent-core",
-  "version": "0.1.45",
+  "version": "0.1.46",
   "description": "AIエージェント起動CLI（共有ランチャー + MCPサーバー）",
   "license": "UNLICENSED",
   "type": "commonjs",

package/dist/secretValues.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.REDACT_MIN = void 0;
-exports.secretPairs = secretPairs;
-// FUNNY BOOTH の Mod（mod/hooks/register.js）が、道具の結果から伏せる秘密の値を受け取るための小さな入口。
-// 金庫の秘密のうち 6 文字以上のものを [名前, 値] の JSON で標準出力に出す（短い値は普通の文字まで伏せてしまうため除く）。
-// 受け取るのは Mod（Claude Code の中のプログラム）だけで、AI や会話の記録には渡らない。
-const vault_1 = require("./vault");
-exports.REDACT_MIN = 6;
-function secretPairs(secrets) {
-    return Object.entries(secrets).filter(([, v]) => typeof v === "string" && v.length >= exports.REDACT_MIN)
-        .sort((a, b) => b[1].length - a[1].length); // 長い値から伏せる（短い値が長い値の一部のとき取りこぼさない）
-}
-if (require.main === module) {
-    try {
-        process.stdout.write(JSON.stringify(secretPairs((0, vault_1.readSecrets)())));
-    }
-    catch {
-        process.stdout.write("[]");
-    }
-}
-//# sourceMappingURL=secretValues.js.map