dsh-cuigengji-plugin 0.4.3 → 0.4.4

package/src/adapters/dsh/rpc.js

@@ -1,96 +1,96 @@
-import { readFileSync } from 'node:fs';
-import { HUMAN_ACTIONS } from '../../contracts/actions.js';
-import { convertLegacyExport } from '../../infrastructure/migrations/legacy.js';
-
-const manifest = JSON.parse(readFileSync(new URL('../../../package.json', import.meta.url), 'utf8'));
-export const RPC_ENDPOINT = 'cuigengji/dispatch';
-const RPC_PATH = `/api/${RPC_ENDPOINT}`;
-const record = value => value !== null && typeof value === 'object' && !Array.isArray(value);
-const invalid = message => Object.assign(new Error(message), { code: 'INVALID_INPUT' });
-
-function failure(error) {
-  return {
-    ok: false,
-    error: {
-      code: error.code || 'CUIGENGJI_ERROR',
-      message: error.message || String(error),
-      details: {},
-    },
-  };
-}
-
-export function registerRpcRoute(ctx, { dispatch, dataRoot, workData, transfer, maintenance }) {
-  const ensureReady = () => maintenance?.ensureReady();
-  const dispatchRpc = async (payload, signal) => {
-    try {
-      signal.throwIfAborted();
-      if (!record(payload) || !HUMAN_ACTIONS.includes(payload.action)) throw invalid('无效的催更姬操作');
-      const { action, args = {}, sessionId } = payload;
-      if (!record(args)) throw invalid('args 必须是对象');
-      if (sessionId !== undefined && (typeof sessionId !== 'string' || !sessionId.trim() || sessionId.length > 512)) {
-        throw invalid('sessionId 必须是有效的会话标识');
-      }
-      if (!action.startsWith('transfer.') && !['novel.list', 'novel.create', 'novel.import', 'legacy.preview', 'settings.get', 'maintenance.status', 'maintenance.verify', 'workspace.status', 'workspace.export', 'workspace.preview', 'workspace.import'].includes(action) && !sessionId) {
-        throw Object.assign(new Error('请选择一个 DSH 会话'), { code: 'SESSION_REQUIRED' });
-      }
-      if (action === 'settings.get') {
-        return { ok: true, value: { dataRoot, pluginVersion: manifest.version, supportedDsh: manifest.peerDependencies['@deepseek-ai/dsh-tools'] } };
-      }
-      if (action === 'legacy.preview') return { ok: true, value: convertLegacyExport(args.input) };
-      if (action === 'maintenance.status') {
-        if (!maintenance) throw invalid('维护服务未初始化');
-        return { ok: true, value: await maintenance.status() };
-      }
-      if (action === 'maintenance.verify') {
-        if (!maintenance) throw invalid('维护服务未初始化');
-        return { ok: true, value: await maintenance.verify(args) };
-      }
-      if (action.startsWith('transfer.')) {
-        await ensureReady();
-        if (!transfer) throw invalid('导入 / 导出服务未初始化');
-        const method = {'transfer.catalog':'catalog','transfer.inspect':'inspect','transfer.preview':'preview','transfer.import':'import','transfer.exportPreview':'exportPreview','transfer.export':'export'}[action];
-        return {ok: true, value: await transfer[method](args, {sessionId})};
-      }
-      if (action.startsWith('workspace.')) {
-        await ensureReady();
-        if (!workData) throw invalid('工作数据服务未初始化');
-        const method = { 'workspace.status':'status', 'workspace.export':'export', 'workspace.preview':'preview', 'workspace.import':'import' }[action];
-        return { ok: true, value: await workData[method](args.backup) };
-      }
-      await ensureReady();
-      return { ok: true, value: await dispatch(action, args, { kind: 'human', sessionId }) };
-    } catch (error) {
-      return failure(error);
-    }
-  };
-
-  ctx.connection.fetch.register({
-    path: RPC_PATH,
-    methods: ['POST'],
-    requestBody: 'buffered',
-    fetch: async request => {
-      if (request.headers.get('content-type')?.split(';')[0].trim().toLowerCase() !== 'application/json') {
-        return new Response('content type must be application/json', { status: 415 });
-      }
-      let message;
-      try {
-        message = await request.json();
-      } catch {
-        return new Response('body is not JSON', { status: 400 });
-      }
-      const rpcId = typeof message?.rpcId === 'string' ? message.rpcId : 'invalid-request';
-      if (!record(message) || message.type !== 'client-request' || message.method !== RPC_ENDPOINT || typeof message.rpcId !== 'string' || !message.rpcId.trim()) {
-        return Response.json({
-          type: 'server-response',
-          rpcId,
-          result: failure(invalid('无效的 RPC 请求')),
-        });
-      }
-      return Response.json({
-        type: 'server-response',
-        rpcId,
-        result: await dispatchRpc(message.payload, request.signal),
-      });
-    },
-  });
-}
+import { readFileSync } from 'node:fs';
+import { HUMAN_ACTIONS } from '../../contracts/actions.js';
+import { convertLegacyExport } from '../../infrastructure/migrations/legacy.js';
+
+const manifest = JSON.parse(readFileSync(new URL('../../../package.json', import.meta.url), 'utf8'));
+export const RPC_ENDPOINT = 'cuigengji/dispatch';
+const RPC_PATH = `/api/${RPC_ENDPOINT}`;
+const record = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+const invalid = message => Object.assign(new Error(message), { code: 'INVALID_INPUT' });
+
+function failure(error) {
+  return {
+    ok: false,
+    error: {
+      code: error.code || 'CUIGENGJI_ERROR',
+      message: error.message || String(error),
+      details: {},
+    },
+  };
+}
+
+export function registerRpcRoute(ctx, { dispatch, dataRoot, workData, transfer, maintenance }) {
+  const ensureReady = () => maintenance?.ensureReady();
+  const dispatchRpc = async (payload, signal) => {
+    try {
+      signal.throwIfAborted();
+      if (!record(payload) || !HUMAN_ACTIONS.includes(payload.action)) throw invalid('无效的催更姬操作');
+      const { action, args = {}, sessionId } = payload;
+      if (!record(args)) throw invalid('args 必须是对象');
+      if (sessionId !== undefined && (typeof sessionId !== 'string' || !sessionId.trim() || sessionId.length > 512)) {
+        throw invalid('sessionId 必须是有效的会话标识');
+      }
+      if (!action.startsWith('transfer.') && !['novel.list', 'novel.create', 'novel.import', 'legacy.preview', 'settings.get', 'maintenance.status', 'maintenance.verify', 'workspace.status', 'workspace.export', 'workspace.preview', 'workspace.import'].includes(action) && !sessionId) {
+        throw Object.assign(new Error('请选择一个 DSH 会话'), { code: 'SESSION_REQUIRED' });
+      }
+      if (action === 'settings.get') {
+        return { ok: true, value: { dataRoot, pluginVersion: manifest.version, supportedDsh: manifest.peerDependencies['@deepseek-ai/dsh-tools'] } };
+      }
+      if (action === 'legacy.preview') return { ok: true, value: convertLegacyExport(args.input) };
+      if (action === 'maintenance.status') {
+        if (!maintenance) throw invalid('维护服务未初始化');
+        return { ok: true, value: await maintenance.status() };
+      }
+      if (action === 'maintenance.verify') {
+        if (!maintenance) throw invalid('维护服务未初始化');
+        return { ok: true, value: await maintenance.verify(args) };
+      }
+      if (action.startsWith('transfer.')) {
+        await ensureReady();
+        if (!transfer) throw invalid('导入 / 导出服务未初始化');
+        const method = {'transfer.catalog':'catalog','transfer.inspect':'inspect','transfer.preview':'preview','transfer.import':'import','transfer.exportPreview':'exportPreview','transfer.export':'export'}[action];
+        return {ok: true, value: await transfer[method](args, {sessionId})};
+      }
+      if (action.startsWith('workspace.')) {
+        await ensureReady();
+        if (!workData) throw invalid('工作数据服务未初始化');
+        const method = { 'workspace.status':'status', 'workspace.export':'export', 'workspace.preview':'preview', 'workspace.import':'import' }[action];
+        return { ok: true, value: await workData[method](args.backup) };
+      }
+      await ensureReady();
+      return { ok: true, value: await dispatch(action, args, { kind: 'human', sessionId }) };
+    } catch (error) {
+      return failure(error);
+    }
+  };
+
+  ctx.connection.fetch.register({
+    path: RPC_PATH,
+    methods: ['POST'],
+    requestBody: 'buffered',
+    fetch: async request => {
+      if (request.headers.get('content-type')?.split(';')[0].trim().toLowerCase() !== 'application/json') {
+        return new Response('content type must be application/json', { status: 415 });
+      }
+      let message;
+      try {
+        message = await request.json();
+      } catch {
+        return new Response('body is not JSON', { status: 400 });
+      }
+      const rpcId = typeof message?.rpcId === 'string' ? message.rpcId : 'invalid-request';
+      if (!record(message) || message.type !== 'client-request' || message.method !== RPC_ENDPOINT || typeof message.rpcId !== 'string' || !message.rpcId.trim()) {
+        return Response.json({
+          type: 'server-response',
+          rpcId,
+          result: failure(invalid('无效的 RPC 请求')),
+        });
+      }
+      return Response.json({
+        type: 'server-response',
+        rpcId,
+        result: await dispatchRpc(message.payload, request.signal),
+      });
+    },
+  });
+}

package/src/adapters/dsh/skills.js

@@ -1,22 +1,22 @@
-import { readFileSync } from 'node:fs';
-export const skillSpecs = [
-  ['cuigengji-project', '接手催更姬小说项目，定位作者的协作目标，按需读取资料并安全保存正文、规划与设定。'],
+import { readFileSync } from 'node:fs';
+export const skillSpecs = [
+  ['cuigengji-project', '接手催更姬小说项目，定位作者的协作目标，按需读取资料并安全保存正文、规划与设定。'],
   ['cuigengji-plan', '讨论剧情走向、人物行动、因果或备选方案时使用；主动把结构性讨论维护到相关共享画布页，用事件、并行动线与分支帮助作者对齐思路。'],
-  ['cuigengji-write', '按作者意图写作或续写小说正文，用章节工具保存，并按实际结果维护相关规划与设定。'],
-  ['cuigengji-revise', '审阅或修订已保存正文，定位具体问题，用版本检查保留作者并行修改，并核对受影响的规划与设定。'],
+  ['cuigengji-write', '按作者意图写作或续写小说正文，用章节工具保存，并按实际结果维护相关规划与设定。'],
+  ['cuigengji-revise', '审阅或修订已保存正文，定位具体问题，用版本检查保留作者并行修改，并核对受影响的规划与设定。'],
   ['cuigengji-memory', '讨论、设计或完善人物动机、世界规则、阵营与关系时使用；主动复用设定卡与关系图，保留未决提案并区分既定事实。'],
-  ['cuigengji-maintenance', '安装或更新催更姬后，查询自动迁移、备份和完整性校验结果；不要求绑定小说。'],
-];
-export function registerSkills(ctx) {
-  const shared = readFileSync(new URL('../../../skills/cuigengji-project/SKILL.md', import.meta.url), 'utf8');
-  const body = text => text.replace(/^---\r?\n[\s\S]*?\r?\n---(?:\r?\n|$)/, '').trim();
-  for (const [name, description] of skillSpecs) {
-    const task = readFileSync(new URL(`../../../skills/${name}/SKILL.md`, import.meta.url), 'utf8');
-    ctx.skills.register({ name, description, source: 'cuigengji',
-      content: (name === 'cuigengji-project' || name === 'cuigengji-maintenance') ? task : `${task.trim()}\n\n${body(shared)}`,
-    });
-  }
-}
+  ['cuigengji-maintenance', '安装或更新催更姬后，查询自动迁移、备份和完整性校验结果；不要求绑定小说。'],
+];
+export function registerSkills(ctx) {
+  const shared = readFileSync(new URL('../../../skills/cuigengji-project/SKILL.md', import.meta.url), 'utf8');
+  const body = text => text.replace(/^---\r?\n[\s\S]*?\r?\n---(?:\r?\n|$)/, '').trim();
+  for (const [name, description] of skillSpecs) {
+    const task = readFileSync(new URL(`../../../skills/${name}/SKILL.md`, import.meta.url), 'utf8');
+    ctx.skills.register({ name, description, source: 'cuigengji',
+      content: (name === 'cuigengji-project' || name === 'cuigengji-maintenance') ? task : `${task.trim()}\n\n${body(shared)}`,
+    });
+  }
+}
 export const persona = `你是帮助用户创作和维护小说的写作助手。
 当前共享协作规则为 shared-canvas-v2；旧会话首次处理相关任务时，已加载的指南若没有这个版本标记，重新加载对应 Skill 一次。
 讨论剧情结构、走向和备选方案时加载 cuigengji-plan，主动维护相关共享画布页；设计人物与世界规则时加载 cuigengji-memory。结构性讨论默认包含记录未确认提案，不必等作者点名画布；明确只聊不保存、简单问答或只读审阅时不写入。

package/src/adapters/mcp/actions.js

@@ -1,8 +1,8 @@
 import { MEMORY_ACTIONS } from '../../contracts/actions.js';
 export { MEMORY_ACTIONS };
-
-export const toolName = action => `memory_${action.replaceAll('.', '_')}`;
-
-export function assertMemoryAction(action) {
-  if (!MEMORY_ACTIONS.includes(action)) throw new Error(`不允许的记忆操作：${action}`);
-}
+
+export const toolName = action => `memory_${action.replaceAll('.', '_')}`;
+
+export function assertMemoryAction(action) {
+  if (!MEMORY_ACTIONS.includes(action)) throw new Error(`不允许的记忆操作：${action}`);
+}

package/src/adapters/mcp/client.js

@@ -1,172 +1,172 @@
-import http from 'node:http';
-import { randomBytes } from 'node:crypto';
-import { fileURLToPath } from 'node:url';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-import { assertMemoryAction, toolName } from './actions.js';
-
-const MAX_BODY_BYTES = 1024 * 1024;
-
-export function memoryRuntime(options = {}, runtime = process) {
-  const command = options.nodeCommand ?? runtime.env.CUIGENGJI_DSH_NODE ?? runtime.execPath;
-  const env = {};
-  if (runtime.env.NODE_OPTIONS) env.NODE_OPTIONS = runtime.env.NODE_OPTIONS;
-  // Desktop hosts use the Electron executable as Node. The SDK's default
-  // environment omits this switch, which otherwise launches a second GUI.
-  if (runtime.versions.electron || runtime.env.ELECTRON_RUN_AS_NODE === '1') {
-    env.ELECTRON_RUN_AS_NODE = '1';
-  }
-  return { command, env };
-}
-
-export class MemoryBridge {
-  constructor(store, options = {}) {
-    this.store = store;
-    this.dispatch = options.dispatch ?? ((action, args, actor) => store.dispatch(action, args, actor));
-    this.resolveNovel = options.resolveNovel;
-    this.timeoutMs = options.timeoutMs ?? 30_000;
-    const runtime = memoryRuntime(options);
-    this.nodeCommand = runtime.command;
-    this.runtimeEnv = runtime.env;
-    this.sessions = new Map();
-    this.tokens = new Map();
-    this.closed = false;
-  }
-
-  async start() {
-    if (this.closed) throw new Error('记忆服务已关闭');
-    if (this.starting) return this.starting;
-    this.starting = (async () => {
-      this.server = http.createServer((request, response) => { void this.handle(request, response); });
-      this.server.requestTimeout = this.timeoutMs;
-      await new Promise((resolve, reject) => {
-        this.server.once('error', reject);
-        this.server.listen(0, '127.0.0.1', resolve);
-      });
-      this.endpoint = `http://127.0.0.1:${this.server.address().port}/memory`;
-      return this;
-    })();
-    return this.starting;
-  }
-
-  async handle(request, response) {
-    const reply = (status, data) => {
-      if (response.destroyed) return;
-      response.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
-      response.end(JSON.stringify(data));
-    };
-    try {
-      if (request.method !== 'POST' || request.url !== '/memory') return reply(404, { error: '未知接口' });
-      const sessionId = this.tokens.get((request.headers.authorization ?? '').replace(/^Bearer /, ''));
-      if (!sessionId) return reply(401, { error: '会话凭据失效' });
-      let size = 0;
-      const chunks = [];
-      for await (const chunk of request) {
-        size += chunk.length;
-        if (size > MAX_BODY_BYTES) return reply(413, { error: '记忆请求过大' });
-        chunks.push(chunk);
-      }
-      const { action, args = {} } = JSON.parse(Buffer.concat(chunks).toString('utf8'));
-      assertMemoryAction(action);
-      if (!args || typeof args !== 'object' || Array.isArray(args)) throw new Error('参数必须是对象');
-      const actor = { kind: 'agent', sessionId };
-      const novelId = await this.boundNovel(sessionId);
-      if (!novelId) throw new Error('当前会话尚未绑定小说');
-      if (args.novelId && args.novelId !== novelId) throw new Error('不能访问其他小说');
-      // Never forward model-supplied session/actor identities.
-      const { sessionId: _session, actor: _actor, ...safeArgs } = args;
-      const result = await this.dispatch(action, { ...safeArgs, novelId }, actor);
-      reply(200, { result });
-    } catch (error) {
-      reply(400, { error: error.message });
-    }
-  }
-
-  async boundNovel(sessionId) {
-    if (this.resolveNovel) return this.resolveNovel(sessionId);
-    const binding = await this.store.dispatch('binding.get', {}, { kind: 'agent', sessionId });
-    return binding?.novelId;
-  }
-
-  async connection(sessionId) {
-    if (!sessionId || typeof sessionId !== 'string') throw new Error('缺少会话 ID');
-    await this.start();
-    const existing = this.sessions.get(sessionId);
-    if (existing) return existing.pending ?? existing;
-    const entry = { pending: null };
-    entry.pending = this.connect(sessionId, entry);
-    this.sessions.set(sessionId, entry);
-    try { return await entry.pending; }
-    catch (error) {
-      if (this.sessions.get(sessionId) === entry) this.sessions.delete(sessionId);
-      throw error;
-    }
-  }
-
-  async connect(sessionId, entry) {
-    const token = randomBytes(32).toString('hex');
-    this.tokens.set(token, sessionId);
-    const env = { ...this.runtimeEnv, CUIGENGJI_MEMORY_ENDPOINT: this.endpoint, CUIGENGJI_MEMORY_TOKEN: token };
-    const transport = new StdioClientTransport({
-      command: this.nodeCommand,
-      args: [fileURLToPath(new URL('./server.js', import.meta.url))],
-      env,
-      stderr: 'pipe',
-    });
-    const client = new Client({ name: 'cuigengji-host', version: '0.1.0' });
-    // Keep child diagnostics out of model output; drain to avoid pipe backpressure.
-    transport.stderr?.on('data', () => {});
-    client.onclose = () => {
-      this.tokens.delete(token);
-      // A reconnect may have replaced this entry. Never tear down the new
-      // connection when an older MCP child exits asynchronously.
-      if (this.sessions.get(sessionId) === entry) this.sessions.delete(sessionId);
-    };
-    try {
-      await client.connect(transport);
-      return { client, transport, token };
-    } catch (error) {
-      this.tokens.delete(token);
-      await transport.close().catch(() => {});
-      throw error;
-    }
-  }
-
-  async call(sessionId, action, args = {}, { signal } = {}) {
-    assertMemoryAction(action);
-    if (signal?.aborted) throw signal.reason ?? new Error('已取消');
-    const { client } = await this.connection(sessionId);
-    const result = await client.callTool({ name: toolName(action), arguments: args }, undefined, {
-      timeout: this.timeoutMs, signal,
-    });
-    const output = result.content?.find(item => item.type === 'text')?.text;
-    if (result.isError) throw new Error(output ?? '记忆工具失败');
-    return JSON.parse(output ?? 'null');
-  }
-
-  async disconnect(sessionId) {
-    const entry = this.sessions.get(sessionId);
-    this.sessions.delete(sessionId);
-    if (!entry) return;
-    const connection = await (entry.pending ?? entry).catch(() => null);
-    if (!connection) return;
-    this.tokens.delete(connection.token);
-    await connection.client.close();
-  }
-
-  async close() {
-    this.closed = true;
-    await Promise.allSettled([...this.sessions.keys()].map(sessionId => this.disconnect(sessionId)));
-    this.tokens.clear();
-    if (this.server) {
-      this.server.closeAllConnections();
-      await new Promise(resolve => this.server.close(resolve));
-    }
-  }
-}
-
-export class MemoryClient {
-  constructor(bridge, sessionId) { this.bridge = bridge; this.sessionId = sessionId; }
-  call(action, args, options) { return this.bridge.call(this.sessionId, action, args, options); }
-  close() { return this.bridge.disconnect(this.sessionId); }
-}
+import http from 'node:http';
+import { randomBytes } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { assertMemoryAction, toolName } from './actions.js';
+
+const MAX_BODY_BYTES = 1024 * 1024;
+
+export function memoryRuntime(options = {}, runtime = process) {
+  const command = options.nodeCommand ?? runtime.env.CUIGENGJI_DSH_NODE ?? runtime.execPath;
+  const env = {};
+  if (runtime.env.NODE_OPTIONS) env.NODE_OPTIONS = runtime.env.NODE_OPTIONS;
+  // Desktop hosts use the Electron executable as Node. The SDK's default
+  // environment omits this switch, which otherwise launches a second GUI.
+  if (runtime.versions.electron || runtime.env.ELECTRON_RUN_AS_NODE === '1') {
+    env.ELECTRON_RUN_AS_NODE = '1';
+  }
+  return { command, env };
+}
+
+export class MemoryBridge {
+  constructor(store, options = {}) {
+    this.store = store;
+    this.dispatch = options.dispatch ?? ((action, args, actor) => store.dispatch(action, args, actor));
+    this.resolveNovel = options.resolveNovel;
+    this.timeoutMs = options.timeoutMs ?? 30_000;
+    const runtime = memoryRuntime(options);
+    this.nodeCommand = runtime.command;
+    this.runtimeEnv = runtime.env;
+    this.sessions = new Map();
+    this.tokens = new Map();
+    this.closed = false;
+  }
+
+  async start() {
+    if (this.closed) throw new Error('记忆服务已关闭');
+    if (this.starting) return this.starting;
+    this.starting = (async () => {
+      this.server = http.createServer((request, response) => { void this.handle(request, response); });
+      this.server.requestTimeout = this.timeoutMs;
+      await new Promise((resolve, reject) => {
+        this.server.once('error', reject);
+        this.server.listen(0, '127.0.0.1', resolve);
+      });
+      this.endpoint = `http://127.0.0.1:${this.server.address().port}/memory`;
+      return this;
+    })();
+    return this.starting;
+  }
+
+  async handle(request, response) {
+    const reply = (status, data) => {
+      if (response.destroyed) return;
+      response.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+      response.end(JSON.stringify(data));
+    };
+    try {
+      if (request.method !== 'POST' || request.url !== '/memory') return reply(404, { error: '未知接口' });
+      const sessionId = this.tokens.get((request.headers.authorization ?? '').replace(/^Bearer /, ''));
+      if (!sessionId) return reply(401, { error: '会话凭据失效' });
+      let size = 0;
+      const chunks = [];
+      for await (const chunk of request) {
+        size += chunk.length;
+        if (size > MAX_BODY_BYTES) return reply(413, { error: '记忆请求过大' });
+        chunks.push(chunk);
+      }
+      const { action, args = {} } = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+      assertMemoryAction(action);
+      if (!args || typeof args !== 'object' || Array.isArray(args)) throw new Error('参数必须是对象');
+      const actor = { kind: 'agent', sessionId };
+      const novelId = await this.boundNovel(sessionId);
+      if (!novelId) throw new Error('当前会话尚未绑定小说');
+      if (args.novelId && args.novelId !== novelId) throw new Error('不能访问其他小说');
+      // Never forward model-supplied session/actor identities.
+      const { sessionId: _session, actor: _actor, ...safeArgs } = args;
+      const result = await this.dispatch(action, { ...safeArgs, novelId }, actor);
+      reply(200, { result });
+    } catch (error) {
+      reply(400, { error: error.message });
+    }
+  }
+
+  async boundNovel(sessionId) {
+    if (this.resolveNovel) return this.resolveNovel(sessionId);
+    const binding = await this.store.dispatch('binding.get', {}, { kind: 'agent', sessionId });
+    return binding?.novelId;
+  }
+
+  async connection(sessionId) {
+    if (!sessionId || typeof sessionId !== 'string') throw new Error('缺少会话 ID');
+    await this.start();
+    const existing = this.sessions.get(sessionId);
+    if (existing) return existing.pending ?? existing;
+    const entry = { pending: null };
+    entry.pending = this.connect(sessionId, entry);
+    this.sessions.set(sessionId, entry);
+    try { return await entry.pending; }
+    catch (error) {
+      if (this.sessions.get(sessionId) === entry) this.sessions.delete(sessionId);
+      throw error;
+    }
+  }
+
+  async connect(sessionId, entry) {
+    const token = randomBytes(32).toString('hex');
+    this.tokens.set(token, sessionId);
+    const env = { ...this.runtimeEnv, CUIGENGJI_MEMORY_ENDPOINT: this.endpoint, CUIGENGJI_MEMORY_TOKEN: token };
+    const transport = new StdioClientTransport({
+      command: this.nodeCommand,
+      args: [fileURLToPath(new URL('./server.js', import.meta.url))],
+      env,
+      stderr: 'pipe',
+    });
+    const client = new Client({ name: 'cuigengji-host', version: '0.1.0' });
+    // Keep child diagnostics out of model output; drain to avoid pipe backpressure.
+    transport.stderr?.on('data', () => {});
+    client.onclose = () => {
+      this.tokens.delete(token);
+      // A reconnect may have replaced this entry. Never tear down the new
+      // connection when an older MCP child exits asynchronously.
+      if (this.sessions.get(sessionId) === entry) this.sessions.delete(sessionId);
+    };
+    try {
+      await client.connect(transport);
+      return { client, transport, token };
+    } catch (error) {
+      this.tokens.delete(token);
+      await transport.close().catch(() => {});
+      throw error;
+    }
+  }
+
+  async call(sessionId, action, args = {}, { signal } = {}) {
+    assertMemoryAction(action);
+    if (signal?.aborted) throw signal.reason ?? new Error('已取消');
+    const { client } = await this.connection(sessionId);
+    const result = await client.callTool({ name: toolName(action), arguments: args }, undefined, {
+      timeout: this.timeoutMs, signal,
+    });
+    const output = result.content?.find(item => item.type === 'text')?.text;
+    if (result.isError) throw new Error(output ?? '记忆工具失败');
+    return JSON.parse(output ?? 'null');
+  }
+
+  async disconnect(sessionId) {
+    const entry = this.sessions.get(sessionId);
+    this.sessions.delete(sessionId);
+    if (!entry) return;
+    const connection = await (entry.pending ?? entry).catch(() => null);
+    if (!connection) return;
+    this.tokens.delete(connection.token);
+    await connection.client.close();
+  }
+
+  async close() {
+    this.closed = true;
+    await Promise.allSettled([...this.sessions.keys()].map(sessionId => this.disconnect(sessionId)));
+    this.tokens.clear();
+    if (this.server) {
+      this.server.closeAllConnections();
+      await new Promise(resolve => this.server.close(resolve));
+    }
+  }
+}
+
+export class MemoryClient {
+  constructor(bridge, sessionId) { this.bridge = bridge; this.sessionId = sessionId; }
+  call(action, args, options) { return this.bridge.call(this.sessionId, action, args, options); }
+  close() { return this.bridge.disconnect(this.sessionId); }
+}