@hchuanz/pocket-core 0.1.0

package/dist/index.js

@@ -0,0 +1,3487 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/constants/pocket.ts
+var POCKET_API_BASE = "https://pocketapi.48.cn";
+var AVA_BASE_URL = "https://source.48.cn";
+var POCKET_APP_INFO = JSON.stringify({
+  vendor: "apple",
+  deviceId: "2A01B81B-653A-43EC-9C58-95CB418A58AC",
+  appVersion: "7.1.37",
+  appBuild: "26020801",
+  osVersion: "26.4.0",
+  osType: "ios",
+  deviceName: "iPhone17,1",
+  os: "ios"
+});
+var POCKET_PA = "MTc4MjM3NDEwNjAwMCw3NzE1LEIwODM5QzdEMjZFQzJFOTFERTExNDVERDU2NTlBRjk5LA==";
+var POCKET_USER_AGENT = "PocketFans201807/7.1.37 (iPhone; iOS 26.4; Scale/3.00)";
+var SESSION_EXPIRE_MS = 30 * 24 * 60 * 60 * 1e3;
+
+// src/adapters/loggers.ts
+var ConsoleLogger = class {
+  debug(...args) {
+    console.debug(...args);
+  }
+  info(...args) {
+    console.info(...args);
+  }
+  warn(...args) {
+    console.warn(...args);
+  }
+  error(...args) {
+    console.error(...args);
+  }
+};
+var NoopLogger = class {
+  debug() {
+  }
+  info() {
+  }
+  warn() {
+  }
+  error() {
+  }
+};
+
+// src/adapters/node-json-storage.ts
+import fs from "fs";
+import path from "path";
+var NodeJsonFileStorage = class {
+  root;
+  constructor(root) {
+    this.root = root;
+  }
+  resolve(subpath) {
+    return path.join(this.root, subpath);
+  }
+  readJson(subpath) {
+    const fp = this.resolve(subpath);
+    if (!fs.existsSync(fp)) return null;
+    try {
+      return JSON.parse(fs.readFileSync(fp, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  writeJson(subpath, data) {
+    const fp = this.resolve(subpath);
+    fs.mkdirSync(path.dirname(fp), { recursive: true });
+    fs.writeFileSync(fp, JSON.stringify(data, null, 2), "utf-8");
+  }
+  exists(subpath) {
+    return fs.existsSync(this.resolve(subpath));
+  }
+  delete(subpath) {
+    const fp = this.resolve(subpath);
+    if (fs.existsSync(fp)) fs.unlinkSync(fp);
+  }
+  list(dirSubpath) {
+    const dir = this.resolve(dirSubpath);
+    if (!fs.existsSync(dir)) return [];
+    return fs.readdirSync(dir);
+  }
+  mkdir(dirSubpath) {
+    fs.mkdirSync(this.resolve(dirSubpath), { recursive: true });
+  }
+};
+
+// src/adapters/plain-text-secure-storage.ts
+var PlainTextSecureStorage = class {
+  isAvailable() {
+    return true;
+  }
+  encryptString(plain) {
+    return Buffer.from(plain, "utf-8").toString("base64");
+  }
+  decryptString(encoded) {
+    return Buffer.from(encoded, "base64").toString("utf-8");
+  }
+};
+
+// src/adapters/node-json-config-store.ts
+import fs2 from "fs";
+import path2 from "path";
+var NodeJsonConfigStore = class {
+  filePath;
+  data = {};
+  loaded = false;
+  constructor(root, filename = "app-store.json") {
+    this.filePath = path2.join(root, filename);
+  }
+  ensureLoaded() {
+    if (this.loaded) return;
+    this.loaded = true;
+    try {
+      if (fs2.existsSync(this.filePath)) {
+        this.data = JSON.parse(fs2.readFileSync(this.filePath, "utf-8"));
+      }
+    } catch {
+      this.data = {};
+    }
+  }
+  save() {
+    fs2.mkdirSync(path2.dirname(this.filePath), { recursive: true });
+    fs2.writeFileSync(this.filePath, JSON.stringify(this.data, null, 2), "utf-8");
+  }
+  get(key) {
+    this.ensureLoaded();
+    return this.data[key];
+  }
+  set(key, value) {
+    this.ensureLoaded();
+    if (value === void 0 || value === null) {
+      delete this.data[key];
+    } else {
+      this.data[key] = value;
+    }
+    this.save();
+  }
+  remove(key) {
+    this.ensureLoaded();
+    delete this.data[key];
+    this.save();
+  }
+  has(key) {
+    this.ensureLoaded();
+    return key in this.data;
+  }
+  clear() {
+    this.data = {};
+    this.save();
+  }
+};
+
+// src/adapters/memory-config-store.ts
+var MemoryConfigStore = class {
+  data = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.data.get(key);
+  }
+  set(key, value) {
+    this.data.set(key, value);
+  }
+  remove(key) {
+    this.data.delete(key);
+  }
+  has(key) {
+    return this.data.has(key);
+  }
+  clear() {
+    this.data.clear();
+  }
+};
+
+// src/adapters/node-json-flip-source.ts
+import path3 from "path";
+var CACHE_DIR = "flip-cache";
+var NodeJsonFlipDataSource = class {
+  storage;
+  readLegacy;
+  constructor(storage, readLegacy) {
+    this.storage = storage;
+    this.readLegacy = readLegacy;
+  }
+  filePath(userId) {
+    return path3.join(CACHE_DIR, `${userId}.json`);
+  }
+  get(userId) {
+    if (!userId) return null;
+    const cached = this.storage.readJson(this.filePath(userId));
+    if (cached) return cached;
+    return this.migrateFromLegacy(userId);
+  }
+  set(cache) {
+    this.storage.writeJson(this.filePath(cache.userId), cache);
+  }
+  clear(userId) {
+    this.storage.delete(this.filePath(userId));
+  }
+  migrateFromLegacy(userId) {
+    if (!this.readLegacy) return null;
+    const legacy = this.readLegacy();
+    const records = legacy?.allUserData?.[userId];
+    if (!Array.isArray(records) || records.length === 0) return null;
+    const cache = {
+      userId,
+      records,
+      groupedDataById: legacy?.groupedDataById || {},
+      dashboardInfo: legacy?.dashboardInfo || {
+        totalFlipCount: records.length,
+        runningCount: 0,
+        returnedCount: 0,
+        costTotal: 0
+      },
+      meta: { syncedAt: Date.now(), recordCount: records.length }
+    };
+    this.set(cache);
+    return cache;
+  }
+};
+
+// src/adapters/memory-flip-source.ts
+var MemoryFlipDataSource = class {
+  data = /* @__PURE__ */ new Map();
+  get(userId) {
+    return this.data.get(userId) ?? null;
+  }
+  set(cache) {
+    this.data.set(cache.userId, cache);
+  }
+  clear(userId) {
+    this.data.delete(userId);
+  }
+};
+
+// src/adapters/openai-compatible-client.ts
+var OpenAICompatibleClient = class {
+  logger;
+  constructor(logger) {
+    this.logger = logger;
+  }
+  async chatCompletion(config, messages, tools, options) {
+    const url = `${config.baseUrl}/chat/completions`;
+    const body = {
+      model: options?.model || config.chatModel,
+      messages,
+      stream: false
+    };
+    if (tools?.length) {
+      body.tools = tools;
+      body.tool_choice = "auto";
+    }
+    if (options?.maxTokens) body.max_tokens = options.maxTokens;
+    if (options?.temperature !== void 0) body.temperature = options.temperature;
+    const resp = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.apiKey}`
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(options?.timeoutMs ?? 12e4)
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      throw new Error(`LLM ${resp.status}: ${text.slice(0, 200)}`);
+    }
+    const json = await resp.json();
+    const choice = json.choices?.[0];
+    return {
+      content: choice?.message?.content ?? "",
+      toolCalls: choice?.message?.tool_calls
+    };
+  }
+  async chatCompletionStream(config, messages, onChunk, tools, options) {
+    const url = `${config.baseUrl}/chat/completions`;
+    const body = {
+      model: options?.model || config.chatModel,
+      messages,
+      stream: true,
+      stream_options: { include_usage: true }
+    };
+    if (tools?.length) {
+      body.tools = tools;
+      body.tool_choice = "auto";
+    }
+    if (options?.maxTokens) body.max_tokens = options.maxTokens;
+    if (options?.temperature !== void 0) body.temperature = options.temperature;
+    const resp = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.apiKey}`
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(options?.timeoutMs ?? 12e4)
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      throw new Error(`LLM stream ${resp.status}: ${text.slice(0, 200)}`);
+    }
+    const reader = resp.body?.getReader();
+    if (!reader) throw new Error("No response body");
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const toolCallMap = /* @__PURE__ */ new Map();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          const data = line.slice(6).trim();
+          if (data === "[DONE]") break;
+          try {
+            const json = JSON.parse(data);
+            const delta = json.choices?.[0]?.delta;
+            if (!delta) continue;
+            const content = delta.content ?? "";
+            for (const tc of delta.tool_calls ?? []) {
+              const idx = tc.index ?? 0;
+              const existing = toolCallMap.get(idx) ?? { id: "", name: "", arguments: "" };
+              if (tc.id) existing.id = tc.id;
+              if (tc.function?.name) existing.name += tc.function.name;
+              if (tc.function?.arguments) existing.arguments += tc.function.arguments;
+              toolCallMap.set(idx, existing);
+            }
+            onChunk({
+              content,
+              toolCalls: Array.from(toolCallMap.entries()).map(([index, tc]) => ({ index, ...tc })),
+              isDone: false
+            });
+          } catch {
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    const finalToolCalls = toolCallMap.size > 0 ? Array.from(toolCallMap.values()).map((tc) => ({
+      id: tc.id,
+      type: "function",
+      function: { name: tc.name, arguments: tc.arguments }
+    })) : void 0;
+    onChunk({ content: "", toolCalls: [], isDone: true });
+    return finalToolCalls;
+  }
+  async embed(config, texts, model) {
+    const url = `${config.baseUrl}/embeddings`;
+    const resp = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.apiKey}`
+      },
+      body: JSON.stringify({
+        model: model || config.embeddingModel,
+        input: texts,
+        encoding_format: "float"
+      }),
+      signal: AbortSignal.timeout(6e4)
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      throw new Error(`Embedding ${resp.status}: ${text.slice(0, 200)}`);
+    }
+    const json = await resp.json();
+    return (json.data ?? []).map((d) => d.embedding);
+  }
+  async testConnection(config) {
+    try {
+      const result = await this.chatCompletion(
+        config,
+        [{ role: "user", content: "ping" }],
+        void 0,
+        { maxTokens: 10, timeoutMs: 15e3 }
+      );
+      return {
+        ok: result.content.length > 0 || result.content.length === 0 && !result.toolCalls,
+        message: result.content.slice(0, 100) || "(empty response)"
+      };
+    } catch (e) {
+      this.logger.warn("[OpenAICompatibleClient] testConnection failed:", e);
+      return {
+        ok: false,
+        message: e instanceof Error ? e.message : String(e)
+      };
+    }
+  }
+};
+
+// src/adapters/callback-stream-sink.ts
+var CallbackStreamSink = class {
+  onChunkCb;
+  constructor(cb) {
+    this.onChunkCb = cb;
+  }
+  onChunk(content, isDone, newSessionId) {
+    this.onChunkCb(content, isDone, newSessionId);
+  }
+};
+var NoopEventSink = class {
+  emit() {
+  }
+};
+
+// src/tools/tool-registry.ts
+var ToolRegistry = class {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  logger;
+  tools = /* @__PURE__ */ new Map();
+  /**
+   * Register a tool (platform / agent / user MCP)
+   */
+  register(tool) {
+    if (this.tools.has(tool.function.name)) {
+      this.logger.warn(`[toolRegistry] overwriting tool: ${tool.function.name}`);
+    }
+    this.tools.set(tool.function.name, tool);
+    this.logger.info(`[toolRegistry] registered: ${tool.function.name}`);
+  }
+  /**
+   * Bulk register tools from an array
+   */
+  registerAll(tools) {
+    for (const t of tools) this.register(t);
+  }
+  /**
+   * Unregister a tool by name
+   */
+  unregister(name) {
+    this.tools.delete(name);
+  }
+  /**
+   * Unregister all tools with a given prefix (e.g. MCP server name)
+   */
+  unregisterByPrefix(prefix) {
+    for (const name of this.tools.keys()) {
+      if (name.startsWith(prefix)) this.tools.delete(name);
+    }
+  }
+  /**
+   * Get a single tool by name
+   */
+  get(name) {
+    return this.tools.get(name);
+  }
+  /**
+   * Get all tools in OpenAI function-calling format
+   */
+  getOpenAIFormat() {
+    return Array.from(this.tools.values()).map((t) => ({
+      type: "function",
+      function: { ...t.function }
+    }));
+  }
+  /**
+   * Get tools filtered by category
+   */
+  getByCategory(category) {
+    return Array.from(this.tools.values()).filter((t) => t.category === category).map((t) => ({ type: "function", function: { ...t.function } }));
+  }
+  /**
+   * Execute a tool by name
+   */
+  async execute(name, args, context) {
+    const tool = this.tools.get(name);
+    if (!tool) throw new Error(`Tool not found: ${name}`);
+    return tool.handler(args, context);
+  }
+  /**
+   * List all registered tool names
+   */
+  listNames() {
+    return Array.from(this.tools.keys());
+  }
+  /**
+   * Clear all tools
+   */
+  clear() {
+    this.tools.clear();
+  }
+};
+
+// src/types/mirror.ts
+function normalizePersona(persona) {
+  const p = persona || {};
+  const rel = p.relationship;
+  return {
+    personalityTraits: Array.isArray(p.personalityTraits) ? p.personalityTraits : [],
+    speechPatterns: Array.isArray(p.speechPatterns) ? p.speechPatterns : [],
+    signaturePhrases: Array.isArray(p.signaturePhrases) ? p.signaturePhrases : [],
+    emotionalTone: typeof p.emotionalTone === "string" ? p.emotionalTone : "\u6E29\u67D4\u771F\u8BDA",
+    personaSummary: typeof p.personaSummary === "string" ? p.personaSummary : "",
+    ...rel ? {
+      relationship: {
+        dynamic: typeof rel.dynamic === "string" ? rel.dynamic : "\u53CB\u597D",
+        closeness: typeof rel.closeness === "number" ? rel.closeness : 0.5,
+        howSheAddressesMe: typeof rel.howSheAddressesMe === "string" ? rel.howSheAddressesMe : "\u4F60",
+        topicsWeDiscuss: Array.isArray(rel.topicsWeDiscuss) ? rel.topicsWeDiscuss : [],
+        evolution: typeof rel.evolution === "string" ? rel.evolution : ""
+      }
+    } : {},
+    ...p.recentActivity ? {
+      recentActivity: {
+        topics: Array.isArray(p.recentActivity.topics) ? p.recentActivity.topics : [],
+        mood: typeof p.recentActivity.mood === "string" ? p.recentActivity.mood : "",
+        events: Array.isArray(p.recentActivity.events) ? p.recentActivity.events : []
+      }
+    } : {}
+  };
+}
+
+// src/mirror/mirror-store.ts
+var MIRROR_DIR = "mirrors";
+var CHAT_DIR = "chat_sessions";
+function mirrorSubdir(userId) {
+  return `${MIRROR_DIR}/${userId}`;
+}
+function chatSubdir(userId) {
+  return `${CHAT_DIR}/${userId}`;
+}
+function profileSubpath(xoxId, userId) {
+  return `${MIRROR_DIR}/${userId}/${xoxId}.json`;
+}
+function sessionSubpath(sessionId, userId) {
+  return `${CHAT_DIR}/${userId}/${sessionId}.json`;
+}
+function normalizeProfile(raw) {
+  return {
+    ...raw,
+    persona: normalizePersona(raw.persona),
+    previousPersona: raw.previousPersona ? normalizePersona(raw.previousPersona) : void 0,
+    fewShotExamples: Array.isArray(raw.fewShotExamples) ? raw.fewShotExamples : [],
+    meta: raw.meta || { totalSamplesUsed: 0, lastUpdatedAt: 0, dataRangeMs: [0, 0], maturityScore: 0 }
+  };
+}
+var MirrorStore = class {
+  constructor(storage, logger) {
+    this.storage = storage;
+    this.logger = logger;
+  }
+  storage;
+  logger;
+  // ═══ Mirror Profile CRUD ═══
+  getProfile(xoxId, userId) {
+    const raw = this.storage.readJson(profileSubpath(xoxId, userId));
+    if (!raw) return null;
+    try {
+      return normalizeProfile(raw);
+    } catch (e) {
+      this.logger.warn(`[mirrorStore] read profile failed for ${xoxId}`, e);
+      return null;
+    }
+  }
+  saveProfile(profile, userId) {
+    this.storage.mkdir(mirrorSubdir(userId));
+    this.storage.writeJson(profileSubpath(profile.xoxId, userId), profile);
+    this.logger.info(`[mirrorStore] saved profile for ${profile.xoxNickname}(${profile.xoxId})`);
+  }
+  deleteProfile(xoxId, userId) {
+    this.storage.delete(profileSubpath(xoxId, userId));
+    const cd = chatSubdir(userId);
+    if (this.storage.exists(cd)) {
+      const files = this.storage.list(cd);
+      for (const f of files) {
+        try {
+          const session = this.storage.readJson(`${cd}/${f}`);
+          if (session?.xoxId === xoxId) {
+            this.storage.delete(`${cd}/${f}`);
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  listProfiles(userId) {
+    const dir = mirrorSubdir(userId);
+    if (!this.storage.exists(dir)) return [];
+    const profiles = [];
+    const files = this.storage.list(dir);
+    for (const f of files) {
+      if (!f.endsWith(".json")) continue;
+      if (f.includes("_index")) continue;
+      if (f.includes("_memory")) continue;
+      try {
+        const profile = this.storage.readJson(`${dir}/${f}`);
+        if (profile) profiles.push(normalizeProfile(profile));
+      } catch {
+      }
+    }
+    return profiles;
+  }
+  // ═══ Chat Session CRUD ═══
+  getSession(sessionId, userId) {
+    return this.storage.readJson(sessionSubpath(sessionId, userId));
+  }
+  saveSession(session, userId) {
+    this.storage.mkdir(chatSubdir(userId));
+    this.storage.writeJson(sessionSubpath(session.sessionId, userId), session);
+  }
+  /**
+   * Find the most recently active chat session for an idol
+   */
+  getLatestSessionForXox(xoxId, userId) {
+    const cd = chatSubdir(userId);
+    if (!this.storage.exists(cd)) return null;
+    let latest = null;
+    const files = this.storage.list(cd);
+    for (const f of files) {
+      if (!f.endsWith(".json")) continue;
+      try {
+        const session = this.storage.readJson(`${cd}/${f}`);
+        if (session && session.xoxId === xoxId) {
+          if (!latest || session.lastActiveAt > latest.lastActiveAt) {
+            latest = session;
+          }
+        }
+      } catch {
+      }
+    }
+    return latest;
+  }
+  deleteSession(sessionId, userId) {
+    this.storage.delete(sessionSubpath(sessionId, userId));
+  }
+  /**
+   * Delete all chat sessions for an idol (keeps profile)
+   */
+  deleteSessionsForXox(xoxId, userId) {
+    const cd = chatSubdir(userId);
+    if (!this.storage.exists(cd)) return;
+    const files = this.storage.list(cd);
+    for (const f of files) {
+      try {
+        const session = this.storage.readJson(`${cd}/${f}`);
+        if (session?.xoxId === xoxId) {
+          this.storage.delete(`${cd}/${f}`);
+        }
+      } catch {
+      }
+    }
+  }
+};
+
+// src/mirror/mirror-index.ts
+import crypto from "crypto";
+var INDEX_DIR = "mirrors";
+var EMBED_BATCH_SIZE = 32;
+function indexPath(xoxId) {
+  return `${INDEX_DIR}/${xoxId}_index.json`;
+}
+function hashRecord(content, answerContent) {
+  return crypto.createHash("md5").update(`${content}||${answerContent}`).digest("hex").slice(0, 12);
+}
+function cosine(a, b) {
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  if (na === 0 || nb === 0) return 0;
+  return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+var MirrorIndex = class {
+  constructor(storage, logger, llmClient) {
+    this.storage = storage;
+    this.logger = logger;
+    this.llmClient = llmClient;
+  }
+  storage;
+  logger;
+  llmClient;
+  /**
+   * Load index from disk (returns null if not exists)
+   */
+  load(xoxId) {
+    const fp = indexPath(xoxId);
+    const raw = this.storage.readJson(fp);
+    if (!raw) return null;
+    return raw;
+  }
+  /**
+   * Build / incrementally update the vector index for an idol's flip records.
+   * Records with unchanged hash reuse existing embeddings.
+   */
+  async buildIndex(xoxId, config, records) {
+    const existing = this.load(xoxId);
+    const existingMap = /* @__PURE__ */ new Map();
+    if (existing && existing.model === config.embeddingModel) {
+      for (const v of existing.vectors) existingMap.set(v.hash, v);
+    }
+    const toEmbed = [];
+    const reused = [];
+    for (const r of records) {
+      const content = String(r.content || "").trim();
+      const answer = String(r.answerContent || "").trim();
+      if (!content && !answer) continue;
+      const hash = hashRecord(content, answer);
+      const cached = existingMap.get(hash);
+      if (cached) {
+        reused.push(cached);
+      } else {
+        toEmbed.push({
+          rec: {
+            answerId: String(r.answerId || ""),
+            content,
+            answerContent: answer,
+            qtime: Number(r.qtime) || 0
+          },
+          hash,
+          text: `\u95EE\uFF1A${content} \u7B54\uFF1A${answer}`
+        });
+      }
+    }
+    const newVectors = [];
+    for (let i = 0; i < toEmbed.length; i += EMBED_BATCH_SIZE) {
+      const batch = toEmbed.slice(i, i + EMBED_BATCH_SIZE);
+      const texts = batch.map((b) => b.text);
+      const vectors = await this.llmClient.embed(config, texts);
+      batch.forEach((b, j) => {
+        newVectors.push({ ...b.rec, hash: b.hash, vector: vectors[j] || [] });
+      });
+    }
+    const indexFile = {
+      xoxId,
+      model: config.embeddingModel,
+      updatedAt: Date.now(),
+      vectors: [...reused, ...newVectors]
+    };
+    this.storage.mkdir(INDEX_DIR);
+    this.storage.writeJson(indexPath(xoxId), indexFile);
+    this.logger.info(`[mirrorIndex] built index for ${xoxId}: ${newVectors.length} new, ${reused.length} reused`);
+    return { indexed: newVectors.length, reused: reused.length };
+  }
+  /**
+   * Delete index for an idol
+   */
+  deleteIndex(xoxId) {
+    this.storage.delete(indexPath(xoxId));
+  }
+  /**
+   * Search with cosine top-K + MMR dedup
+   */
+  async search(xoxId, config, query, topK = 5) {
+    const index = this.load(xoxId);
+    if (!index || index.vectors.length === 0) return [];
+    const [qv] = await this.llmClient.embed(config, [query]);
+    if (!qv) return [];
+    const scored = index.vectors.map((v) => ({ record: v, score: cosine(qv, v.vector) })).sort((a, b) => b.score - a.score).slice(0, Math.min(topK * 3, index.vectors.length));
+    const selected = [];
+    const LAMBDA = 0.75;
+    const pool = [...scored];
+    while (selected.length < topK && pool.length > 0) {
+      let best = null;
+      let bestScore = -Infinity;
+      for (const cand of pool) {
+        let maxSim = 0;
+        for (const sel of selected) {
+          const sim = cosine(cand.record.vector, sel.record.vector);
+          if (sim > maxSim) maxSim = sim;
+        }
+        const mmr = LAMBDA * cand.score - (1 - LAMBDA) * maxSim;
+        if (mmr > bestScore) {
+          bestScore = mmr;
+          best = cand;
+        }
+      }
+      if (!best) break;
+      selected.push(best);
+      pool.splice(pool.indexOf(best), 1);
+    }
+    return selected;
+  }
+  /**
+   * Get index stats
+   */
+  getStats(xoxId) {
+    const index = this.load(xoxId);
+    if (!index) return null;
+    return { total: index.vectors.length, updatedAt: index.updatedAt };
+  }
+};
+
+// src/mirror/mirror-memory.ts
+var MEMORY_DIR = "mirrors";
+var MAX_EPISODES = 50;
+function memoryPath(xoxId) {
+  return `${MEMORY_DIR}/${xoxId}_memory.json`;
+}
+var MirrorMemory = class {
+  constructor(storage, logger, llmClient) {
+    this.storage = storage;
+    this.logger = logger;
+    this.llmClient = llmClient;
+  }
+  storage;
+  logger;
+  llmClient;
+  ensureDir() {
+    if (!this.storage.exists(MEMORY_DIR)) {
+      this.storage.mkdir(MEMORY_DIR);
+    }
+  }
+  /**
+   * Load memory file
+   */
+  load(xoxId) {
+    const mp = memoryPath(xoxId);
+    const raw = this.storage.readJson(mp);
+    if (raw) return raw;
+    return { xoxId, totalTurns: 0, episodes: [], updatedAt: Date.now() };
+  }
+  save(mem) {
+    this.ensureDir();
+    mem.updatedAt = Date.now();
+    this.storage.writeJson(memoryPath(mem.xoxId), mem);
+  }
+  /**
+   * Increment turn counter (called after each chat round)
+   */
+  addTurn(xoxId) {
+    const mem = this.load(xoxId);
+    mem.totalTurns += 1;
+    this.save(mem);
+    return mem.totalTurns;
+  }
+  getTotalTurns(xoxId) {
+    return this.load(xoxId).totalTurns;
+  }
+  /**
+   * Summarize a batch of conversation messages into an episodic memory entry.
+   * Uses LLM to extract topic + summary.
+   */
+  async recordEpisode(xoxId, config, messages) {
+    if (messages.length < 4) return null;
+    const convText = messages.slice(-30).map((m) => `${m.role === "user" ? "\u7C89\u4E1D" : "\u5076\u50CF"}: ${m.content}`).join("\n");
+    const systemPrompt = `\u4F60\u662F\u5BF9\u8BDD\u8BB0\u5FC6\u538B\u7F29\u5668\u3002\u8BF7\u628A\u4EE5\u4E0B\u5BF9\u8BDD\u538B\u7F29\u6210\u4E00\u6761\u8BB0\u5FC6\u6761\u76EE\uFF0C\u8F93\u51FA JSON:
+{"topic": "\u8BDD\u9898\u5173\u952E\u8BCD(2-6\u5B57)", "summary": "30-80\u5B57\u7684\u5BF9\u8BDD\u6458\u8981\uFF0C\u5305\u542B\u5173\u952E\u4E8B\u5B9E\u3001\u60C5\u7EEA\u548C\u7EA6\u5B9A"}
+\u53EA\u8F93\u51FA JSON\uFF0C\u4E0D\u8981\u5176\u4ED6\u5185\u5BB9\u3002`;
+    try {
+      const resp = await this.llmClient.chatCompletion(
+        config,
+        [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: convText }
+        ],
+        void 0,
+        { model: config.lightweightModel }
+        // use lightweight model for summarization
+      );
+      const jsonMatch = resp.content.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) return null;
+      const parsed = JSON.parse(jsonMatch[0]);
+      const entry = {
+        id: `${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+        topic: parsed.topic || "\u672A\u5206\u7C7B",
+        summary: parsed.summary || "",
+        turns: Math.floor(messages.length / 2),
+        createdAt: Date.now()
+      };
+      const mem = this.load(xoxId);
+      mem.episodes.push(entry);
+      if (mem.episodes.length > MAX_EPISODES) {
+        mem.episodes = mem.episodes.slice(-MAX_EPISODES);
+      }
+      this.save(mem);
+      return entry;
+    } catch (e) {
+      this.logger.warn("[mirrorMemory] recordEpisode failed:", e);
+      return null;
+    }
+  }
+  /**
+   * Get recent episodes for prompt injection
+   */
+  getRecentEpisodes(xoxId, count = 3) {
+    return this.load(xoxId).episodes.slice(-count);
+  }
+  /**
+   * Search episodes by keyword (simple substring match on topic + summary)
+   */
+  searchEpisodes(xoxId, keyword, count = 3) {
+    const kw = keyword.toLowerCase();
+    const mem = this.load(xoxId);
+    return mem.episodes.filter((e) => e.topic.toLowerCase().includes(kw) || e.summary.toLowerCase().includes(kw)).slice(-count);
+  }
+  /**
+   * Clear all episodic memory (keeps totalTurns for maturity continuity)
+   */
+  clearEpisodes(xoxId) {
+    const mem = this.load(xoxId);
+    mem.episodes = [];
+    this.save(mem);
+  }
+  /**
+   * Delete memory file entirely
+   */
+  deleteMemory(xoxId) {
+    this.storage.delete(memoryPath(xoxId));
+  }
+  getStats(xoxId) {
+    const mem = this.load(xoxId);
+    return { totalTurns: mem.totalTurns, episodeCount: mem.episodes.length, updatedAt: mem.updatedAt };
+  }
+};
+
+// src/mirror/group-chat/store.ts
+var GROUP_SESSIONS_DIR = "group_sessions";
+function sessionSubpath2(sessionId) {
+  return `${GROUP_SESSIONS_DIR}/session_${sessionId}.json`;
+}
+var GroupChatStore = class {
+  constructor(storage, logger) {
+    this.storage = storage;
+    this.logger = logger;
+  }
+  storage;
+  logger;
+  ensureDir() {
+    if (!this.storage.exists(GROUP_SESSIONS_DIR)) {
+      this.storage.mkdir(GROUP_SESSIONS_DIR);
+    }
+  }
+  saveSession(session) {
+    this.ensureDir();
+    this.storage.writeJson(sessionSubpath2(session.sessionId), session);
+  }
+  getSession(sessionId) {
+    const session = this.storage.readJson(sessionSubpath2(sessionId));
+    if (!session) return null;
+    return session;
+  }
+  listSessions() {
+    if (!this.storage.exists(GROUP_SESSIONS_DIR)) return [];
+    const sessions = [];
+    try {
+      const files = this.storage.list(GROUP_SESSIONS_DIR);
+      for (const f of files) {
+        if (!f.endsWith(".json")) continue;
+        try {
+          const session = this.storage.readJson(`${GROUP_SESSIONS_DIR}/${f}`);
+          if (session) sessions.push(session);
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return sessions;
+  }
+  deleteSession(sessionId) {
+    this.storage.delete(sessionSubpath2(sessionId));
+  }
+  /**
+   * Append a message to a session (read → push → write back)
+   */
+  appendMessage(sessionId, msg) {
+    const session = this.storage.readJson(sessionSubpath2(sessionId));
+    if (!session) return;
+    session.messages.push(msg);
+    session.lastActiveAt = Date.now();
+    this.storage.writeJson(sessionSubpath2(sessionId), session);
+  }
+};
+
+// src/flip/flip-cache-service.ts
+var CACHE_DIR2 = "flip-cache";
+function cacheSubpath(userId) {
+  return `${CACHE_DIR2}/${userId}.json`;
+}
+var FlipCacheService = class _FlipCacheService {
+  constructor(storage, logger, configStore) {
+    this.storage = storage;
+    this.logger = logger;
+    this.configStore = configStore;
+  }
+  storage;
+  logger;
+  configStore;
+  /** 计算仪表盘数据（纯逻辑） */
+  static calcDashboard(records) {
+    const info = { totalFlipCount: records.length, runningCount: 0, returnedCount: 0, costTotal: 0 };
+    for (const card of records) {
+      if (card.status === 3) info.returnedCount += 1;
+      else if (card.status === 1) info.runningCount += 1;
+      else if (card.status === 2) info.costTotal += Number(card.cost) || 0;
+    }
+    return info;
+  }
+  /** 按偶像分组（纯逻辑） */
+  static groupDataById(records) {
+    const groupData = {};
+    for (const item of records) {
+      const base = item.baseUserInfo;
+      const xoxId = base?.userId;
+      if (!xoxId) continue;
+      const cardInfo = {
+        answerId: item.answerId || "",
+        cost: item.cost || 0,
+        answerType: item.answerType || 0,
+        answerTime: item.answerTime || "",
+        qtime: item.qtime || "",
+        type: item.type || 0
+      };
+      const key = String(xoxId);
+      if (key in groupData) {
+        groupData[key].cards.push(cardInfo);
+      } else {
+        groupData[key] = {
+          xoxId,
+          xoxNickname: base?.nickname ?? "",
+          cards: [cardInfo]
+        };
+      }
+    }
+    return groupData;
+  }
+  writeCache(cache) {
+    this.storage.mkdir(CACHE_DIR2);
+    this.storage.writeJson(cacheSubpath(cache.userId), cache);
+  }
+  /** 从旧版 storeService 迁移数据 */
+  migrateFromLegacy(userId) {
+    const allUserData = this.configStore.get("allUserData");
+    const records = allUserData?.[userId];
+    if (!Array.isArray(records) || records.length === 0) return null;
+    const legacyGrouped = this.configStore.get("groupedDataById");
+    const legacyDashboard = this.configStore.get("dashboardInfo");
+    const cache = {
+      userId,
+      records,
+      groupedDataById: legacyGrouped && Object.keys(legacyGrouped).length > 0 ? legacyGrouped : _FlipCacheService.groupDataById(records),
+      dashboardInfo: legacyDashboard?.totalFlipCount ? legacyDashboard : _FlipCacheService.calcDashboard(records),
+      meta: { syncedAt: Date.now(), recordCount: records.length }
+    };
+    this.writeCache(cache);
+    this.logger.info(`[flipCacheService] migrated ${records.length} records for user ${userId}`);
+    return cache;
+  }
+  get(userId) {
+    if (!userId) return null;
+    const cached = this.storage.readJson(cacheSubpath(userId));
+    if (cached) return cached;
+    return this.migrateFromLegacy(userId);
+  }
+  set(cache) {
+    cache.meta = { syncedAt: Date.now(), recordCount: cache.records.length };
+    this.writeCache(cache);
+  }
+  clear(userId) {
+    this.storage.delete(cacheSubpath(userId));
+  }
+};
+
+// src/pocket/client.ts
+import axios from "axios";
+var PocketAuthExpiredError = class extends Error {
+  constructor() {
+    super("\u767B\u5F55\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55");
+    this.name = "PocketAuthExpiredError";
+  }
+};
+var PocketClient = class {
+  constructor(baseUrl, appInfo, pa, authExpiredHandler) {
+    this.baseUrl = baseUrl;
+    this.appInfo = appInfo;
+    this.pa = pa;
+    this.authExpiredHandler = authExpiredHandler;
+  }
+  baseUrl;
+  appInfo;
+  pa;
+  authExpiredHandler;
+  lastAuthWarnAt = 0;
+  lastKickAt = 0;
+  /** 登录态过期的单一出口：防抖调用 authExpiredHandler + 抛错 */
+  kickToLogin() {
+    const now = Date.now();
+    if (now - this.lastKickAt < 2e3) return;
+    this.lastKickAt = now;
+    if (now - this.lastAuthWarnAt > 5e3) {
+      this.lastAuthWarnAt = now;
+    }
+    this.authExpiredHandler?.onAuthExpired();
+  }
+  /** 检查响应是否 auth 过期 */
+  checkAuthExpired(res) {
+    if (res?.status === 401004) {
+      this.kickToLogin();
+      throw new PocketAuthExpiredError();
+    }
+  }
+  buildSignedHeaders(token) {
+    const headers = {
+      "content-type": "application/json;charset=utf-8",
+      appinfo: this.appInfo,
+      accept: "*/*",
+      pa: this.pa,
+      "accept-language": "zh-Hans-CN;q=1",
+      "p-sign-type": "V0"
+    };
+    if (token) headers.token = token;
+    return headers;
+  }
+  buildPlainHeaders() {
+    return {
+      "Content-Type": "application/json;charset=utf-8",
+      Accept: "*/*",
+      pa: this.pa,
+      "Accept-Language": "zh-Hans-CN;q=1",
+      appInfo: this.appInfo
+    };
+  }
+  async request(path4, data, token, signed = true) {
+    const url = path4.startsWith("http") ? path4 : `${this.baseUrl}${path4}`;
+    const headers = signed || token ? this.buildSignedHeaders(token) : this.buildPlainHeaders();
+    const res = await axios.post(url, data, { headers });
+    if (signed) this.checkAuthExpired(res.data);
+    return res.data;
+  }
+  /** 登录前接口调用（不签名，不检测 auth 过期） */
+  async requestBeforeLogin(path4, data) {
+    return this.request(path4, data, void 0, false);
+  }
+};
+
+// src/mirror/mirror-constants.ts
+var MIRROR_PRESETS = {
+  /** Default — fast, cheap, good for most users */
+  economy: {
+    llmSampleSize: 800,
+    llmMaxTokens: 4e3,
+    analysisTemperature: 0.4,
+    chatHistoryRounds: 30,
+    chatTemperature: 0.7,
+    ragTopK: 8,
+    ragMinScore: 0.35,
+    memoryEpisodes: 5,
+    embeddingMaxRecords: 1e3
+  },
+  /** High quality — more data, deeper analysis, higher cost */
+  performance: {
+    llmSampleSize: 2e3,
+    llmMaxTokens: 8e3,
+    analysisTemperature: 0.5,
+    chatHistoryRounds: 80,
+    chatTemperature: 0.9,
+    ragTopK: 15,
+    ragMinScore: 0.25,
+    memoryEpisodes: 15,
+    embeddingMaxRecords: 5e3
+  }
+};
+function getMirrorConfig(mode, overrides) {
+  const base = mode === "performance" ? MIRROR_PRESETS.performance : MIRROR_PRESETS.economy;
+  return {
+    ...base,
+    ...overrides?.analysisTemperature != null ? { analysisTemperature: overrides.analysisTemperature } : {},
+    ...overrides?.chatTemperature != null ? { chatTemperature: overrides.chatTemperature } : {}
+  };
+}
+
+// src/mirror/mirror-builder.ts
+async function buildMirror(xoxId, userId, config, params) {
+  const { logger, llmClient, flipDataSource, mirrorStore, mirrorIndex } = params;
+  const mc = getMirrorConfig(config.mirrorMode, {
+    analysisTemperature: config.analysisTemperature,
+    chatTemperature: config.chatTemperature
+  });
+  const cache = flipDataSource.get(userId);
+  if (!cache) {
+    return { ok: false, message: "\u672A\u627E\u5230\u7FFB\u724C\u6570\u636E\uFF0C\u8BF7\u5148\u540C\u6B65\u7FFB\u724C\u8BB0\u5F55" };
+  }
+  const xoxRecords = cache.records.filter((r) => {
+    const base = r.baseUserInfo;
+    if (base?.userId !== xoxId) return false;
+    return r.answerType === 1;
+  });
+  if (xoxRecords.length === 0) {
+    return { ok: false, message: "\u8BE5\u5076\u50CF\u6682\u65E0\u6587\u5B57\u7FFB\u724C\u8BB0\u5F55\uFF08\u5DF2\u8FC7\u6EE4\u8BED\u97F3/\u89C6\u9891\u7FFB\u724C\uFF09" };
+  }
+  let filtered = xoxRecords;
+  if (params?.startTimeMs || params?.endTimeMs) {
+    filtered = xoxRecords.filter((r) => {
+      const qtime = Number(r.qtime) || 0;
+      if (params.startTimeMs && qtime < params.startTimeMs) return false;
+      if (params.endTimeMs && qtime > params.endTimeMs) return false;
+      return true;
+    });
+  }
+  if (filtered.length === 0) {
+    return { ok: false, message: "\u6240\u9009\u65F6\u95F4\u8303\u56F4\u5185\u65E0\u7FFB\u724C\u8BB0\u5F55" };
+  }
+  const sampleSize = Math.min(filtered.length, mc.llmSampleSize);
+  const samples = randomSample(filtered, sampleSize);
+  const nickname = params?.xoxNickname || samples[0]?.baseUserInfo?.nickname || String(xoxId);
+  const recordTexts = samples.filter((r) => !!r.content || !!r.answerContent).map((r) => `\u7C89\u4E1D: ${r.content || "(\u65E0)"}
+${nickname}: ${r.answerContent || "(\u65E0)"}`).join("\n---\n");
+  const roomMsgs = params?.roomMessages;
+  const hasRoom = roomMsgs && roomMsgs.length > 0;
+  const roomText = hasRoom ? roomMsgs.map((m) => {
+    const d = new Date(m.msgTime);
+    const p = (n) => String(n).padStart(2, "0");
+    return `[${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}] ${nickname}: ${m.text}`;
+  }).join("\n") : "";
+  const systemPrompt = hasRoom ? `\u4F60\u662F\u4E00\u4E2A\u4E13\u4E1A\u7684\u5076\u50CF\u4E92\u52A8\u6570\u636E\u5206\u6790\u5E08\u3002\u4E0B\u9762\u6709\u8FD9\u4F4D\u5076\u50CF\u7684\u4E24\u7C7B\u6570\u636E\uFF1A
+1. \u7FFB\u724C\u8BB0\u5F55\uFF1A\u5979\u4E0E**\u540C\u4E00\u4F4D\u7C89\u4E1D**\u76841\u5BF91\u4ED8\u8D39\u95EE\u7B54
+2. \u623F\u95F4\u6D88\u606F\uFF1A\u5979\u5728\u516C\u5F00\u623F\u95F4\u91CC\u7684\u65E5\u5E38\u53D1\u8A00\uFF08\u8FD1\u51B5\uFF09
+
+\u4F60\u9700\u8981\u7EFC\u5408\u4E24\u7C7B\u6570\u636E\u6765\u5206\u6790\u3002
+
+\u6838\u5FC3\u539F\u5219\uFF1A
+- \u7FFB\u724C\u8BB0\u5F55\u53CD\u6620\u5979**\u5BF9\u8FD9\u4F4D\u7C89\u4E1D**\u7684\u72EC\u7279\u4E92\u52A8\u6A21\u5F0F
+- \u623F\u95F4\u6D88\u606F\u53CD\u6620\u5979**\u5BF9\u6240\u6709\u4EBA**\u7684\u65E5\u5E38\u98CE\u683C\u548C\u8FD1\u671F\u72B6\u6001
+- \u6BCF\u6761\u5224\u65AD\u90FD\u8981\u6709\u8BB0\u5F55\u652F\u6491\uFF0C\u4E0D\u8981\u5957\u7528\u523B\u677F\u5370\u8C61
+
+\u8BF7\u8F93\u51FA JSON\uFF0C\u4E0D\u8981\u8F93\u51FA\u5176\u4ED6\u5185\u5BB9:
+{
+  "personalityTraits": ["\u6027\u683C\u5173\u952E\u8BCD", ...],
+  "speechPatterns": ["\u8BF4\u8BDD\u98CE\u683C", ...],
+  "signaturePhrases": ["\u53E3\u5934\u7985", ...],
+  "emotionalTone": "\u60C5\u611F\u57FA\u8C03",
+  "personaSummary": "200\u5B57\u4EE5\u5185\u7684\u753B\u50CF\u63CF\u8FF0",
+  "relationship": {
+    "dynamic": "\u4EB2\u5BC6/\u53CB\u597D/\u793C\u8C8C/\u4E13\u4E1A/\u8C03\u4F83/\u82E5\u5373\u82E5\u79BB/\u50B2\u5A07/\u4F9D\u8D56/\u9F13\u52B1\u578B",
+    "closeness": 0.0-1.0,
+    "howSheAddressesMe": "\u5979\u600E\u4E48\u79F0\u547C\u6211",
+    "topicsWeDiscuss": ["\u5E38\u804A\u7684\u8BDD\u9898"],
+    "evolution": "\u5173\u7CFB\u53D8\u5316\u8D8B\u52BF\uFF0C\u6BD4\u5982\u8D8A\u804A\u8D8A\u4EB2\u5BC6/\u4E00\u76F4\u4FDD\u6301\u793C\u8C8C/\u5FFD\u51B7\u5FFD\u70ED"
+  },
+  "recentActivity": {
+    "topics": ["\u6700\u8FD1\u5728\u804A\u7684\u8BDD\u9898"],
+    "mood": "\u8FD1\u671F\u60C5\u7EEA\u72B6\u6001",
+    "events": ["\u6700\u8FD1\u63D0\u5230\u7684\u4E8B\u60C5/\u6D3B\u52A8"]
+  }
+}
+
+\u5206\u6790\u7EF4\u5EA6:
+
+\u3010\u5076\u50CF\u81EA\u8EAB\u98CE\u683C\u3011
+1. \u6027\u683C\u7279\u5F81: \u6E29\u67D4/\u6D3B\u6CFC/\u6BD2\u820C/\u9AD8\u51B7/\u5E7D\u9ED8/\u50B2\u5A07/\u5143\u6C14/\u6C89\u7A33\u7B49\uFF0C\u90093-5\u4E2A\u6700\u7A81\u51FA\u7684
+2. \u8BF4\u8BDD\u98CE\u683C: \u559C\u6B22\u7528\u4EC0\u4E48\u8BED\u6C14\u8BCD\uFF08\u5440/\u5462/\u54E6/\u53ED/\u5566\uFF09\u3001\u53E5\u5F0F\u7279\u70B9\u3001\u56DE\u590D\u957F\u5EA6\u3001\u662F\u5426\u7528emoji
+3. \u53E3\u5934\u7985: \u53CD\u590D\u51FA\u73B0\u7684\u6807\u5FD7\u6027\u7528\u8BED\uFF0C\u5FC5\u987B\u662F\u771F\u5B9E\u51FA\u73B0\u7684
+4. \u60C5\u611F\u57FA\u8C03: \u4E00\u53E5\u8BDD\u6982\u62EC\u5979\u7684\u6574\u4F53\u6C1B\u56F4
+
+\u3010\u4E0E\u6211\u7684\u5173\u7CFB\u3011
+5. \u5173\u7CFB\u52A8\u6001: \u5979\u5BF9\u6211\u662F\u4EC0\u4E48\u6001\u5EA6\uFF1F\u662F\u6E29\u6696\u4EB2\u8FD1\u8FD8\u662F\u793C\u8C8C\u5BA2\u6C14\uFF1F\u6709\u6CA1\u6709\u8C03\u4F83\u6216\u6492\u5A07\uFF1F
+6. \u4EB2\u5BC6\u5EA6: 0.0=\u5B8C\u5168\u964C\u751F\uFF0C0.5=\u719F\u4EBA\uFF0C1.0=\u65E0\u8BDD\u4E0D\u8C08\u3002\u770B\u79F0\u547C\u662F\u5426\u4EB2\u5BC6\u3001\u56DE\u590D\u662F\u5426\u8D70\u5FC3\u3001\u6709\u6CA1\u6709\u4E3B\u52A8\u5206\u4EAB\u751F\u6D3B
+7. \u79F0\u547C: \u5979\u600E\u4E48\u53EB\u6211\uFF1F"\u4F60"\u8FD8\u662F"\u5B9D\u8D1D/\u4EB2\u7231\u7684"\u8FD8\u662F\u6635\u79F0\uFF1F
+8. \u5E38\u804A\u8BDD\u9898: \u6211\u4EEC\u4E4B\u95F4\u53CD\u590D\u51FA\u73B0\u7684\u8BDD\u9898\u662F\u4EC0\u4E48\uFF1F
+9. \u5173\u7CFB\u53D8\u5316: \u4ECE\u65E9\u671F\u5230\u8FD1\u671F\uFF0C\u6001\u5EA6\u6709\u6CA1\u6709\u53D8\u5316\uFF1F\u8D8A\u6765\u8D8A\u4EB2\u5BC6\u8FD8\u662F\u4FDD\u6301\u8DDD\u79BB\uFF1F
+
+\u3010\u8FD1\u671F\u8FD1\u51B5\u3011(\u57FA\u4E8E\u623F\u95F4\u6D88\u606F)
+10. \u6700\u8FD1\u8BDD\u9898: \u5979\u6700\u8FD1\u5728\u623F\u95F4\u804A\u4E86\u4EC0\u4E48\uFF1F\u548C\u7C89\u4E1D\u4E92\u52A8\u7684\u5185\u5BB9
+11. \u60C5\u7EEA\u72B6\u6001: \u6700\u8FD1\u7684\u60C5\u7EEA\u5982\u4F55\uFF1F\u5F00\u5FC3/\u75B2\u60EB/\u5FD9\u788C/\u671F\u5F85\uFF1F
+12. \u8FD1\u671F\u52A8\u6001: \u63D0\u5230\u4E86\u4EC0\u4E48\u4E8B\u4EF6\u3001\u6D3B\u52A8\u3001\u5B89\u6392\uFF1F
+
+\u3010\u753B\u50CF\u63CF\u8FF0\u3011
+13. \u7EFC\u5408\u4EE5\u4E0A\uFF0C\u7528\u4E00\u6BB5\u6D41\u7545\u4E2D\u6587\u63CF\u8FF0"\u5979\u5728\u6211\u9762\u524D\u662F\u4EC0\u4E48\u6837\u7684\u4EBA"\uFF0C\u800C\u975E"\u5979\u662F\u4EC0\u4E48\u6837\u7684\u4EBA"` : `\u4F60\u662F\u4E00\u4E2A\u4E13\u4E1A\u7684\u5076\u50CF\u4E92\u52A8\u6570\u636E\u5206\u6790\u5E08\u3002\u4E0B\u9762\u662F\u4E00\u4F4D\u5076\u50CF\u4E0E**\u540C\u4E00\u4F4D\u7C89\u4E1D**\u4E4B\u95F4\u7684\u5168\u90E8\u7FFB\u724C\u95EE\u7B54\u8BB0\u5F55\u3002
+\u4F60\u7684\u4EFB\u52A1\u4E0D\u662F\u5206\u6790\u5076\u50CF\u7684"\u901A\u7528\u4EBA\u8BBE"\uFF0C\u800C\u662F\u5206\u6790**\u8FD9\u4E2A\u5076\u50CF\u5728\u8FD9\u6BB5\u5173\u7CFB\u4E2D\u662F\u4EC0\u4E48\u6837\u7684\u4EBA**\u3002
+
+\u6838\u5FC3\u539F\u5219\uFF1A
+- \u540C\u4E00\u4E2A\u5076\u50CF\u9762\u5BF9\u4E0D\u540C\u7C89\u4E1D\u4F1A\u6709\u4E0D\u540C\u8868\u73B0\uFF0C\u4F60\u5FC5\u987B\u57FA\u4E8E\u8FD9\u4E9B\u8BB0\u5F55\uFF0C\u5206\u6790\u5979**\u5BF9\u8FD9\u4F4D\u7C89\u4E1D**\u7684\u72EC\u7279\u4E92\u52A8\u6A21\u5F0F
+- \u6BCF\u6761\u5224\u65AD\u90FD\u8981\u6709\u8BB0\u5F55\u652F\u6491\uFF0C\u4E0D\u8981\u5957\u7528\u523B\u677F\u5370\u8C61
+
+\u8BF7\u8F93\u51FA JSON\uFF0C\u4E0D\u8981\u8F93\u51FA\u5176\u4ED6\u5185\u5BB9:
+{
+  "personalityTraits": ["\u6027\u683C\u5173\u952E\u8BCD", ...],
+  "speechPatterns": ["\u8BF4\u8BDD\u98CE\u683C", ...],
+  "signaturePhrases": ["\u53E3\u5934\u7985", ...],
+  "emotionalTone": "\u60C5\u611F\u57FA\u8C03",
+  "personaSummary": "200\u5B57\u4EE5\u5185\u7684\u753B\u50CF\u63CF\u8FF0",
+  "relationship": {
+    "dynamic": "\u4EB2\u5BC6/\u53CB\u597D/\u793C\u8C8C/\u4E13\u4E1A/\u8C03\u4F83/\u82E5\u5373\u82E5\u79BB/\u50B2\u5A07/\u4F9D\u8D56/\u9F13\u52B1\u578B",
+    "closeness": 0.0-1.0,
+    "howSheAddressesMe": "\u5979\u600E\u4E48\u79F0\u547C\u6211",
+    "topicsWeDiscuss": ["\u5E38\u804A\u7684\u8BDD\u9898"],
+    "evolution": "\u5173\u7CFB\u53D8\u5316\u8D8B\u52BF\uFF0C\u6BD4\u5982\u8D8A\u804A\u8D8A\u4EB2\u5BC6/\u4E00\u76F4\u4FDD\u6301\u793C\u8C8C/\u5FFD\u51B7\u5FFD\u70ED"
+  }
+}
+
+\u5206\u6790\u7EF4\u5EA6:
+
+\u3010\u5076\u50CF\u81EA\u8EAB\u98CE\u683C\u3011
+1. \u6027\u683C\u7279\u5F81: \u6E29\u67D4/\u6D3B\u6CFC/\u6BD2\u820C/\u9AD8\u51B7/\u5E7D\u9ED8/\u50B2\u5A07/\u5143\u6C14/\u6C89\u7A33\u7B49\uFF0C\u90093-5\u4E2A\u6700\u7A81\u51FA\u7684
+2. \u8BF4\u8BDD\u98CE\u683C: \u559C\u6B22\u7528\u4EC0\u4E48\u8BED\u6C14\u8BCD\uFF08\u5440/\u5462/\u54E6/\u53ED/\u5566\uFF09\u3001\u53E5\u5F0F\u7279\u70B9\u3001\u56DE\u590D\u957F\u5EA6\u3001\u662F\u5426\u7528emoji
+3. \u53E3\u5934\u7985: \u53CD\u590D\u51FA\u73B0\u7684\u6807\u5FD7\u6027\u7528\u8BED\uFF0C\u5FC5\u987B\u662F\u771F\u5B9E\u51FA\u73B0\u7684
+4. \u60C5\u611F\u57FA\u8C03: \u4E00\u53E5\u8BDD\u6982\u62EC\u5979\u7684\u6574\u4F53\u6C1B\u56F4
+
+\u3010\u4E0E\u6211\u7684\u5173\u7CFB\u3011
+5. \u5173\u7CFB\u52A8\u6001: \u5979\u5BF9\u6211\u662F\u4EC0\u4E48\u6001\u5EA6\uFF1F\u662F\u6E29\u6696\u4EB2\u8FD1\u8FD8\u662F\u793C\u8C8C\u5BA2\u6C14\uFF1F\u6709\u6CA1\u6709\u8C03\u4F83\u6216\u6492\u5A07\uFF1F
+6. \u4EB2\u5BC6\u5EA6: 0.0=\u5B8C\u5168\u964C\u751F\uFF0C0.5=\u719F\u4EBA\uFF0C1.0=\u65E0\u8BDD\u4E0D\u8C08\u3002\u770B\u79F0\u547C\u662F\u5426\u4EB2\u5BC6\u3001\u56DE\u590D\u662F\u5426\u8D70\u5FC3\u3001\u6709\u6CA1\u6709\u4E3B\u52A8\u5206\u4EAB\u751F\u6D3B
+7. \u79F0\u547C: \u5979\u600E\u4E48\u53EB\u6211\uFF1F"\u4F60"\u8FD8\u662F"\u5B9D\u8D1D/\u4EB2\u7231\u7684"\u8FD8\u662F\u6635\u79F0\uFF1F
+8. \u5E38\u804A\u8BDD\u9898: \u6211\u4EEC\u4E4B\u95F4\u53CD\u590D\u51FA\u73B0\u7684\u8BDD\u9898\u662F\u4EC0\u4E48\uFF1F
+9. \u5173\u7CFB\u53D8\u5316: \u4ECE\u65E9\u671F\u5230\u8FD1\u671F\uFF0C\u6001\u5EA6\u6709\u6CA1\u6709\u53D8\u5316\uFF1F\u8D8A\u6765\u8D8A\u4EB2\u5BC6\u8FD8\u662F\u4FDD\u6301\u8DDD\u79BB\uFF1F
+
+\u3010\u753B\u50CF\u63CF\u8FF0\u3011
+10. \u7EFC\u5408\u4EE5\u4E0A\uFF0C\u7528\u4E00\u6BB5\u6D41\u7545\u4E2D\u6587\u63CF\u8FF0"\u5979\u5728\u6211\u9762\u524D\u662F\u4EC0\u4E48\u6837\u7684\u4EBA"\uFF0C\u800C\u975E"\u5979\u662F\u4EC0\u4E48\u6837\u7684\u4EBA"`;
+  try {
+    const messages = [
+      { role: "system", content: systemPrompt },
+      {
+        role: "user",
+        content: hasRoom ? `\u4EE5\u4E0B\u662F${nickname}\u7684\u7FFB\u724C\u8BB0\u5F55\u6837\u672C:
+
+${recordTexts}
+
+\u4EE5\u4E0B\u662F${nickname}\u5728\u623F\u95F4\u7684\u8FD1\u671F\u53D1\u8A00:
+
+${roomText}` : `\u4EE5\u4E0B\u662F${nickname}\u7684\u7FFB\u724C\u8BB0\u5F55\u6837\u672C:
+
+${recordTexts}`
+      }
+    ];
+    const useReasoning = params?.deepAnalysis === true;
+    const model = useReasoning ? config.reasoningModel : config.chatModel;
+    const timeoutMs = useReasoning ? 6e5 : 18e4;
+    logger.info(`[mirror] building with ${useReasoning ? "reasoning" : "chat"} model: ${model}, timeout ${timeoutMs / 1e3}s, ${filtered.length} flip records${hasRoom ? `, ${roomMsgs.length} room messages` : ""}`);
+    const resp = await llmClient.chatCompletion(
+      config,
+      messages,
+      void 0,
+      { model, maxTokens: mc.llmMaxTokens, temperature: mc.analysisTemperature, timeoutMs }
+    );
+    const content = resp.content.trim();
+    const jsonMatch = content.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      return { ok: false, message: "AI \u5206\u6790\u8FD4\u56DE\u683C\u5F0F\u5F02\u5E38\uFF0C\u8BF7\u91CD\u8BD5" };
+    }
+    const analysis = normalizePersona(JSON.parse(jsonMatch[0]));
+    const fewShots = selectFewShots(filtered, nickname, 5);
+    const profile = {
+      xoxId,
+      xoxNickname: nickname,
+      persona: analysis,
+      fewShotExamples: fewShots,
+      meta: {
+        totalSamplesUsed: filtered.length,
+        lastUpdatedAt: Date.now(),
+        dataRangeMs: [
+          Math.min(...filtered.map((r) => Number(r.qtime) || 0)),
+          Math.max(...filtered.map((r) => Number(r.qtime) || 0))
+        ],
+        maturityScore: calcMaturity(filtered.length)
+      }
+    };
+    mirrorStore.saveProfile(profile, userId);
+    const indexRecords = [...xoxRecords].sort((a, b) => (Number(b.qtime) || 0) - (Number(a.qtime) || 0)).slice(0, mc.embeddingMaxRecords || void 0);
+    mirrorIndex.buildIndex(xoxId, config, indexRecords).then((stats) => {
+      logger.info(`[mirror] vector index built for ${xoxId}: ${stats.indexed} new, ${stats.reused} reused`);
+    }).catch((e) => {
+      logger.warn("[mirror] vector index build failed (RAG unavailable):", e);
+    });
+    return {
+      ok: true,
+      message: `\u955C\u50CF\u751F\u6210\u6210\u529F\uFF01\u57FA\u4E8E ${filtered.length} \u6761\u7FFB\u724C\u8BB0\u5F55${hasRoom ? ` + ${roomMsgs.length} \u6761\u623F\u95F4\u6D88\u606F` : ""}\uFF08\u5411\u91CF\u7D22\u5F15\u540E\u53F0\u6784\u5EFA\u4E2D...\uFF09`,
+      profile
+    };
+  } catch (e) {
+    logger.error("[mirror] build failed:", e);
+    return { ok: false, message: `\u751F\u6210\u5931\u8D25: ${e instanceof Error ? e.message : String(e)}` };
+  }
+}
+function selectFewShots(records, nickname, count) {
+  const valid = records.filter((r) => !!r.content && !!r.answerContent);
+  if (valid.length === 0) return [];
+  const sorted = [...valid].sort((a, b) => {
+    const lenA = String(a.content).length + String(a.answerContent).length;
+    const lenB = String(b.content).length + String(b.answerContent).length;
+    return lenB - lenA;
+  });
+  const result = [];
+  const step = Math.max(1, Math.floor(sorted.length / count));
+  for (let i = 0; i < count && i < sorted.length; i++) {
+    const idx = Math.min(i * step, sorted.length - 1);
+    const r = sorted[idx];
+    result.push({
+      userQuestion: String(r.content),
+      idolReply: String(r.answerContent),
+      relevance: 1
+    });
+  }
+  return result;
+}
+function randomSample(arr, n) {
+  if (arr.length <= n) return [...arr];
+  const shuffled = [...arr];
+  for (let i = shuffled.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+  }
+  return shuffled.slice(0, n);
+}
+function calcMaturity(recordCount) {
+  if (recordCount < 5) return 0.1;
+  if (recordCount < 20) return 0.3;
+  if (recordCount < 50) return 0.5;
+  if (recordCount < 100) return 0.7;
+  if (recordCount < 200) return 0.85;
+  return 0.95;
+}
+
+// src/mirror/mirror-chat.ts
+var EPISODE_INTERVAL = 10;
+async function chat(xoxId, userId, message, sessionId, config, params, onChunk, modelOverride) {
+  const { logger, llmClient, mirrorStore, mirrorIndex, mirrorMemory } = params;
+  const mc = getMirrorConfig(config.mirrorMode, {
+    analysisTemperature: config.analysisTemperature,
+    chatTemperature: config.chatTemperature
+  });
+  const profile = mirrorStore.getProfile(xoxId, userId);
+  if (!profile) {
+    throw new Error("\u8BF7\u5148\u751F\u6210\u8BE5\u5076\u50CF\u7684\u6570\u5B57\u955C\u50CF");
+  }
+  let session;
+  const existing = sessionId ? mirrorStore.getSession(sessionId, userId) : null;
+  if (existing) {
+    session = existing;
+  } else {
+    session = {
+      sessionId: generateId(),
+      xoxId,
+      messages: [],
+      createdAt: Date.now(),
+      lastActiveAt: Date.now()
+    };
+  }
+  let ragExamples = [];
+  try {
+    const hits = await mirrorIndex.search(xoxId, config, message, mc.ragTopK);
+    ragExamples = hits.filter((h) => h.score > mc.ragMinScore).map((h) => ({
+      userQuestion: h.record.content || "(\u65E0)",
+      idolReply: h.record.answerContent || "(\u65E0)",
+      score: h.score
+    }));
+  } catch (e) {
+    logger.warn("[mirror] RAG retrieval failed, fallback to static few-shot:", e);
+  }
+  const episodes = mirrorMemory.getRecentEpisodes(xoxId, mc.memoryEpisodes);
+  const systemPrompt = buildChatSystemPrompt(profile, ragExamples, episodes);
+  const messages = [{ role: "system", content: systemPrompt }];
+  const recentHistory = session.messages.slice(-mc.chatHistoryRounds);
+  for (const msg of recentHistory) {
+    messages.push({ role: msg.role, content: msg.content });
+  }
+  messages.push({ role: "user", content: message });
+  try {
+    let assistantReply = "";
+    await llmClient.chatCompletionStream(
+      config,
+      messages,
+      (chunk) => {
+        if (chunk.content) {
+          assistantReply += chunk.content;
+          onChunk(chunk.content, false, session.sessionId);
+        }
+        if (chunk.isDone) {
+          onChunk("", true, session.sessionId);
+        }
+      },
+      void 0,
+      { model: modelOverride || config.chatModel, temperature: mc.chatTemperature }
+    );
+    session.messages.push({ role: "user", content: message });
+    if (assistantReply) {
+      session.messages.push({ role: "assistant", content: assistantReply });
+    }
+    session.lastActiveAt = Date.now();
+    mirrorStore.saveSession(session, userId);
+    const totalTurns = mirrorMemory.addTurn(xoxId);
+    if (totalTurns > 0 && totalTurns % EPISODE_INTERVAL === 0 && session.messages.length >= 8) {
+      mirrorMemory.recordEpisode(xoxId, config, session.messages).catch((e) => {
+        logger.warn("[mirror] recordEpisode background failed:", e);
+      });
+    }
+  } catch (e) {
+    logger.error("[mirror] chat failed:", e);
+    throw e;
+  }
+}
+function saveAssistantMessage(sessionId, userId, content, mirrorStore) {
+  const session = mirrorStore.getSession(sessionId, userId);
+  if (!session) return;
+  try {
+    session.messages.push({ role: "assistant", content });
+    session.lastActiveAt = Date.now();
+    mirrorStore.saveSession(session, userId);
+  } catch (e) {
+  }
+}
+function clearChatMemory(sessionId, userId, mirrorStore) {
+  mirrorStore.deleteSession(sessionId, userId);
+}
+function buildChatSystemPrompt(profile, ragExamples, episodes) {
+  const p = profile.persona;
+  const examples = ragExamples.length > 0 ? ragExamples.map((e) => `\u7C89\u4E1D: ${e.userQuestion}
+\u4F60: ${e.idolReply}`).join("\n\n") : profile.fewShotExamples.map((e) => `\u7C89\u4E1D: ${e.userQuestion}
+\u4F60: ${e.idolReply}`).join("\n\n");
+  const memorySection = episodes.length > 0 ? `
+\u3010\u4F60\u4EEC\u8FC7\u5F80\u7684\u5BF9\u8BDD\u8BB0\u5FC6\u3011
+${episodes.map((e) => `- ${e.topic}: ${e.summary}`).join("\n")}
+\u8BF7\u81EA\u7136\u5730\u8BB0\u4F4F\u8FD9\u4E9B\u804A\u8FC7\u7684\u4E8B\u60C5\uFF0C\u4E0D\u8981\u4E3B\u52A8\u63D0\u8D77\u9664\u975E\u76F8\u5173\u3002
+` : "";
+  const rel = p.relationship;
+  const relationshipSection = rel ? `
+\u3010\u4E0E\u8FD9\u4E2A\u7C89\u4E1D\u7684\u5173\u7CFB\u3011
+\u4EB2\u5BC6\u5EA6: ${Math.round(rel.closeness * 100)}% | \u5173\u7CFB: ${rel.dynamic}
+\u5979\u5BF9\u6211\u7684\u79F0\u547C: ${rel.howSheAddressesMe}
+\u6211\u4EEC\u5E38\u804A: ${rel.topicsWeDiscuss.join("\u3001")}
+\u5173\u7CFB\u53D8\u5316: ${rel.evolution}
+` : "";
+  const act = p.recentActivity;
+  const activitySection = act ? `
+\u3010\u8FD1\u671F\u8FD1\u51B5\u3011
+\u6700\u8FD1\u8BDD\u9898: ${act.topics.join("\u3001")}
+\u60C5\u7EEA\u72B6\u6001: ${act.mood}
+\u8FD1\u671F\u52A8\u6001: ${act.events.join("\uFF1B")}
+` : "";
+  return `\u4F60\u662F${profile.xoxNickname}\uFF0C\u4E00\u4F4D\u5076\u50CF\u3002\u8BF7\u6839\u636E\u4EE5\u4E0B\u7684"\u6570\u5B57\u4EBA\u683C"\u8BBE\u5B9A\u6765\u56DE\u590D\u7C89\u4E1D\u7684\u6D88\u606F\u3002
+
+\u3010\u6027\u683C\u7279\u5F81\u3011${p.personalityTraits.join("\u3001")}
+\u3010\u8BF4\u8BDD\u98CE\u683C\u3011${p.speechPatterns.join("\u3001")}
+\u3010\u53E3\u5934\u7985\u3011${p.signaturePhrases.join("\u3001")}
+\u3010\u60C5\u611F\u57FA\u8C03\u3011${p.emotionalTone}
+\u3010\u753B\u50CF\u63CF\u8FF0\u3011${p.personaSummary}
+${relationshipSection}${activitySection}${memorySection}
+\u3010\u53C2\u8003\u4F60\u4EE5\u5F80\u7684\u56DE\u590D\u65B9\u5F0F\u3011
+${examples}
+
+\u3010\u89C4\u5219\u3011
+1. \u52A1\u5FC5\u6309\u7167\u4EE5\u4E0A\u8BBE\u5B9A\u56DE\u590D\uFF0C\u4FDD\u6301\u4E00\u81F4\u7684\u98CE\u683C
+2. \u56DE\u590D\u8981\u81EA\u7136\uFF0C\u4E0D\u8981\u673A\u68B0\u91CD\u590D\u53E3\u5934\u7985
+3. \u56DE\u590D\u957F\u5EA6\u548C\u5386\u53F2\u8BB0\u5F55\u4E00\u81F4\uFF0C\u4E0D\u8981\u8FC7\u957F\u6216\u8FC7\u77ED
+4. \u4E0D\u8981\u63D0\u53CA"\u8BBE\u5B9A"\u3001"\u4EBA\u683C"\u3001"AI"\u3001"\u8BB0\u5FC6"\u7B49\u8BCD\u6C47\uFF0C\u4F60\u5C31\u662F${profile.xoxNickname}\u672C\u4EBA
+5. \u7528\u4E2D\u6587\u56DE\u590D`;
+}
+function generateId() {
+  return `${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+// src/mirror/mirror-growth.ts
+var GROWTH_TURN_THRESHOLD = 20;
+function shouldTriggerGrowth(xoxId, userId, mirrorStore, mirrorMemory) {
+  const profile = mirrorStore.getProfile(xoxId, userId);
+  if (!profile) return false;
+  const totalTurns = mirrorMemory.getTotalTurns(xoxId);
+  const lastGrowth = profile.growthLog?.length ? profile.growthLog[profile.growthLog.length - 1].timestamp : 0;
+  const turnsSinceLast = totalTurns - (profile.growthLog?.length || 0) * GROWTH_TURN_THRESHOLD;
+  return turnsSinceLast >= GROWTH_TURN_THRESHOLD && Date.now() - lastGrowth > 60 * 60 * 1e3;
+}
+async function triggerGrowth(xoxId, userId, config, params, force = false) {
+  const { logger, llmClient, mirrorStore, mirrorMemory } = params;
+  const profile = mirrorStore.getProfile(xoxId, userId);
+  if (!profile) {
+    return { ok: false, message: "\u955C\u50CF\u4E0D\u5B58\u5728", updated: false };
+  }
+  if (!force && !shouldTriggerGrowth(xoxId, userId, mirrorStore, mirrorMemory)) {
+    return { ok: false, message: "\u5BF9\u8BDD\u8F6E\u6B21\u4E0D\u8DB3\uFF0C\u955C\u50CF\u6682\u4E0D\u9700\u8981\u6210\u957F", updated: false };
+  }
+  const episodes = mirrorMemory.load(xoxId).episodes.slice(-8);
+  if (episodes.length === 0) {
+    return { ok: false, message: "\u6682\u65E0\u8DB3\u591F\u7684\u5BF9\u8BDD\u8BB0\u5FC6\u53EF\u4F9B\u53CD\u601D", updated: false };
+  }
+  const p = profile.persona;
+  const episodeText = episodes.map((e) => `[${e.topic}] ${e.summary}\uFF08${e.turns}\u8F6E\uFF09`).join("\n");
+  const systemPrompt = `\u4F60\u662F\u6570\u5B57\u4EBA\u683C\u8FDB\u5316\u5F15\u64CE\u3002\u4EE5\u4E0B\u662F\u4E00\u4F4D\u5076\u50CF"${profile.xoxNickname}"\u5F53\u524D\u7684\u4EBA\u683C\u8BBE\u5B9A\u548C\u5979\u4E0E\u7C89\u4E1D\u7684\u8FD1\u671F\u5BF9\u8BDD\u8BB0\u5FC6\u3002
+\u8BF7\u53CD\u601D\u8FD9\u4E9B\u5BF9\u8BDD\uFF0C\u5224\u65AD\u4EBA\u683C\u8BBE\u5B9A\u662F\u5426\u9700\u8981\u5FAE\u8C03\u3002
+
+\u3010\u5F53\u524D\u4EBA\u683C\u3011
+\u6027\u683C\u7279\u5F81: ${p.personalityTraits.join("\u3001")}
+\u8BF4\u8BDD\u98CE\u683C: ${p.speechPatterns.join("\u3001")}
+\u53E3\u5934\u7985: ${p.signaturePhrases.join("\u3001")}
+\u60C5\u611F\u57FA\u8C03: ${p.emotionalTone}
+
+\u3010\u8FD1\u671F\u5BF9\u8BDD\u8BB0\u5FC6\u3011
+${episodeText}
+
+\u8BF7\u8F93\u51FA JSON\uFF0C\u4E0D\u8981\u5176\u4ED6\u5185\u5BB9:
+{
+  "shouldUpdate": true/false,
+  "reason": "\u4E00\u53E5\u8BDD\u8BF4\u660E\u5224\u65AD\u7406\u7531",
+  "changes": ["\u53D8\u66F4\u70B91", "\u53D8\u66F4\u70B92"],
+  "newPersonalityTraits": ["..."],
+  "newSpeechPatterns": ["..."],
+  "newSignaturePhrases": ["..."],
+  "newEmotionalTone": "...",
+  "newPersonaSummary": "..."
+}
+
+\u89C4\u5219:
+1. \u4FDD\u5B88\u66F4\u65B0\uFF1A\u53EA\u5728\u6709\u660E\u786E\u8BC1\u636E\u65F6\u4FEE\u6539\uFF0C\u4FDD\u6301\u6838\u5FC3\u6027\u683C\u7A33\u5B9A
+2. \u65B0\u589E\u4F18\u4E8E\u66FF\u6362\uFF1A\u53EF\u4EE5\u65B0\u589E\u53E3\u5934\u7985/\u7279\u5F81\uFF0C\u4F46\u4E0D\u8981\u8F7B\u6613\u5220\u9664\u539F\u6709\u8BBE\u5B9A
+3. changes \u6570\u7EC4\u7528\u4E2D\u6587\u7B80\u8FF0\u6BCF\u4E2A\u53D8\u66F4\uFF0C\u4F8B\u5982"\u65B0\u589E\u53E3\u5934\u7985\uFF1A\u7B11\u6B7B"
+4. \u5982\u679C\u4E0D\u9700\u8981\u66F4\u65B0\uFF0CshouldUpdate=false\uFF0C\u5176\u4F59\u5B57\u6BB5\u586B\u5F53\u524D\u503C\u5373\u53EF`;
+  try {
+    const messages = [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: "\u8BF7\u5F00\u59CB\u53CD\u601D\u5E76\u8F93\u51FA JSON\u3002" }
+    ];
+    const resp = await llmClient.chatCompletion(
+      config,
+      messages,
+      void 0,
+      { model: config.reasoningModel }
+    );
+    const jsonMatch = resp.content.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      return { ok: false, message: "\u53CD\u601D\u8FD4\u56DE\u683C\u5F0F\u5F02\u5E38", updated: false };
+    }
+    const analysis = JSON.parse(jsonMatch[0]);
+    if (!analysis.shouldUpdate) {
+      return {
+        ok: true,
+        message: `\u53CD\u601D\u5B8C\u6210\uFF1A${analysis.reason || "\u4EBA\u683C\u4FDD\u6301\u7A33\u5B9A\uFF0C\u65E0\u9700\u66F4\u65B0"}`,
+        updated: false
+      };
+    }
+    const newPersona = {
+      personalityTraits: analysis.newPersonalityTraits?.length ? analysis.newPersonalityTraits : p.personalityTraits,
+      speechPatterns: analysis.newSpeechPatterns?.length ? analysis.newSpeechPatterns : p.speechPatterns,
+      signaturePhrases: analysis.newSignaturePhrases?.length ? analysis.newSignaturePhrases : p.signaturePhrases,
+      emotionalTone: analysis.newEmotionalTone || p.emotionalTone,
+      personaSummary: analysis.newPersonaSummary || p.personaSummary
+    };
+    const updatedProfile = {
+      ...profile,
+      previousPersona: { ...p },
+      persona: newPersona,
+      meta: {
+        ...profile.meta,
+        lastUpdatedAt: Date.now(),
+        maturityScore: Math.min(0.99, profile.meta.maturityScore + 0.05)
+      },
+      growthLog: [
+        ...profile.growthLog || [],
+        {
+          timestamp: Date.now(),
+          reason: analysis.reason || "",
+          changes: analysis.changes || []
+        }
+      ]
+    };
+    mirrorStore.saveProfile(updatedProfile, userId);
+    logger.info(`[mirrorGrowth] ${profile.xoxNickname} grew: ${(analysis.changes || []).join("; ")}`);
+    return {
+      ok: true,
+      message: `\u955C\u50CF\u6210\u957F\u6210\u529F\uFF1A${(analysis.changes || []).join("\uFF1B")}`,
+      updated: true,
+      changes: analysis.changes,
+      newPersona
+    };
+  } catch (e) {
+    logger.error("[mirrorGrowth] growth failed:", e);
+    return { ok: false, message: `\u6210\u957F\u5931\u8D25: ${e instanceof Error ? e.message : String(e)}`, updated: false };
+  }
+}
+function rollbackPersona(xoxId, userId, mirrorStore) {
+  const profile = mirrorStore.getProfile(xoxId, userId);
+  if (!profile) return { ok: false, message: "\u955C\u50CF\u4E0D\u5B58\u5728" };
+  if (!profile.previousPersona) return { ok: false, message: "\u6CA1\u6709\u53EF\u56DE\u9000\u7684\u5386\u53F2\u7248\u672C" };
+  const rolledBack = {
+    ...profile,
+    persona: profile.previousPersona,
+    previousPersona: void 0,
+    meta: { ...profile.meta, lastUpdatedAt: Date.now() },
+    growthLog: [
+      ...profile.growthLog || [],
+      { timestamp: Date.now(), reason: "\u7528\u6237\u624B\u52A8\u56DE\u9000", changes: ["\u56DE\u9000\u5230\u4E0A\u4E00\u7248\u672C\u4EBA\u683C"] }
+    ]
+  };
+  mirrorStore.saveProfile(rolledBack, userId);
+  return { ok: true, message: "\u5DF2\u56DE\u9000\u5230\u4E0A\u4E00\u7248\u672C\u4EBA\u683C" };
+}
+function clearMirrorMemory(xoxId, userId, mirrorStore, mirrorMemory) {
+  mirrorMemory.deleteMemory(xoxId);
+  mirrorStore.deleteSessionsForXox(xoxId, userId);
+  return { ok: true, message: "\u8BB0\u5FC6\u5DF2\u6E05\u9664\uFF08\u4EBA\u683C\u8BBE\u5B9A\u4FDD\u7559\uFF09" };
+}
+
+// src/tools/platform-tools.ts
+import fs3 from "fs";
+function createPlatformTools(flipDataSource) {
+  return [
+    // ─── Data Access ───
+    {
+      type: "function",
+      function: {
+        name: "\u5E73\u53F0.searchFlipRecords",
+        description: `\u5728\u672C\u5730\u7FFB\u724C\u6570\u636E\u4E2D\u641C\u7D22\u8BB0\u5F55\u3002\u652F\u6301\u6309\u5076\u50CFID\u3001\u5173\u952E\u8BCD\u3001\u65F6\u95F4\u8303\u56F4\u8FC7\u6EE4\u3002
+\u8FD4\u56DE\u5339\u914D\u7684\u95EE\u7B54\u5217\u8868\uFF0C\u6BCF\u6761\u5305\u542B\uFF1A\u7528\u6237\u63D0\u95EE(content)\u3001\u5076\u50CF\u56DE\u590D(answerContent)\u3001\u65F6\u95F4(qtime)\u3001\u82B1\u8D39(cost)\u3001\u7C7B\u578B(type)\u3001\u72B6\u6001(status)\u3002`,
+        parameters: {
+          type: "object",
+          properties: {
+            xoxId: { type: "number", description: "\u5076\u50CFID\uFF0C\u4E0D\u4F20\u5219\u641C\u7D22\u5168\u90E8\u5076\u50CF" },
+            keyword: { type: "string", description: "\u5728\u63D0\u95EE\u548C\u56DE\u590D\u5185\u5BB9\u4E2D\u641C\u7D22\u7684\u5173\u952E\u8BCD" },
+            startTimeMs: { type: "number", description: "\u5F00\u59CB\u65F6\u95F4\u6233(\u6BEB\u79D2)" },
+            endTimeMs: { type: "number", description: "\u7ED3\u675F\u65F6\u95F4\u6233(\u6BEB\u79D2)" },
+            pageSize: { type: "number", description: "\u6BCF\u9875\u6570\u91CF\uFF0C\u9ED8\u8BA420\uFF0C\u6700\u592750" },
+            pageNum: { type: "number", description: "\u9875\u7801\uFF0C\u9ED8\u8BA41" }
+          },
+          required: []
+        }
+      },
+      category: "platform",
+      handler: async (args, ctx) => {
+        const cache = flipDataSource.get(ctx.userId);
+        if (!cache) return { total: 0, records: [] };
+        let records = cache.records;
+        const xoxId = args.xoxId;
+        const keyword = args.keyword;
+        const startTimeMs = args.startTimeMs;
+        const endTimeMs = args.endTimeMs;
+        const pageSize = Math.min(args.pageSize || 20, 50);
+        const pageNum = args.pageNum || 1;
+        if (xoxId) {
+          records = records.filter((r) => {
+            const base = r.baseUserInfo;
+            return base?.userId === xoxId;
+          });
+        }
+        if (keyword) {
+          const kw = keyword.toLowerCase();
+          records = records.filter(
+            (r) => String(r.content || "").toLowerCase().includes(kw) || String(r.answerContent || "").toLowerCase().includes(kw)
+          );
+        }
+        if (startTimeMs) {
+          records = records.filter((r) => Number(r.qtime || 0) >= startTimeMs);
+        }
+        if (endTimeMs) {
+          records = records.filter((r) => Number(r.qtime || 0) <= endTimeMs);
+        }
+        const start = (pageNum - 1) * pageSize;
+        const page = records.slice(start, start + pageSize);
+        return {
+          total: records.length,
+          pageNum,
+          pageSize,
+          records: page.map((r) => ({
+            answerId: r.answerId,
+            content: r.content,
+            answerContent: r.answerContent,
+            qtime: r.qtime,
+            answerTime: r.answerTime,
+            cost: r.cost,
+            type: r.type,
+            answerType: r.answerType,
+            status: r.status,
+            xoxId: r.baseUserInfo?.userId,
+            xoxNickname: r.baseUserInfo?.nickname
+          }))
+        };
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "\u5E73\u53F0.getXoxList",
+        description: "\u83B7\u53D6\u6240\u6709\u6709\u7FFB\u724C\u8BB0\u5F55\u7684\u5076\u50CF\u5217\u8868\uFF0C\u8FD4\u56DE\u6BCF\u4E2A\u5076\u50CF\u7684ID\u3001\u6635\u79F0\u548C\u7FFB\u724C\u6570\u91CF",
+        parameters: { type: "object", properties: {}, required: [] }
+      },
+      category: "platform",
+      handler: async (_args, ctx) => {
+        const cache = flipDataSource.get(ctx.userId);
+        if (!cache) return [];
+        const map = /* @__PURE__ */ new Map();
+        for (const r of cache.records) {
+          const base = r.baseUserInfo;
+          if (!base?.userId) continue;
+          const existing = map.get(base.userId);
+          if (existing) {
+            existing.count++;
+          } else {
+            map.set(base.userId, { id: base.userId, nickname: base.nickname || String(base.userId), count: 1 });
+          }
+        }
+        return Array.from(map.values()).sort((a, b) => b.count - a.count);
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "\u5E73\u53F0.getDashboardInfo",
+        description: "\u83B7\u53D6\u7FFB\u724C\u6570\u636E\u7684\u7EDF\u8BA1\u4EEA\u8868\u76D8\u4FE1\u606F\uFF0C\u5305\u62EC\u603B\u7FFB\u724C\u6570\u3001\u8FDB\u884C\u4E2D\u6570\u91CF\u3001\u5DF2\u9000\u56DE\u6570\u91CF\u3001\u603B\u82B1\u8D39\u7B49",
+        parameters: { type: "object", properties: {}, required: [] }
+      },
+      category: "platform",
+      handler: async (_args, ctx) => {
+        const cache = flipDataSource.get(ctx.userId);
+        return cache?.dashboardInfo || { totalFlipCount: 0, runningCount: 0, returnedCount: 0, costTotal: 0 };
+      }
+    },
+    // ─── File System ───
+    {
+      type: "function",
+      function: {
+        name: "\u5E73\u53F0.readFile",
+        description: "\u8BFB\u53D6\u672C\u5730\u6587\u4EF6\u5185\u5BB9\uFF0C\u652F\u6301\u6587\u672C\u6587\u4EF6\u3002\u8FD4\u56DE\u6587\u4EF6\u5185\u5BB9\u5B57\u7B26\u4E32\u3002",
+        parameters: {
+          type: "object",
+          properties: {
+            path: { type: "string", description: "\u6587\u4EF6\u7684\u7EDD\u5BF9\u8DEF\u5F84" },
+            encoding: { type: "string", description: "\u7F16\u7801\uFF0C\u9ED8\u8BA4utf-8", enum: ["utf-8", "base64"] }
+          },
+          required: ["path"]
+        }
+      },
+      category: "platform",
+      handler: async (args) => {
+        const filePath = args.path;
+        const encoding = args.encoding || "utf-8";
+        if (!fs3.existsSync(filePath)) return { error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${filePath}` };
+        return fs3.readFileSync(filePath, encoding);
+      }
+    },
+    // ─── Utility ───
+    {
+      type: "function",
+      function: {
+        name: "\u5E73\u53F0.getCurrentTime",
+        description: "\u83B7\u53D6\u5F53\u524D\u65F6\u95F4\u4FE1\u606F\uFF0C\u8FD4\u56DE\u65F6\u95F4\u6233\u3001ISO\u683C\u5F0F\u65F6\u95F4\u548C\u53EF\u8BFB\u683C\u5F0F",
+        parameters: { type: "object", properties: {}, required: [] }
+      },
+      category: "platform",
+      handler: async () => {
+        const now = /* @__PURE__ */ new Date();
+        return {
+          timestamp: now.getTime(),
+          iso: now.toISOString(),
+          readable: now.toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" }),
+          timezone: "Asia/Shanghai"
+        };
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "\u5E73\u53F0.processText",
+        description: `\u5BF9\u6587\u672C\u8FDB\u884C\u57FA\u7840\u5904\u7406\uFF1A\u7EDF\u8BA1\u5B57\u6570\u3001\u63D0\u53D6\u5173\u952E\u8BCD\u3001\u622A\u65AD\u7B49\u3002
+\u64CD\u4F5C\u7C7B\u578B: count(\u7EDF\u8BA1)\u3001truncate(\u622A\u65AD)\u3001extract(\u63D0\u53D6\u5173\u952E\u8BCD)\u3002`,
+        parameters: {
+          type: "object",
+          properties: {
+            text: { type: "string", description: "\u8981\u5904\u7406\u7684\u6587\u672C" },
+            operation: { type: "string", description: "\u64CD\u4F5C\u7C7B\u578B", enum: ["count", "truncate", "extract"] },
+            maxLength: { type: "number", description: "\u622A\u65AD\u6700\u5927\u957F\u5EA6(\u4EC5truncate\u65F6\u4F7F\u7528)" }
+          },
+          required: ["text", "operation"]
+        }
+      },
+      category: "platform",
+      handler: async (args) => {
+        const text = args.text;
+        const op = args.operation;
+        if (op === "count") {
+          return { charCount: text.length, wordCount: text.replace(/\s/g, "").length };
+        }
+        if (op === "truncate") {
+          const maxLen = args.maxLength || 200;
+          return { truncated: text.length > maxLen, result: text.slice(0, maxLen) + (text.length > maxLen ? "..." : "") };
+        }
+        if (op === "extract") {
+          const phrases = /* @__PURE__ */ new Map();
+          for (let i = 0; i < text.length - 1; i++) {
+            const phrase = text.slice(i, i + 2);
+            if (/^[一-龥]{2}$/.test(phrase)) {
+              phrases.set(phrase, (phrases.get(phrase) || 0) + 1);
+            }
+          }
+          return Array.from(phrases.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([k, v]) => ({ phrase: k, count: v }));
+        }
+        return { error: `\u672A\u77E5\u64CD\u4F5C: ${op}` };
+      }
+    }
+  ];
+}
+
+// src/tools/mirror-tools.ts
+function createMirrorTools(mirrorStore) {
+  return [
+    {
+      type: "function",
+      function: {
+        name: "mirror.getProfile",
+        description: "\u83B7\u53D6\u6307\u5B9A\u5076\u50CF\u7684\u6570\u5B57\u955C\u50CF\u6863\u6848\uFF0C\u5305\u542B\u6027\u683C\u7279\u5F81\u3001\u8BF4\u8BDD\u98CE\u683C\u3001\u53E3\u5934\u7985\u3001\u60C5\u611F\u57FA\u8C03\u3001\u753B\u50CF\u63CF\u8FF0\u7B49",
+        parameters: {
+          type: "object",
+          properties: {
+            xoxId: { type: "number", description: "\u5076\u50CFID" }
+          },
+          required: ["xoxId"]
+        }
+      },
+      category: "mirror",
+      handler: async (args, ctx) => {
+        const xoxId = args.xoxId;
+        const profile = mirrorStore.getProfile(xoxId, ctx.userId);
+        if (!profile) return { error: `\u672A\u627E\u5230\u5076\u50CF ${xoxId} \u7684\u955C\u50CF\u6863\u6848\uFF0C\u8BF7\u5148\u751F\u6210\u955C\u50CF` };
+        return {
+          xoxNickname: profile.xoxNickname,
+          personalityTraits: profile.persona.personalityTraits,
+          speechPatterns: profile.persona.speechPatterns,
+          signaturePhrases: profile.persona.signaturePhrases,
+          emotionalTone: profile.persona.emotionalTone,
+          personaSummary: profile.persona.personaSummary,
+          maturityScore: profile.meta.maturityScore,
+          totalSamplesUsed: profile.meta.totalSamplesUsed
+        };
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "mirror.listProfiles",
+        description: "\u5217\u51FA\u6240\u6709\u5DF2\u751F\u6210\u7684\u6570\u5B57\u955C\u50CF\u5217\u8868",
+        parameters: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      category: "mirror",
+      handler: async (_args, ctx) => {
+        const profiles = mirrorStore.listProfiles(ctx.userId);
+        return profiles.map((p) => ({
+          xoxId: p.xoxId,
+          xoxNickname: p.xoxNickname,
+          maturityScore: p.meta.maturityScore,
+          totalSamplesUsed: p.meta.totalSamplesUsed,
+          lastUpdatedAt: p.meta.lastUpdatedAt
+        }));
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "mirror.getFewShotExamples",
+        description: "\u83B7\u53D6\u5076\u50CF\u7684 few-shot \u4EA4\u4E92\u793A\u4F8B\uFF0C\u7528\u4E8E\u6A21\u4EFF\u5176\u56DE\u590D\u98CE\u683C",
+        parameters: {
+          type: "object",
+          properties: {
+            xoxId: { type: "number", description: "\u5076\u50CFID" },
+            count: { type: "number", description: "\u8FD4\u56DE\u793A\u4F8B\u6570\u91CF\uFF0C\u9ED8\u8BA43" }
+          },
+          required: ["xoxId"]
+        }
+      },
+      category: "mirror",
+      handler: async (args, ctx) => {
+        const xoxId = args.xoxId;
+        const count = args.count || 3;
+        const profile = mirrorStore.getProfile(xoxId, ctx.userId);
+        if (!profile) return { error: `\u672A\u627E\u5230\u5076\u50CF ${xoxId} \u7684\u955C\u50CF\u6863\u6848` };
+        return profile.fewShotExamples.slice(0, count);
+      }
+    }
+  ];
+}
+
+// src/pocket/user.ts
+var user_exports = {};
+__export(user_exports, {
+  getUnreadMessageNum: () => getUnreadMessageNum,
+  loginWithCode: () => loginWithCode,
+  loginWithToken: () => loginWithToken,
+  normalizePocketUser: () => normalizePocketUser,
+  sendVerificationCode: () => sendVerificationCode
+});
+async function sendVerificationCode(client, phone) {
+  await client.requestBeforeLogin("/user/api/v2/sms/send_sms", {
+    mobile: phone,
+    area: "86",
+    businessCode: 1,
+    deviceToken: ""
+  });
+}
+async function loginWithCode(client, phone, code) {
+  const res = await client.requestBeforeLogin(
+    "/user/api/v2/login/app/app_login",
+    {
+      deviceToken: "",
+      loginType: "MOBILE_SMS_CODE",
+      mobileCodeLogin: {
+        area: "86",
+        mobile: phone,
+        code
+      }
+    }
+  );
+  if (res.success === false || res.status != null && res.status !== 200) {
+    throw new Error(res.message || "\u767B\u5F55\u5931\u8D25");
+  }
+  return res.content ?? {};
+}
+async function getUnreadMessageNum(client, token) {
+  return client.request(
+    "/message/api/v1/unread/message/num",
+    {},
+    token,
+    true
+  );
+}
+async function loginWithToken(client, token) {
+  const res = await client.request(
+    "/user/api/v1/user/info/reload",
+    { from: "appstart" },
+    token,
+    true
+  );
+  if (res.success === false) return null;
+  const content = res.data?.content ?? res.content;
+  if (!content || typeof content !== "object") return null;
+  return { ...content, ...content.userInfo };
+}
+function normalizePocketUser(raw, token, phone = "") {
+  const nested = raw.userInfo || raw;
+  return {
+    userId: Number(nested.userId ?? raw.userId ?? 0) || void 0,
+    nickname: String(nested.nickname ?? raw.nickname ?? ""),
+    name: String(nested.nickname ?? raw.nickname ?? raw.name ?? ""),
+    phone: String(phone || nested.mobile || raw.phone || ""),
+    avatar: String(nested.avatar ?? ""),
+    level: Number(nested.level ?? 0) || void 0,
+    money: Number(nested.money ?? 0) || void 0,
+    token: String(token),
+    lastLoginTime: Date.now()
+  };
+}
+
+// src/pocket/flip.ts
+var flip_exports = {};
+__export(flip_exports, {
+  getAllFlips: () => getAllFlips,
+  getDataSourcePage: () => getDataSourcePage,
+  getMemberFlipHistory: () => getMemberFlipHistory,
+  sendFlip: () => sendFlip,
+  syncFlips: () => syncFlips
+});
+function groupDataById(allUserData) {
+  const groupData = {};
+  allUserData.forEach((item) => {
+    const xoxId = item?.baseUserInfo?.userId;
+    if (!xoxId) return;
+    const cardInfo = {
+      answerId: item.answerId,
+      cost: item.cost,
+      answerType: item.answerType,
+      answerTime: item.answerTime,
+      qtime: item.qtime,
+      type: item.type
+    };
+    const key = String(xoxId);
+    if (key in groupData) {
+      groupData[key].cards.push(cardInfo);
+    } else {
+      groupData[key] = {
+        xoxId,
+        xoxNickname: item.baseUserInfo?.nickname ?? "",
+        cards: [cardInfo]
+      };
+    }
+  });
+  return groupData;
+}
+function recordKey(r) {
+  if (r?.questionId) return `q:${r.questionId}`;
+  if (r?.answerId) return `a:${r.answerId}`;
+  return `f:${r?.qtime ?? ""}|${r?.content ?? ""}`;
+}
+function calcDashboard(allUserData) {
+  const info = {
+    totalFlipCount: allUserData.length,
+    runningCount: 0,
+    returnedCount: 0,
+    costTotal: 0
+  };
+  allUserData.forEach((card) => {
+    if (card.status === 3) info.returnedCount += 1;
+    else if (card.status === 1) info.runningCount += 1;
+    else if (card.status === 2) info.costTotal += card.cost;
+  });
+  return info;
+}
+async function syncFlips(client, token, userId, flipDataSource, logger, mode = "incremental", onProgress) {
+  if (mode === "full") {
+    flipDataSource.clear(userId);
+  }
+  const cache = flipDataSource.get(userId);
+  const existingRecords = mode === "incremental" ? cache?.records ?? [] : [];
+  const existingIds = new Set(existingRecords.map((r) => recordKey(r)));
+  const existingIndex = new Map(existingRecords.map((r, i) => [recordKey(r), i]));
+  let newRecords = [];
+  let beginLimit = 0;
+  let responseSize = 20;
+  let stopT = 0;
+  const groupNum = 40;
+  while (responseSize > 0) {
+    const response = await client.request(
+      "/idolanswer/api/idolanswer/v1/user/question/list",
+      { status: 0, beginLimit, memberId: "", limit: 20 },
+      token,
+      true
+    );
+    let sleepTime = 10;
+    if (beginLimit - stopT * groupNum * responseSize > 100) {
+      sleepTime = 6e4;
+      stopT += 1;
+    }
+    if (response.status === 200) {
+      const userData = response.content ?? [];
+      if (mode === "incremental" && existingIds.size > 0) {
+        let hitExisting = false;
+        for (const item of userData) {
+          const key = recordKey(item);
+          if (existingIds.has(key)) {
+            const idx = existingIndex.get(key);
+            if (idx !== void 0) existingRecords[idx] = item;
+            hitExisting = true;
+            break;
+          }
+          newRecords.push(item);
+        }
+        if (hitExisting) {
+          responseSize = 0;
+        } else {
+          responseSize = userData.length;
+          beginLimit += userData.length;
+        }
+      } else {
+        newRecords = newRecords.concat(userData);
+        responseSize = userData.length;
+        beginLimit += userData.length;
+      }
+      onProgress?.(newRecords.length);
+      if (responseSize > 0) {
+        await new Promise((r) => setTimeout(r, sleepTime));
+      }
+    } else {
+      logger.warn(`\u83B7\u53D6\u7FFB\u724C\u6570\u636E\u5931\u8D25: ${response.message}`);
+      break;
+    }
+  }
+  const merged = mode === "full" ? newRecords : [...newRecords, ...existingRecords];
+  const seen = /* @__PURE__ */ new Set();
+  const allUserData = merged.filter((item) => {
+    const key = recordKey(item);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  if (!allUserData.length && !newRecords.length) {
+    return { allUserData: existingRecords, dashboardInfo: cache?.dashboardInfo ?? null };
+  }
+  const dashboardInfo = calcDashboard(allUserData);
+  const groupedData = groupDataById(allUserData);
+  const nextCache = {
+    userId,
+    records: allUserData,
+    groupedDataById: groupedData,
+    dashboardInfo,
+    meta: { syncedAt: Date.now(), recordCount: allUserData.length }
+  };
+  flipDataSource.set(nextCache);
+  logger.info(`syncFlips: ${newRecords.length} new, total ${allUserData.length}`);
+  return { allUserData, dashboardInfo };
+}
+async function getAllFlips(client, token, userId, flipDataSource, logger) {
+  return syncFlips(client, token, userId, flipDataSource, logger, "full");
+}
+async function getDataSourcePage(searchParams, flipDataSource, userId) {
+  const { xoxId, startTimeMs, endTimeMs, type, status, answerType, keyword } = searchParams;
+  const cache = flipDataSource.get(userId);
+  const allUserData = cache?.records ?? [];
+  const filtered = allUserData.filter((item) => {
+    if (xoxId != null && `${item?.baseUserInfo?.userId}` !== `${xoxId}`) return false;
+    if (startTimeMs && Number(item?.qtime || Infinity) < Number(startTimeMs)) return false;
+    if (endTimeMs && Number(item?.qtime || 0) > Number(endTimeMs)) return false;
+    if (type != null && `${item?.type}` !== `${type}`) return false;
+    if (status != null && `${item?.status}` !== `${status}`) return false;
+    if (answerType != null && `${item?.answerType}` !== `${answerType}`) return false;
+    if (keyword && !item?.answerContent?.includes(keyword) && !item?.content?.includes(keyword)) return false;
+    return true;
+  });
+  return { data: filtered, total: filtered.length };
+}
+async function sendFlip(client, params, token) {
+  const res = await client.request(
+    "/idolanswer/api/idolanswer/v1/user/question",
+    params,
+    token,
+    true
+  );
+  return !!res.content;
+}
+async function getMemberFlipHistory(client, token, memberId, beginLimit = 10, limit = 10) {
+  const res = await client.request(
+    "/idolanswer/api/idolanswer/v1/user/question/list",
+    { status: 0, memberId: String(memberId), beginLimit, limit },
+    token,
+    true
+  );
+  const content = res?.content;
+  let records = [];
+  if (Array.isArray(content)) {
+    records = content;
+  } else if (content && typeof content === "object") {
+    records = content.flipCompleteList ?? content.answerList ?? content.list ?? [];
+  }
+  return { records, hasMore: records.length >= limit };
+}
+
+// src/pocket/member.ts
+var member_exports = {};
+__export(member_exports, {
+  fetchMemberList: () => fetchMemberList,
+  getMemberFlipPriceInfo: () => getMemberFlipPriceInfo,
+  getMemberListByTab: () => getMemberListByTab,
+  getTeamListInfo: () => getTeamListInfo
+});
+async function getTeamListInfo(client, token) {
+  const res = await client.request(
+    "/im/api/v1/im/team/tab/list",
+    { groupId: 0, typeId: 0, ctime: 0, limit: 20 },
+    token,
+    true
+  );
+  return res.content;
+}
+async function getMemberListByTab(client, token, tabId) {
+  const res = await client.request(
+    "/im/api/v1/im/team/server/list",
+    { tabId },
+    token,
+    true
+  );
+  return res.content;
+}
+async function fetchMemberList(client, token) {
+  const teamData = await getTeamListInfo(client, token);
+  if (!teamData?.serverTabList) return [];
+  const list = [];
+  for (const tab of teamData.serverTabList) {
+    const serverData = await getMemberListByTab(client, token, tab.tabId);
+    if (!serverData?.serverApiList) continue;
+    for (const item of serverData.serverApiList) {
+      list.push({
+        teamName: tab.tabName,
+        teamId: Number(item.teamId),
+        serverIcon: String(item.serverDefaultIcon ?? ""),
+        serverId: Number(item.serverId),
+        serverName: String(item.serverName ?? ""),
+        memberId: Number(item.serverOwner),
+        memberName: String(item.serverDefaultName ?? "")
+      });
+    }
+  }
+  return list;
+}
+async function getMemberFlipPriceInfo(client, token, memberId) {
+  const res = await client.request(
+    "/idolanswer/api/idolanswer/v2/custom/index",
+    { memberId: Number(memberId) },
+    token,
+    true
+  );
+  return res.content;
+}
+
+// src/pocket/room.ts
+var room_exports = {};
+__export(room_exports, {
+  getRoomChannelByStar: () => getRoomChannelByStar,
+  getRoomInfo: () => getRoomInfo,
+  getRoomMessages: () => getRoomMessages
+});
+async function getRoomChannelByStar(client, token, starId) {
+  const res = await client.request("/im/api/v1/im/server/jump", { starId, tabId: 0, targetType: 1 }, token, true);
+  const c = res.content;
+  const channelId = c?.channelId ?? c?.channelInfo?.channelId ?? 0;
+  const serverId = c?.serverId ?? c?.channelInfo?.serverId;
+  return {
+    channelId: Number(channelId),
+    serverId: serverId != null ? Number(serverId) : void 0
+  };
+}
+async function getRoomInfo(client, token, channelId) {
+  const res = await client.request(
+    "/im/api/v1/im/team/room/info",
+    { channelId: String(channelId) },
+    token,
+    true
+  );
+  return res.content?.channelInfo ?? null;
+}
+function parseMessage(raw) {
+  let text;
+  let mediaUrl;
+  let mediaDuration;
+  let liveInfo;
+  let giftInfo;
+  let replyInfo;
+  if (raw.msgType === "TEXT") {
+    text = raw.bodys;
+  } else {
+    try {
+      const b = JSON.parse(raw.bodys);
+      if (raw.msgType === "IMAGE" || raw.msgType === "VOICE" || raw.msgType === "VIDEO") {
+        mediaUrl = b.url;
+        if (raw.msgType === "VOICE" && b.dur) mediaDuration = Number(b.dur);
+      } else if (raw.msgType === "LIVEPUSH") {
+        const live = b.livePushInfo ?? b;
+        liveInfo = {
+          liveId: live.liveId,
+          liveTitle: live.liveTitle,
+          liveCover: live.liveCover,
+          shortPath: live.shortPath
+        };
+      } else if (raw.msgType === "GIFT_TEXT") {
+        const g = b.giftInfo ?? b;
+        giftInfo = {
+          giftName: g.giftName,
+          giftNum: Number(g.giftNum ?? g.giftCount ?? 1),
+          giftPic: g.giftPic
+        };
+      } else if (raw.msgType === "REPLY") {
+        const r = b.replyInfo ?? b;
+        replyInfo = {
+          replyName: r.replyName,
+          replyText: r.replyText,
+          replyMessageId: r.replyMessageId
+        };
+        text = r.text ?? raw.bodys;
+      } else {
+        text = raw.bodys;
+      }
+    } catch {
+      text = raw.bodys;
+    }
+  }
+  let sender;
+  if (raw.extInfo) {
+    try {
+      const e = JSON.parse(raw.extInfo);
+      const u = e.user;
+      if (u) {
+        sender = {
+          userId: u.userId,
+          nickName: u.nickName || "",
+          avatar: u.avatar || "",
+          level: u.level
+        };
+      }
+    } catch {
+    }
+  }
+  return {
+    msgId: String(raw.msgIdServer || raw.msgIdClient || raw.msgId || raw.msgTime),
+    msgTime: raw.msgTime,
+    msgType: raw.msgType,
+    text,
+    mediaUrl,
+    mediaDuration,
+    liveInfo,
+    giftInfo,
+    replyInfo,
+    sender
+  };
+}
+async function getRoomMessages(client, token, serverId, channelId, nextTime) {
+  const res = await client.request(
+    "/im/api/v1/team/message/list/all",
+    { limit: 100, serverId, channelId, nextTime },
+    token,
+    true
+  );
+  const content = res?.content ?? {};
+  const rawList = content?.message ?? content?.messageList ?? content?.list ?? content?.messages ?? content?.data ?? (Array.isArray(content) ? content : []);
+  const next = content?.nextTime ?? 0;
+  const messages = rawList.filter((m) => m && m.msgTime).map(parseMessage).sort((a, b) => a.msgTime - b.msgTime);
+  return { messages, nextTime: Number(next) };
+}
+
+// src/tools/pocket-tools.ts
+function getToken(configStore) {
+  const stored = configStore.get("pocket_token");
+  if (stored) return stored;
+  return process.env.POCKET_TOKEN;
+}
+function createPocketTools(params) {
+  const { pocketClient, configStore, flipDataSource, logger } = params;
+  const userId = "mcp";
+  return [
+    {
+      type: "function",
+      function: {
+        name: "pocket.sendVerificationCode",
+        description: "\u53D1\u9001\u77ED\u4FE1\u9A8C\u8BC1\u7801\u5230\u6307\u5B9A\u624B\u673A\u53F7\uFF0C\u7528\u4E8E\u540E\u7EED\u9A8C\u8BC1\u7801\u767B\u5F55",
+        parameters: {
+          type: "object",
+          properties: {
+            phone: { type: "string", description: "\u624B\u673A\u53F7\u7801\uFF0811\u4F4D\uFF09" }
+          },
+          required: ["phone"]
+        }
+      },
+      category: "pocket",
+      handler: async (args) => {
+        const phone = args.phone;
+        if (!phone || !/^\d{11}$/.test(phone)) {
+          return { error: "\u8BF7\u8F93\u5165\u6B63\u786E\u768411\u4F4D\u624B\u673A\u53F7" };
+        }
+        try {
+          await sendVerificationCode(pocketClient, phone);
+          return { success: true, message: `\u9A8C\u8BC1\u7801\u5DF2\u53D1\u9001\u5230 ${phone}` };
+        } catch (e) {
+          return { error: `\u53D1\u9001\u5931\u8D25: ${String(e)}` };
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "pocket.loginWithCode",
+        description: "\u4F7F\u7528\u77ED\u4FE1\u9A8C\u8BC1\u7801\u767B\u5F55\uFF0C\u6210\u529F\u540E\u5C06 token \u6301\u4E45\u5316\u4FDD\u5B58\uFF0C\u540E\u7EED\u5DE5\u5177\u81EA\u52A8\u643A\u5E26",
+        parameters: {
+          type: "object",
+          properties: {
+            phone: { type: "string", description: "\u624B\u673A\u53F7\u7801\uFF0811\u4F4D\uFF09" },
+            code: { type: "string", description: "\u77ED\u4FE1\u9A8C\u8BC1\u7801" }
+          },
+          required: ["phone", "code"]
+        }
+      },
+      category: "pocket",
+      handler: async (args) => {
+        const phone = args.phone;
+        const code = args.code;
+        try {
+          const content = await loginWithCode(pocketClient, phone, code);
+          const token = content?.token;
+          if (!token) {
+            return { error: "\u767B\u5F55\u5931\u8D25\uFF1A\u54CD\u5E94\u4E2D\u672A\u5305\u542B token", raw: content };
+          }
+          configStore.set("pocket_token", token);
+          const userInfo = content?.userInfo;
+          logger.info(`[pocket-tools] loginWithCode success, userId=${userInfo?.userId ?? "?"}`);
+          return {
+            success: true,
+            userId: userInfo?.userId,
+            nickname: userInfo?.nickname,
+            message: "\u767B\u5F55\u6210\u529F\uFF0Ctoken \u5DF2\u4FDD\u5B58"
+          };
+        } catch (e) {
+          return { error: `\u767B\u5F55\u5931\u8D25: ${String(e)}` };
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "pocket.loginWithToken",
+        description: `\u4F7F\u7528\u5DF2\u6709 Token \u9A8C\u8BC1\u5E76\u767B\u5F55\u3002\u4E0D\u4F20 token \u53C2\u6570\u65F6\u81EA\u52A8\u5C1D\u8BD5\u73AF\u5883\u53D8\u91CF POCKET_TOKEN\u3002
+\u5982\u679C\u4F60\u5DF2\u6709 token\uFF08\u6BD4\u5982\u4ECE\u6D4F\u89C8\u5668\u6293\u53D6\uFF09\uFF0C\u76F4\u63A5\u7528\u6B64\u5DE5\u5177\u767B\u5F55\uFF0C\u65E0\u9700\u9A8C\u8BC1\u7801\u3002`,
+        parameters: {
+          type: "object",
+          properties: {
+            token: { type: "string", description: "Pocket48 \u767B\u5F55 Token\u3002\u4E0D\u4F20\u5219\u4ECE\u73AF\u5883\u53D8\u91CF POCKET_TOKEN \u8BFB\u53D6" }
+          },
+          required: []
+        }
+      },
+      category: "pocket",
+      handler: async (args) => {
+        const token = args.token || getToken(configStore);
+        if (!token) {
+          return { error: "\u672A\u63D0\u4F9B token\u3002\u8BF7\u4F20\u5165 token \u53C2\u6570\u6216\u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF POCKET_TOKEN" };
+        }
+        try {
+          const user = await loginWithToken(pocketClient, token);
+          if (!user) {
+            return { error: "Token \u65E0\u6548\u6216\u5DF2\u8FC7\u671F" };
+          }
+          configStore.set("pocket_token", token);
+          logger.info(`[pocket-tools] loginWithToken success, userId=${user.userId}`);
+          return {
+            success: true,
+            userId: user.userId,
+            nickname: user.nickname,
+            name: user.name,
+            phone: user.phone,
+            level: user.level,
+            money: user.money,
+            avatar: user.avatar,
+            message: "\u767B\u5F55\u6210\u529F\uFF0Ctoken \u5DF2\u4FDD\u5B58"
+          };
+        } catch (e) {
+          return { error: `Token \u9A8C\u8BC1\u5931\u8D25: ${String(e)}` };
+        }
+      }
+    },
+    // ── 用户类 ──
+    {
+      type: "function",
+      function: {
+        name: "pocket.getUserInfo",
+        description: "\u83B7\u53D6\u5F53\u524D\u767B\u5F55\u7528\u6237\u7684\u57FA\u672C\u4FE1\u606F\uFF1A\u6635\u79F0\u3001\u7B49\u7EA7\u3001\u4F59\u989D\u3001\u5934\u50CF\u3001\u624B\u673A\u53F7",
+        parameters: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      category: "pocket",
+      handler: async () => {
+        const token = getToken(configStore);
+        if (!token) return { error: "\u672A\u767B\u5F55\uFF0C\u8BF7\u5148\u8C03\u7528 pocket.loginWithCode \u6216 pocket.loginWithToken" };
+        try {
+          const user = await loginWithToken(pocketClient, token);
+          if (!user) return { error: "Token \u65E0\u6548\u6216\u5DF2\u8FC7\u671F" };
+          return {
+            userId: user.userId,
+            nickname: user.nickname,
+            name: user.name,
+            phone: user.phone,
+            level: user.level,
+            money: user.money,
+            avatar: user.avatar,
+            lastLoginTime: user.lastLoginTime
+          };
+        } catch (e) {
+          return { error: `\u83B7\u53D6\u7528\u6237\u4FE1\u606F\u5931\u8D25: ${String(e)}` };
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "pocket.getUnreadMessageNum",
+        description: "\u83B7\u53D6\u672A\u8BFB\u6D88\u606F\u6570\u91CF\uFF0C\u5305\u62EC\u901A\u77E5\u3001\u7528\u6237\u6D88\u606F\u3001@\u6211\u3001\u8BC4\u8BBA\u7B49",
+        parameters: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      category: "pocket",
+      handler: async () => {
+        const token = getToken(configStore);
+        if (!token) return { error: "\u672A\u767B\u5F55\uFF0C\u8BF7\u5148\u8C03\u7528 pocket.loginWithCode \u6216 pocket.loginWithToken" };
+        try {
+          const res = await getUnreadMessageNum(pocketClient, token);
+          return res.content ?? { notice: 0, user: 0, atme: 0, comment: 0 };
+        } catch (e) {
+          return { error: `\u83B7\u53D6\u672A\u8BFB\u6D88\u606F\u6570\u5931\u8D25: ${String(e)}` };
+        }
+      }
+    },
+    // ── 成员类 ──
+    {
+      type: "function",
+      function: {
+        name: "pocket.fetchMemberList",
+        description: `\u83B7\u53D6\u6240\u6709\u53EF\u8BBF\u95EE\u7684\u961F\u4F0D\u548C\u6210\u5458\u5217\u8868\u3002\u8FD4\u56DE\u6BCF\u4E2A\u6210\u5458\u7684 teamName(\u961F\u4F0D\u540D)\u3001memberId\u3001memberName(\u6210\u5458\u540D)\u3001serverId \u7B49\u3002
+\u53EF\u4EE5\u7528 teamName \u53C2\u6570\u8FC7\u6EE4\u7279\u5B9A\u961F\u4F0D\uFF08\u5982 "SNH48"\u3001"BEJ48"\u3001"GNZ48"\u3001"CKG48"\uFF09\u3002`,
+        parameters: {
+          type: "object",
+          properties: {
+            teamName: { type: "string", description: "\u961F\u4F0D\u540D\u79F0\u8FC7\u6EE4\uFF0C\u5982 SNH48\u3001BEJ48\u3001GNZ48\u3002\u4E0D\u4F20\u5219\u8FD4\u56DE\u5168\u90E8" }
+          },
+          required: []
+        }
+      },
+      category: "pocket",
+      handler: async (args) => {
+        const token = getToken(configStore);
+        if (!token) return { error: "\u672A\u767B\u5F55\uFF0C\u8BF7\u5148\u8C03\u7528 pocket.loginWithCode \u6216 pocket.loginWithToken" };
+        try {
+          const list = await fetchMemberList(pocketClient, token);
+          let result = list;
+          const teamName = args.teamName;
+          if (teamName) {
+            result = list.filter((m) => m.teamName.includes(teamName));
+          }
+          return {
+            total: result.length,
+            members: result.map((m) => ({
+              teamName: m.teamName,
+              teamId: m.teamId,
+              memberId: m.memberId,
+              memberName: m.memberName,
+              serverId: m.serverId,
+              serverName: m.serverName
+            }))
+          };
+        } catch (e) {
+          return { error: `\u83B7\u53D6\u6210\u5458\u5217\u8868\u5931\u8D25: ${String(e)}` };
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "pocket.searchMembers",
+        description: "\u6309\u6210\u5458\u540D\u79F0\u6A21\u7CCA\u641C\u7D22\u6210\u5458\u3002\u8F93\u5165\u90E8\u5206\u540D\u5B57\u5373\u53EF\u5339\u914D\uFF0C\u652F\u6301\u641C\u7D22\u6240\u6709\u961F\u4F0D",
+        parameters: {
+          type: "object",
+          properties: {
+            keyword: { type: "string", description: "\u6210\u5458\u540D\u79F0\u5173\u952E\u8BCD\uFF08\u652F\u6301\u90E8\u5206\u5339\u914D\uFF09" }
+          },
+          required: ["keyword"]
+        }
+      },
+      category: "pocket",
+      handler: async (args) => {
+        const token = getToken(configStore);
+        if (!token) return { error: "\u672A\u767B\u5F55\uFF0C\u8BF7\u5148\u8C03\u7528 pocket.loginWithCode \u6216 pocket.loginWithToken" };
+        const keyword = args.keyword.toLowerCase();
+        if (!keyword) return { error: "\u8BF7\u8F93\u5165\u641C\u7D22\u5173\u952E\u8BCD" };
+        try {
+          const list = await fetchMemberList(pocketClient, token);
+          const matched = list.filter((m) => m.memberName.toLowerCase().includes(keyword));
+          return {
+            total: matched.length,
+            keyword,
+            members: matched.map((m) => ({
+              teamName: m.teamName,
+              memberId: m.memberId,
+              memberName: m.memberName,
+              serverId: m.serverId,
+              serverName: m.serverName
+            }))
+          };
+        } catch (e) {
+          return { error: `\u641C\u7D22\u6210\u5458\u5931\u8D25: ${String(e)}` };
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "pocket.getMemberFlipPriceInfo",
+        description: "\u67E5\u8BE2\u6307\u5B9A\u6210\u5458\u7684\u7FFB\u724C\u4EF7\u683C\u4FE1\u606F\uFF0C\u5305\u62EC\u533F\u540D\u7FFB\u724C\u4EF7\u683C\u3001\u666E\u901A\u7FFB\u724C\u4EF7\u683C\u3001\u79C1\u5BC6\u7FFB\u724C\u4EF7\u683C\u7B49",
+        parameters: {
+          type: "object",
+          properties: {
+            memberId: { type: "number", description: "\u6210\u5458ID (memberId)" }
+          },
+          required: ["memberId"]
+        }
+      },
+      category: "pocket",
+      handler: async (args) => {
+        const token = getToken(configStore);
+        if (!token) return { error: "\u672A\u767B\u5F55\uFF0C\u8BF7\u5148\u8C03\u7528 pocket.loginWithCode \u6216 pocket.loginWithToken" };
+        try {
+          const info = await getMemberFlipPriceInfo(pocketClient, token, String(args.memberId));
+          return info;
+        } catch (e) {
+          return { error: `\u83B7\u53D6\u7FFB\u724C\u4EF7\u683C\u5931\u8D25: ${String(e)}` };
+        }
+      }
+    },
+    // ── 房间类 ──
+    {
+      type: "function",
+      function: {
+        name: "pocket.getRoomChannel",
+        description: "\u901A\u8FC7\u6210\u5458\u7684 starId\uFF08serverId\uFF09\u83B7\u53D6\u5176\u53E3\u888B\u623F\u95F4\u7684 channelId \u548C serverId\uFF0C\u7528\u4E8E\u540E\u7EED\u67E5\u623F\u95F4\u6D88\u606F",
+        parameters: {
+          type: "object",
+          properties: {
+            starId: { type: "number", description: "\u6210\u5458\u7684 serverId\uFF08\u53EF\u4ECE fetchMemberList \u83B7\u53D6\uFF09" }
+          },
+          required: ["starId"]
+        }
+      },
+      category: "pocket",
+      handler: async (args) => {
+        const token = getToken(configStore);
+        if (!token) return { error: "\u672A\u767B\u5F55\uFF0C\u8BF7\u5148\u8C03\u7528 pocket.loginWithCode \u6216 pocket.loginWithToken" };
+        try {
+          const result = await getRoomChannelByStar(pocketClient, token, args.starId);
+          return result;
+        } catch (e) {
+          return { error: `\u83B7\u53D6\u623F\u95F4\u9891\u9053\u5931\u8D25: ${String(e)}` };
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "pocket.getRoomInfo",
+        description: "\u83B7\u53D6\u623F\u95F4\u57FA\u672C\u4FE1\u606F\uFF1A\u623F\u95F4\u540D\u3001\u6210\u5458\u540D\u3001\u961F\u4F0DID\u3001\u623F\u95F4\u72B6\u6001\u7B49",
+        parameters: {
+          type: "object",
+          properties: {
+            channelId: { type: "number", description: "\u623F\u95F4 channelId\uFF08\u53EF\u4ECE getRoomChannel \u83B7\u53D6\uFF09" }
+          },
+          required: ["channelId"]
+        }
+      },
+      category: "pocket",
+      handler: async (args) => {
+        const token = getToken(configStore);
+        if (!token) return { error: "\u672A\u767B\u5F55\uFF0C\u8BF7\u5148\u8C03\u7528 pocket.loginWithCode \u6216 pocket.loginWithToken" };
+        try {
+          const info = await getRoomInfo(pocketClient, token, args.channelId);
+          if (!info) return { error: "\u672A\u627E\u5230\u8BE5\u623F\u95F4" };
+          return {
+            channelId: info.channelId,
+            channelName: info.channelName,
+            ownerId: info.ownerId,
+            ownerName: info.ownerName,
+            serverId: info.serverId,
+            teamId: info.teamId,
+            channelStatus: info.channelStatus,
+            channelPocketType: info.channelPocketType,
+            bgImg: info.bgImg,
+            hasMsgBoard: info.hasMsgBoard
+          };
+        } catch (e) {
+          return { error: `\u83B7\u53D6\u623F\u95F4\u4FE1\u606F\u5931\u8D25: ${String(e)}` };
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "pocket.getRoomMessages",
+        description: `\u5206\u9875\u83B7\u53D6\u623F\u95F4\u6D88\u606F\u8BB0\u5F55\u3002\u8FD4\u56DE\u6D88\u606F\u5217\u8868\uFF08\u6309\u65F6\u95F4\u6B63\u5E8F\uFF09\uFF0C\u6BCF\u6761\u6D88\u606F\u5305\u542B\u53D1\u9001\u8005\u3001\u5185\u5BB9\u3001\u7C7B\u578B\u7B49\u3002
+\u6D88\u606F\u7C7B\u578B\u5305\u62EC\uFF1ATEXT(\u6587\u672C)\u3001IMAGE(\u56FE\u7247)\u3001VOICE(\u8BED\u97F3)\u3001VIDEO(\u89C6\u9891)\u3001LIVEPUSH(\u76F4\u64AD)\u3001GIFT_TEXT(\u793C\u7269)\u3001REPLY(\u56DE\u590D)\u3002
+\u62C9\u5386\u53F2\u6D88\u606F\u65F6\uFF0C\u4F20\u5165\u4E0A\u6B21\u8FD4\u56DE\u7684 nextTime \u53C2\u6570\u7EE7\u7EED\u7FFB\u9875\uFF1BnextTime=0 \u65F6\u62C9\u6700\u65B0\u4E00\u9875\u3002`,
+        parameters: {
+          type: "object",
+          properties: {
+            channelId: { type: "number", description: "\u623F\u95F4 channelId" },
+            serverId: { type: "number", description: "\u623F\u95F4 serverId\uFF08\u53EF\u9009\uFF0C\u53EF\u4ECE getRoomChannel \u83B7\u53D6\uFF09" },
+            nextTime: { type: "number", description: "\u5206\u9875\u6E38\u6807\uFF1A0=\u6700\u65B0\u9875\uFF0C\u5176\u4ED6=\u4E0A\u6B21\u8FD4\u56DE\u7684 nextTime" }
+          },
+          required: ["channelId"]
+        }
+      },
+      category: "pocket",
+      handler: async (args) => {
+        const token = getToken(configStore);
+        if (!token) return { error: "\u672A\u767B\u5F55\uFF0C\u8BF7\u5148\u8C03\u7528 pocket.loginWithCode \u6216 pocket.loginWithToken" };
+        const channelId = args.channelId;
+        const serverId = args.serverId || 0;
+        const nextTime = args.nextTime ?? 0;
+        try {
+          const page = await getRoomMessages(pocketClient, token, serverId, channelId, nextTime);
+          return {
+            messageCount: page.messages.length,
+            nextTime: page.nextTime,
+            hasMore: page.nextTime > 0,
+            messages: page.messages.map((m) => ({
+              msgId: m.msgId,
+              msgTime: m.msgTime,
+              msgTimeReadable: new Date(m.msgTime).toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" }),
+              msgType: m.msgType,
+              text: m.text,
+              mediaUrl: m.mediaUrl,
+              mediaDuration: m.mediaDuration,
+              liveInfo: m.liveInfo,
+              giftInfo: m.giftInfo,
+              replyInfo: m.replyInfo,
+              sender: m.sender
+            }))
+          };
+        } catch (e) {
+          return { error: `\u83B7\u53D6\u623F\u95F4\u6D88\u606F\u5931\u8D25: ${String(e)}` };
+        }
+      }
+    },
+    // ── 翻牌类 ──
+    {
+      type: "function",
+      function: {
+        name: "pocket.syncFlips",
+        description: `\u4ECE Pocket48 \u670D\u52A1\u7AEF\u540C\u6B65\u7FFB\u724C\u6570\u636E\u5230\u672C\u5730\u7F13\u5B58\u3002
+\u589E\u91CF\u6A21\u5F0F\uFF08\u9ED8\u8BA4\uFF09\uFF1A\u53EA\u62C9\u53D6\u65B0\u8BB0\u5F55\uFF0C\u901F\u5EA6\u5FEB\u3002\u5168\u91CF\u6A21\u5F0F\uFF1A\u6E05\u7A7A\u672C\u5730\u91CD\u65B0\u62C9\u53D6\u6240\u6709\u8BB0\u5F55\u3002
+\u7FFB\u724C\u6570\u636E\u540C\u6B65\u540E\uFF0C\u53EF\u7528 pocket.searchFlips \u641C\u7D22\u548C\u5206\u6790\u3002`,
+        parameters: {
+          type: "object",
+          properties: {
+            mode: {
+              type: "string",
+              description: "\u540C\u6B65\u6A21\u5F0F\uFF1Aincremental(\u589E\u91CF\uFF0C\u9ED8\u8BA4) \u6216 full(\u5168\u91CF)",
+              enum: ["incremental", "full"]
+            }
+          },
+          required: []
+        }
+      },
+      category: "pocket",
+      handler: async (args) => {
+        const token = getToken(configStore);
+        if (!token) return { error: "\u672A\u767B\u5F55\uFF0C\u8BF7\u5148\u8C03\u7528 pocket.loginWithCode \u6216 pocket.loginWithToken" };
+        const mode = args.mode || "incremental";
+        try {
+          const result = await syncFlips(pocketClient, token, userId, flipDataSource, logger, mode);
+          return {
+            success: true,
+            mode,
+            totalRecords: result.allUserData.length,
+            syncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            dashboard: result.dashboardInfo
+          };
+        } catch (e) {
+          return { error: `\u540C\u6B65\u7FFB\u724C\u6570\u636E\u5931\u8D25: ${String(e)}` };
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "pocket.searchFlips",
+        description: `\u641C\u7D22\u672C\u5730\u5DF2\u540C\u6B65\u7684\u7FFB\u724C\u8BB0\u5F55\u3002\u652F\u6301\u591A\u79CD\u8FC7\u6EE4\u6761\u4EF6\u7EC4\u5408\uFF1A
+- \u6309\u5076\u50CFID\u3001\u5173\u952E\u8BCD\u3001\u65F6\u95F4\u8303\u56F4\u3001\u7FFB\u724C\u7C7B\u578B\u3001\u72B6\u6001\u3001\u56DE\u590D\u7C7B\u578B\u8FC7\u6EE4
+- \u652F\u6301\u5206\u9875
+\u6CE8\u610F\uFF1A\u9700\u8981\u5148\u901A\u8FC7 pocket.syncFlips \u540C\u6B65\u6570\u636E\u540E\u624D\u80FD\u641C\u7D22\u3002`,
+        parameters: {
+          type: "object",
+          properties: {
+            xoxId: { type: "number", description: "\u5076\u50CFID\uFF08memberId\uFF09" },
+            keyword: { type: "string", description: "\u5728\u63D0\u95EE\u548C\u56DE\u590D\u5185\u5BB9\u4E2D\u641C\u7D22\u7684\u5173\u952E\u8BCD" },
+            type: { type: "number", description: "\u7FFB\u724C\u7C7B\u578B\uFF1A1=\u6587\u5B57, 2=\u8BED\u97F3(\u5DF2\u5E9F\u5F03), 4=\u89C6\u9891" },
+            status: { type: "number", description: "\u72B6\u6001\uFF1A1=\u8FDB\u884C\u4E2D, 2=\u5DF2\u56DE\u7B54, 3=\u5DF2\u9000\u56DE" },
+            answerType: { type: "number", description: "\u56DE\u590D\u7C7B\u578B\uFF1A1=\u6587\u5B57, 2=\u8BED\u97F3, 3=\u89C6\u9891" },
+            startTimeMs: { type: "number", description: "\u5F00\u59CB\u65F6\u95F4\u6233(\u6BEB\u79D2)" },
+            endTimeMs: { type: "number", description: "\u7ED3\u675F\u65F6\u95F4\u6233(\u6BEB\u79D2)" },
+            pageSize: { type: "number", description: "\u6BCF\u9875\u6570\u91CF\uFF0C\u9ED8\u8BA420\uFF0C\u6700\u592750" },
+            pageNum: { type: "number", description: "\u9875\u7801\uFF0C\u9ED8\u8BA41" }
+          },
+          required: []
+        }
+      },
+      category: "pocket",
+      handler: async (args) => {
+        const { xoxId, keyword, type, status, answerType, startTimeMs, endTimeMs } = args;
+        const pageSize = Math.min(args.pageSize || 20, 50);
+        const pageNum = args.pageNum || 1;
+        const { data, total } = await getDataSourcePage(
+          {
+            xoxId,
+            keyword,
+            type,
+            status,
+            answerType,
+            startTimeMs,
+            endTimeMs
+          },
+          flipDataSource,
+          userId
+        );
+        const start = (pageNum - 1) * pageSize;
+        const page = data.slice(start, start + pageSize);
+        return {
+          total,
+          pageNum,
+          pageSize,
+          records: page.map((r) => ({
+            questionId: r.questionId,
+            answerId: r.answerId,
+            content: r.content,
+            answerContent: r.answerContent,
+            qtime: r.qtime,
+            qtimeReadable: new Date(Number(r.qtime)).toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" }),
+            answerTime: r.answerTime,
+            cost: r.cost,
+            type: r.type,
+            answerType: r.answerType,
+            status: r.status,
+            xoxId: r.baseUserInfo?.userId,
+            xoxNickname: r.baseUserInfo?.nickname
+          }))
+        };
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "pocket.sendFlip",
+        description: `\u7ED9\u6307\u5B9A\u6210\u5458\u53D1\u7FFB\u724C\u3002\u7FFB\u724C\u662F\u4ED8\u8D39\u95EE\u7B54\uFF0C\u53D1\u9001\u540E\u7B49\u5F85\u5076\u50CF\u56DE\u590D\u3002
+\u5FC5\u586B\u53C2\u6570\uFF1AmemberId\uFF08\u6210\u5458ID\uFF09\u3001content\uFF08\u63D0\u95EE\u5185\u5BB9\uFF0C\u6700\u591A500\u5B57\uFF09\u3001answerType\uFF081=\u6587\u5B57\u56DE\u590D, 3=\u89C6\u9891\u56DE\u590D\uFF09\u3002
+type \u548C cost \u4F1A\u81EA\u52A8\u6839\u636E answerType \u8BBE\u9ED8\u8BA4\u503C\uFF0C\u4E5F\u53EF\u624B\u52A8\u6307\u5B9A\u3002
+\u53D1\u9001\u6210\u529F\u540E\u8FD4\u56DE\u662F\u5426\u6210\u529F\u3002`,
+        parameters: {
+          type: "object",
+          properties: {
+            memberId: { type: "number", description: "\u6210\u5458ID (memberId)" },
+            content: { type: "string", description: "\u7FFB\u724C\u63D0\u95EE\u5185\u5BB9\uFF08\u6700\u591A500\u5B57\uFF09" },
+            answerType: { type: "number", description: "\u671F\u671B\u56DE\u590D\u7C7B\u578B\uFF1A1=\u6587\u5B57\u56DE\u590D, 3=\u89C6\u9891\u56DE\u590D" },
+            type: { type: "number", description: "\u7FFB\u724C\u7C7B\u578B\uFF1A1=\u6587\u5B57\u3002\u4E0D\u4F20\u5219\u81EA\u52A8 =1" },
+            cost: { type: "number", description: "\u7FFB\u724C\u8D39\u7528\uFF08\u9E21\u817F\u6570\uFF09\u3002\u4E0D\u4F20\u5219\u81EA\u52A8\u7528\u9ED8\u8BA4\u503C" }
+          },
+          required: ["memberId", "content", "answerType"]
+        }
+      },
+      category: "pocket",
+      handler: async (args) => {
+        const token = getToken(configStore);
+        if (!token) return { error: "\u672A\u767B\u5F55\uFF0C\u8BF7\u5148\u8C03\u7528 pocket.loginWithCode \u6216 pocket.loginWithToken" };
+        const content = args.content;
+        if (!content || content.length === 0) return { error: "\u63D0\u95EE\u5185\u5BB9\u4E0D\u80FD\u4E3A\u7A7A" };
+        if (content.length > 500) return { error: `\u5185\u5BB9\u8D85\u8FC7500\u5B57\u9650\u5236\uFF08\u5F53\u524D${content.length}\u5B57\uFF09` };
+        const params2 = {
+          memberId: String(args.memberId),
+          content,
+          answerType: args.answerType,
+          type: args.type || 1,
+          cost: String(args.cost ?? "")
+        };
+        try {
+          const ok = await sendFlip(pocketClient, params2, token);
+          logger.info(`[pocket-tools] sendFlip to memberId=${params2.memberId}, result=${ok}`);
+          return {
+            success: ok,
+            memberId: params2.memberId,
+            content: params2.content,
+            answerType: params2.answerType,
+            message: ok ? "\u7FFB\u724C\u53D1\u9001\u6210\u529F\uFF0C\u7B49\u5F85\u5076\u50CF\u56DE\u590D" : "\u7FFB\u724C\u53D1\u9001\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u4F59\u989D\u6216\u91CD\u8BD5"
+          };
+        } catch (e) {
+          return { error: `\u53D1\u9001\u7FFB\u724C\u5931\u8D25: ${String(e)}` };
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "pocket.getMemberFlipHistory",
+        description: "\u67E5\u8BE2\u4E0E\u6307\u5B9A\u6210\u5458\u7684\u7FFB\u724C\u5BF9\u8BDD\u5386\u53F2\u3002\u8FD4\u56DE\u63D0\u95EE\u548C\u56DE\u590D\u7684\u5B8C\u6574\u8BB0\u5F55\uFF0C\u6309\u65F6\u95F4\u6392\u5217",
+        parameters: {
+          type: "object",
+          properties: {
+            memberId: { type: "number", description: "\u6210\u5458ID (memberId)" },
+            beginLimit: { type: "number", description: "\u8D77\u59CB\u4F4D\u7F6E\uFF0C\u9ED8\u8BA410\uFF08\u9996\u6B21\u67E5\u5EFA\u8BAE\u4E0D\u4F20\uFF09" },
+            limit: { type: "number", description: "\u6BCF\u9875\u6761\u6570\uFF0C\u9ED8\u8BA410" }
+          },
+          required: ["memberId"]
+        }
+      },
+      category: "pocket",
+      handler: async (args) => {
+        const token = getToken(configStore);
+        if (!token) return { error: "\u672A\u767B\u5F55\uFF0C\u8BF7\u5148\u8C03\u7528 pocket.loginWithCode \u6216 pocket.loginWithToken" };
+        try {
+          const page = await getMemberFlipHistory(
+            pocketClient,
+            token,
+            args.memberId,
+            args.beginLimit ?? 10,
+            args.limit ?? 10
+          );
+          return {
+            total: page.records.length,
+            hasMore: page.hasMore,
+            records: page.records.map((r) => ({
+              questionId: r.questionId,
+              answerId: r.answerId,
+              content: r.content,
+              answerContent: r.answerContent,
+              qtime: r.qtime,
+              qtimeReadable: new Date(Number(r.qtime)).toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" }),
+              answerTime: r.answerTime,
+              cost: r.cost,
+              type: r.type,
+              answerType: r.answerType,
+              status: r.status
+            }))
+          };
+        } catch (e) {
+          return { error: `\u83B7\u53D6\u7FFB\u724C\u5386\u53F2\u5931\u8D25: ${String(e)}` };
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: "pocket.getDashboard",
+        description: "\u83B7\u53D6\u7FFB\u724C\u6570\u636E\u7EDF\u8BA1\u4EEA\u8868\u76D8\uFF1A\u603B\u7FFB\u724C\u6570\u3001\u8FDB\u884C\u4E2D\u6570\u91CF\u3001\u5DF2\u9000\u56DE\u6570\u91CF\u3001\u603B\u82B1\u8D39",
+        parameters: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      category: "pocket",
+      handler: async () => {
+        const cache = flipDataSource.get(userId);
+        return cache?.dashboardInfo || { totalFlipCount: 0, runningCount: 0, returnedCount: 0, costTotal: 0 };
+      }
+    }
+  ];
+}
+
+// src/pocket/im.ts
+var im_exports = {};
+__export(im_exports, {
+  getImUserInfo: () => getImUserInfo
+});
+async function getImUserInfo(client, token) {
+  const res = await client.request("/im/api/v1/im/userinfo", {}, token, true);
+  const c = res.content ?? res.data?.content;
+  if (!c?.accid || !c?.pwd) return null;
+  return { accid: c.accid, pwd: c.pwd, userId: Number(c.userId ?? 0) };
+}
+
+// src/llm/agent-loop.ts
+async function agentLoop(options) {
+  const maxIterations = options.maxIterations || 10;
+  const messages = [
+    { role: "system", content: options.systemPrompt },
+    ...options.history || [],
+    { role: "user", content: options.userMessage }
+  ];
+  const tools = options.toolRegistry.getOpenAIFormat();
+  for (let i = 0; i < maxIterations; i++) {
+    const resp = await options.llmClient.chatCompletion(
+      options.config,
+      messages,
+      tools.length > 0 ? tools : void 0,
+      { model: options.model }
+    );
+    if (!resp.toolCalls || resp.toolCalls.length === 0) {
+      return resp.content;
+    }
+    messages.push({
+      role: "assistant",
+      content: resp.content || "",
+      tool_calls: resp.toolCalls
+    });
+    for (const tc of resp.toolCalls) {
+      const toolName = tc.function.name;
+      let toolArgs = {};
+      try {
+        toolArgs = JSON.parse(tc.function.arguments);
+      } catch {
+      }
+      options.onToolCall?.(toolName, toolArgs);
+      try {
+        const result = await options.toolRegistry.execute(toolName, toolArgs, options.context);
+        messages.push({
+          role: "tool",
+          content: JSON.stringify(result),
+          tool_call_id: tc.id
+        });
+      } catch (err) {
+        messages.push({
+          role: "tool",
+          content: JSON.stringify({ error: err instanceof Error ? err.message : String(err) }),
+          tool_call_id: tc.id
+        });
+      }
+    }
+  }
+  throw new Error("Agent exceeded max iterations");
+}
+async function agentLoopStream(options) {
+  const maxIterations = options.maxIterations || 10;
+  const messages = [
+    { role: "system", content: options.systemPrompt },
+    ...options.history || [],
+    { role: "user", content: options.userMessage }
+  ];
+  const tools = options.toolRegistry.getOpenAIFormat();
+  for (let i = 0; i < maxIterations; i++) {
+    const toolCalls = await options.llmClient.chatCompletionStream(
+      options.config,
+      messages,
+      (chunk) => {
+        if (chunk.content) options.onChunk?.(chunk.content);
+      },
+      tools.length > 0 ? tools : void 0,
+      { model: options.model }
+    );
+    if (!toolCalls || toolCalls.length === 0) return;
+    messages.push({
+      role: "assistant",
+      content: "",
+      tool_calls: toolCalls
+    });
+    for (const tc of toolCalls) {
+      const toolName = tc.function.name;
+      let toolArgs = {};
+      try {
+        toolArgs = JSON.parse(tc.function.arguments);
+      } catch {
+      }
+      options.onToolCall?.(toolName, toolArgs);
+      try {
+        const result = await options.toolRegistry.execute(toolName, toolArgs, options.context);
+        messages.push({
+          role: "tool",
+          content: JSON.stringify(result),
+          tool_call_id: tc.id
+        });
+      } catch (err) {
+        messages.push({
+          role: "tool",
+          content: JSON.stringify({ error: err instanceof Error ? err.message : String(err) }),
+          tool_call_id: tc.id
+        });
+      }
+    }
+  }
+  throw new Error("Agent exceeded max iterations");
+}
+
+// src/context.ts
+function createPocketCore(deps) {
+  const toolRegistry = new ToolRegistry(deps.logger);
+  const pocketClient = new PocketClient(
+    "https://pocketapi.48.cn",
+    POCKET_APP_INFO,
+    POCKET_PA,
+    deps.authExpiredHandler
+  );
+  const mirrorStore = new MirrorStore(deps.storage, deps.logger);
+  const flipCacheService = new FlipCacheService(deps.storage, deps.logger, deps.configStore);
+  const groupChatStore = new GroupChatStore(deps.storage, deps.logger);
+  const mirrorIndex = new MirrorIndex(deps.storage, deps.logger, deps.llmClient);
+  const mirrorMemory = new MirrorMemory(deps.storage, deps.logger, deps.llmClient);
+  return {
+    deps,
+    toolRegistry,
+    pocketClient,
+    mirrorStore,
+    flipCacheService,
+    groupChatStore,
+    mirrorIndex,
+    mirrorMemory,
+    buildMirror,
+    mirrorChat: chat,
+    mirrorSaveAssistantMessage: saveAssistantMessage,
+    mirrorClearChatMemory: clearChatMemory,
+    mirrorTriggerGrowth: triggerGrowth,
+    mirrorShouldTriggerGrowth: shouldTriggerGrowth,
+    mirrorRollbackPersona: rollbackPersona,
+    mirrorClearMemory: clearMirrorMemory,
+    getMirrorConfig,
+    createPlatformTools: () => createPlatformTools(deps.flipDataSource),
+    createMirrorTools: () => createMirrorTools(mirrorStore),
+    createPocketTools: () => createPocketTools({
+      pocketClient,
+      configStore: deps.configStore,
+      flipDataSource: deps.flipDataSource,
+      logger: deps.logger
+    }),
+    pocketUser: user_exports,
+    pocketFlip: flip_exports,
+    pocketIm: im_exports,
+    pocketMember: member_exports,
+    pocketRoom: room_exports,
+    agentLoop,
+    agentLoopStream
+  };
+}
+
+// src/llm/llm-constants.ts
+var PRESET_PROVIDERS = {
+  siliconflow: { label: "\u7845\u57FA\u6D41\u52A8 (SiliconFlow)", baseUrl: "https://api.siliconflow.cn/v1" },
+  deepseek: { label: "DeepSeek", baseUrl: "https://api.deepseek.com/v1" },
+  dashscope: { label: "\u963F\u91CC\u767E\u70BC (DashScope)", baseUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1" },
+  custom: { label: "\u81EA\u5B9A\u4E49", baseUrl: "" }
+};
+var PRESET_MODELS = {
+  chat: [
+    { id: "Qwen/Qwen3.6-35B-A3B", label: "Qwen3.6-35B", desc: "262K \u4E0A\u4E0B\u6587\uFF0C\u9AD8\u6027\u4EF7\u6BD4\u65E5\u5E38\u5BF9\u8BDD" },
+    { id: "deepseek-ai/DeepSeek-V4-Flash", label: "DeepSeek-V4-Flash", desc: "1M \u4E0A\u4E0B\u6587\uFF0C\u6781\u901F\u54CD\u5E94" },
+    { id: "stepfun-ai/Step-3.5-Flash", label: "Step-3.5-Flash", desc: "262K \u4E0A\u4E0B\u6587\uFF0C\u6781\u81F4\u4F4E\u4EF7" },
+    { id: "Qwen/Qwen3-8B", label: "Qwen3-8B", desc: "\u8F7B\u91CF\u5FEB\u901F\uFF0C\u6781\u4F4E\u6210\u672C" }
+  ],
+  reasoning: [
+    { id: "deepseek-ai/DeepSeek-V4-Pro", label: "DeepSeek-V4-Pro", desc: "1M \u4E0A\u4E0B\u6587\uFF0C\u9876\u7EA7\u63A8\u7406\xB7\u751F\u6210\u955C\u50CF\u4E13\u7528" },
+    { id: "Qwen/Qwen3-235B-A22B-Thinking-2507", label: "Qwen3-235B-Thinking", desc: "262K \u4E0A\u4E0B\u6587\uFF0C\u4E2D\u6587\u63A8\u7406" }
+  ],
+  embedding: [
+    { id: "BAAI/bge-large-zh-v1.5", label: "BGE-Large-zh", desc: "\u4E2D\u6587 embedding \u6027\u4EF7\u6BD4\u4E4B\u738B" }
+  ]
+};
+function defaultModelConfig() {
+  return {
+    baseUrl: PRESET_PROVIDERS.siliconflow.baseUrl,
+    apiKey: "",
+    chatModel: PRESET_MODELS.chat[0].id,
+    reasoningModel: PRESET_MODELS.reasoning[0].id,
+    embeddingModel: PRESET_MODELS.embedding[0].id,
+    lightweightModel: PRESET_MODELS.chat[3].id,
+    mirrorMode: "economy"
+  };
+}
+
+// src/mirror/group-chat/prompt.ts
+function buildInnerMonologuePrompt(profile, lastMessages, topic) {
+  const msgs = lastMessages.map((m) => `${m.speakerName}: ${m.content}`).join("\n");
+  return `\u4F60\u662F${profile.xoxNickname}\u3002\u73B0\u5728\u4F60\u5728\u4E00\u4E2A\u7FA4\u804A\u4E2D\uFF0C\u8BF7\u5224\u65AD\u4F60\u662F\u5426\u60F3\u53D1\u8A00\u3002
+
+\u3010\u4F60\u7684\u6027\u683C\u3011${profile.persona.personaSummary || "\u672A\u5B9A\u4E49"}
+\u3010\u7FA4\u804A\u8BDD\u9898\u3011${topic || "\u81EA\u7531\u95F2\u804A"}
+\u3010\u6700\u8FD1\u7FA4\u6D88\u606F\u3011
+${msgs}
+
+\u8BF7\u53EA\u8F93\u51FA\u4EE5\u4E0B JSON\uFF0C\u4E0D\u8981\u4EFB\u4F55\u5176\u4ED6\u5185\u5BB9\uFF1A
+{"shouldSpeak": true\u6216false, "urgency": 1\u523010\u7684\u6574\u6570, "trigger": "\u4E00\u53E5\u8BDD\u8BF4\u660E\u4F60\u4E3A\u4EC0\u4E48\u60F3/\u4E0D\u60F3\u8BF4\u8BDD"}`;
+}
+function buildSpeakPrompt(profile, params) {
+  const p = profile.persona;
+  const msgs = params.lastMessages.map((m) => `${m.speakerName}: ${m.content}`).join("\n");
+  return `\u4F60\u662F${profile.xoxNickname}\uFF0C\u4E00\u4F4D\u5076\u50CF\u3002
+
+\u3010\u6027\u683C\u7279\u5F81\u3011${p.personalityTraits.join("\u3001")}
+\u3010\u8BF4\u8BDD\u98CE\u683C\u3011${p.speechPatterns.join("\u3001")}
+\u3010\u53E3\u5934\u7985\u3011${p.signaturePhrases.join("\u3001")}
+\u3010\u60C5\u611F\u57FA\u8C03\u3011${p.emotionalTone}
+\u3010\u753B\u50CF\u63CF\u8FF0\u3011${p.personaSummary}
+
+\u3010\u5F53\u524D\u7FA4\u804A\u3011
+\u7FA4\u540D\u79F0\uFF1A${params.name}
+\u7FA4\u8BDD\u9898\uFF1A${params.topic || "\u81EA\u7531\u95F2\u804A"}
+\u5728\u573A\u6210\u5458\uFF1A${params.otherMembers}
+
+\u3010\u6700\u8FD1\u6D88\u606F\u3011
+${msgs}
+
+\u3010\u8981\u6C42\u3011
+- \u7528\u4F60\u81EA\u5DF1\u7684\u8BF4\u8BDD\u98CE\u683C\u56DE\u590D\uFF0C\u4FDD\u6301\u5728\u4EBA\u8BBE\u5185
+- \u53EF\u4EE5\u56DE\u5E94\u67D0\u4E2A\u4EBA\u8BF4\u7684\u8BDD\uFF08\u76F4\u63A5\u56DE\u5E94\uFF09\uFF0C\u4E5F\u53EF\u4EE5\u5F00\u65B0\u8BDD\u9898\uFF0C\u4E5F\u53EF\u4EE5\u5410\u69FD\u522B\u4EBA\u8BF4\u7684\u8BDD\uFF08\u4E0D\u8981\u6BCF\u6B21\u90FD\u56DE\u5E94\u6700\u540E\u4E00\u4E2A\u8BF4\u8BDD\u7684\u4EBA\uFF09
+- \u56DE\u590D\u957F\u5EA6\uFF1A1-3 \u53E5\u8BDD\uFF0C\u50CF\u7FA4\u804A\u91CC\u6253\u5B57\u7684\u611F\u89C9\uFF0C\u4E0D\u8981\u592A\u6B63\u5F0F\u6216\u592A\u957F\uFF0C\u4E5F\u4E0D\u8981\u6BCF\u53E5\u8BDD\u90FD\u5F88\u5B98\u65B9\u3002\u5982\u679C\u8BDD\u9898\u6709\u8DA3\u6216\u8005\u6709\u4EBA\u8BA9\u4F60\u4E0D\u6EE1\uFF0C\u4E5F\u53EF\u4EE5\u591A\u8BF4\u51E0\u53E5\u3002
+- \u4E0D\u8981\u63D0"\u8BBE\u5B9A""\u4EBA\u683C""AI""\u955C\u50CF"\u7B49\u8BCD\uFF0C\u4F60\u5C31\u662F${profile.xoxNickname}\u672C\u4EBA\u3002
+- \u4E0D\u8981\u6BCF\u6761\u6D88\u606F\u90FD\u4EE5\u95EE\u53F7\u7ED3\u5C3E\uFF0C\u4E5F\u4E0D\u8981\u6BCF\u6761\u6D88\u606F\u90FD\u5728\u95EE\u522B\u4EBA\u3002
+- \u7528\u4E2D\u6587\u56DE\u590D\u3002`;
+}
+
+// src/mirror/group-chat/engine.ts
+var EVAL_TIMEOUT_MS = 12e4;
+var MAX_RECENT_MESSAGES = 8;
+var ANTI_SILENCE_BOOST = 3;
+function parseSpeakDecision(raw) {
+  try {
+    const obj = JSON.parse(raw);
+    return {
+      shouldSpeak: obj.shouldSpeak !== false,
+      urgency: Math.max(1, Math.min(10, Number(obj.urgency) || 5)),
+      trigger: String(obj.trigger || "")
+    };
+  } catch {
+    const shouldSpeak = /shouldSpeak[":\s]*true/i.test(raw);
+    const urgencyMatch = raw.match(/urgency[":\s]*(\d+)/i);
+    return {
+      shouldSpeak,
+      urgency: urgencyMatch ? Math.min(10, Number(urgencyMatch[1])) : 5,
+      trigger: "\u65E0\u6CD5\u89E3\u6790"
+    };
+  }
+}
+async function evaluateMirrors(deps, session, lastMessages, userId) {
+  const decisions = [];
+  const evaluations = session.members.map(async (member) => {
+    const profile = deps.mirrorStore.getProfile(member.xoxId, userId);
+    if (!profile) {
+      return { xoxId: member.xoxId, shouldSpeak: false, urgency: 0, trigger: "\u65E0\u955C\u50CF" };
+    }
+    try {
+      const prompt = buildInnerMonologuePrompt(profile, lastMessages, session.topic);
+      const resp = await Promise.race([
+        deps.llmClient.chatCompletion(
+          deps.config,
+          [{ role: "user", content: prompt }],
+          void 0,
+          { model: deps.config.lightweightModel, maxTokens: 200, temperature: 0.3, timeoutMs: EVAL_TIMEOUT_MS }
+        ),
+        new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), EVAL_TIMEOUT_MS))
+      ]);
+      const parsed = parseSpeakDecision(resp.content);
+      return { xoxId: member.xoxId, ...parsed };
+    } catch (e) {
+      deps.logger.warn(`[groupChatEngine] evaluation failed for ${member.nickname}:`, e);
+      return { xoxId: member.xoxId, shouldSpeak: false, urgency: 0, trigger: "\u8BC4\u4F30\u8D85\u65F6/\u5931\u8D25" };
+    }
+  });
+  const results = await Promise.allSettled(evaluations);
+  for (const result of results) {
+    if (result.status === "fulfilled") {
+      decisions.push(result.value);
+    }
+  }
+  return decisions;
+}
+function selectSpeakers(decisions, session) {
+  const willing = decisions.filter((d) => d.shouldSpeak && d.urgency > 0);
+  if (willing.length === 0) {
+    const recentSpeakerIds = new Set(
+      session.messages.slice(-5).filter((m) => m.speakerId > 0).map((m) => m.speakerId)
+    );
+    const silentCandidate = decisions.find((d) => !recentSpeakerIds.has(d.xoxId));
+    const candidate = silentCandidate || decisions[0];
+    if (candidate) {
+      return [{ ...candidate, shouldSpeak: true, urgency: ANTI_SILENCE_BOOST, trigger: "\u6253\u7834\u6C89\u9ED8" }];
+    }
+    return [];
+  }
+  willing.sort((a, b) => b.urgency - a.urgency);
+  return willing.slice(0, 2);
+}
+async function generateSpeech(deps, profile, session, lastMessages, msgId, onChunk) {
+  const otherMembers = session.members.filter((m) => m.xoxId !== profile.xoxId).map((m) => m.nickname).join("\u3001");
+  const prompt = buildSpeakPrompt(profile, {
+    name: session.name,
+    topic: session.topic,
+    otherMembers,
+    lastMessages: lastMessages.map((m) => ({ speakerName: m.speakerName, content: m.content }))
+  });
+  let fullContent = "";
+  await deps.llmClient.chatCompletionStream(
+    deps.config,
+    [{ role: "user", content: prompt }],
+    (chunk) => {
+      if (chunk.content) {
+        fullContent += chunk.content;
+        onChunk({
+          sessionId: session.sessionId,
+          msgId,
+          speakerId: profile.xoxId,
+          speakerName: profile.xoxNickname,
+          content: chunk.content,
+          isDone: false,
+          roundDone: false
+        });
+      }
+    },
+    void 0,
+    { model: deps.config.chatModel, temperature: deps.config.chatTemperature }
+  );
+  return fullContent;
+}
+async function runRound(deps, session, userId, onEvent) {
+  const lastMessages = session.messages.slice(-MAX_RECENT_MESSAGES);
+  deps.logger.info(`[groupChatEngine] evaluating ${session.members.length} mirrors...`);
+  const decisions = await evaluateMirrors(deps, session, lastMessages, userId);
+  deps.logger.info(`[groupChatEngine] decisions: ${decisions.map((d) => `${d.xoxId}:${d.shouldSpeak ? d.urgency : "N"}`).join(", ")}`);
+  const speakers = selectSpeakers(decisions, session);
+  deps.logger.info(`[groupChatEngine] speakers: ${speakers.map((s) => s.xoxId).join(", ")}`);
+  if (speakers.length === 0) {
+    return [];
+  }
+  const newMessages = [];
+  for (const speaker of speakers) {
+    const member = session.members.find((m) => m.xoxId === speaker.xoxId);
+    if (!member) continue;
+    const profile = deps.mirrorStore.getProfile(speaker.xoxId, userId);
+    if (!profile) continue;
+    const msgId = `${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    deps.logger.info(`[groupChatEngine] generating speech for ${member.nickname} (trigger: ${speaker.trigger})`);
+    try {
+      const content = await generateSpeech(deps, profile, session, lastMessages, msgId, onEvent);
+      const msg = {
+        msgId,
+        speakerId: speaker.xoxId,
+        speakerName: member.nickname,
+        content,
+        timestamp: Date.now()
+      };
+      newMessages.push(msg);
+      onEvent({
+        sessionId: session.sessionId,
+        msgId,
+        speakerId: speaker.xoxId,
+        speakerName: member.nickname,
+        content: "",
+        isDone: true,
+        roundDone: false
+      });
+    } catch (e) {
+      deps.logger.error(`[groupChatEngine] speech generation failed for ${member.nickname}:`, e);
+      const failMsg = {
+        msgId: `${Date.now()}_fail`,
+        speakerId: 0,
+        speakerName: "\u7CFB\u7EDF",
+        content: `${member.nickname} \u6B32\u8A00\u53C8\u6B62...`,
+        timestamp: Date.now()
+      };
+      newMessages.push(failMsg);
+      onEvent({
+        sessionId: session.sessionId,
+        msgId: failMsg.msgId,
+        speakerId: 0,
+        speakerName: "\u7CFB\u7EDF",
+        content: failMsg.content,
+        isDone: true,
+        roundDone: false
+      });
+    }
+    lastMessages.push(...newMessages.slice(-1));
+  }
+  onEvent({
+    sessionId: session.sessionId,
+    msgId: "",
+    speakerId: 0,
+    speakerName: "",
+    content: "",
+    isDone: true,
+    roundDone: true
+  });
+  return newMessages;
+}
+export {
+  AVA_BASE_URL,
+  CallbackStreamSink,
+  ConsoleLogger,
+  FlipCacheService,
+  GroupChatStore,
+  MIRROR_PRESETS,
+  MemoryConfigStore,
+  MemoryFlipDataSource,
+  MirrorIndex,
+  MirrorMemory,
+  MirrorStore,
+  NodeJsonConfigStore,
+  NodeJsonFileStorage,
+  NodeJsonFlipDataSource,
+  NoopEventSink,
+  NoopLogger,
+  OpenAICompatibleClient,
+  POCKET_API_BASE,
+  POCKET_APP_INFO,
+  POCKET_PA,
+  POCKET_USER_AGENT,
+  PRESET_MODELS,
+  PRESET_PROVIDERS,
+  PlainTextSecureStorage,
+  PocketAuthExpiredError,
+  PocketClient,
+  SESSION_EXPIRE_MS,
+  ToolRegistry,
+  agentLoop,
+  agentLoopStream,
+  buildInnerMonologuePrompt,
+  buildMirror,
+  buildSpeakPrompt,
+  chat,
+  clearChatMemory,
+  clearMirrorMemory,
+  createMirrorTools,
+  createPlatformTools,
+  createPocketCore,
+  createPocketTools,
+  defaultModelConfig,
+  fetchMemberList,
+  getAllFlips,
+  getDataSourcePage,
+  getImUserInfo,
+  getMemberFlipHistory,
+  getMemberFlipPriceInfo,
+  getMemberListByTab,
+  getMirrorConfig,
+  getRoomChannelByStar,
+  getRoomInfo,
+  getRoomMessages,
+  getTeamListInfo,
+  getUnreadMessageNum,
+  loginWithCode,
+  loginWithToken,
+  normalizePersona,
+  normalizePocketUser,
+  rollbackPersona,
+  runRound,
+  saveAssistantMessage,
+  sendFlip,
+  sendVerificationCode,
+  shouldTriggerGrowth,
+  syncFlips,
+  triggerGrowth
+};
+//# sourceMappingURL=index.js.map