@sanqianx/project-knowledge 5.0.21 → 5.0.22

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
   "plugins": [
     {
       "name": "project-knowledge",
-      "version": "5.0.21",
+      "version": "5.0.22",
       "source": "./plugins/project-knowledge",
       "description": "Search durable project decisions and implementation history through MCP."
     }

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [5.0.22] - 2026-10-20
+
+- 将启动时的 Agent 接入检查和自动修复放入独立进程，避免慢客户端命令阻塞后台就绪通知、网页和实例控制；超时会记录可重试状态，停止服务同时清理自有检查进程。
+- 仅检查用户已连接的客户端；未能核实的状态不再当成未安装并触发自动修复。保留并排工作区、已有接入选择及知识数据。
+- 补充真实后台 CLI 在原生命令阻塞时的就绪、HTTP、状态查询和停止回归，以及超时、崩溃、手动修复结果优先级验证。
+
 ## [5.0.21] - 2026-10-20
 
 - 开始工作采用并排工作区：从加号新建子代理或按需添加知识引用，使用统一的对话、工具步骤、文件修改和输入框；移除面向客户的任务标识、派发阶段及诊断信息。

package/_site/_test/fixtures/slow-startup-integration.cjs

@@ -0,0 +1,12 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const root = process.env.KB_LAUNCHER_TEST_PACKAGE || path.resolve(__dirname, '../../..');
+const { IntegrationManager } = require(path.join(root, '_site/lib/integration-installer'));
+IntegrationManager.prototype.statusAll = async function () {
+  fs.writeFileSync(process.env.KB_STARTUP_INTEGRATION_MARKER, String(process.pid));
+  // Models a synchronous native CLI probe, without running or repairing any
+  // real client integration on the developer or CI machine.
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 8000);
+  return { clients: [{ client: 'codex', developmentCapture: { installed: true } }] };
+};

package/_site/_test/fixtures/startup-repair-worker.cjs

@@ -0,0 +1,13 @@
+'use strict';
+process.once('message', input => {
+  const mode = input.managerOptions.homeDir;
+  if (mode === 'crash') return process.exit(1);
+  if (mode === 'hang') return setInterval(() => {}, 1000);
+  setTimeout(() => {
+    process.send({ ok: true, results: {
+      claude: { state: 'failed', error: 'native repair failed' },
+      codex: { state: 'repaired', error: null },
+      zcode: { state: 'failed', error: 'unrequested result' },
+    } }, () => process.disconnect());
+  }, 80);
+});

package/_site/_test/integration-auto-repair-test.js

@@ -88,5 +88,26 @@ const makeManager = ({ statusClients, onInstall }) => {
     snapshot.claude = { state: 'tampered' };
     assert.equal(repair.status().claude.state, 'repaired', 'status() returns a copy');
   }
+  {
+    const dir = tmpDataDir();
+    markIntent(dir, 'codex', 'disconnected');
+    const manager = makeManager({ statusClients: [], onInstall: () => { throw new Error('must not repair'); } });
+    const repair = new IntegrationAutoRepair({ dataDir: dir, createManager: () => manager });
+    await repair.runOnce();
+    assert.equal(manager.calls.statusAll, 0, 'disconnected clients must not run native startup probes');
+    markIntent(dir, 'codex', 'connected');
+    manager.statusAll = async options => {
+      assert.deepEqual(options.clients, ['codex']);
+      return { clients: [{ client: 'codex', developmentCapture: { state: 'check-failed' } }] };
+    };
+    await repair.runOnce();
+    assert.equal(manager.calls.installAll.length, 0, 'an unknown status must not be treated as an absent integration');
+    manager.statusAll = async () => {
+      markIntent(dir, 'codex', 'disconnected');
+      return { clients: [{ client: 'codex', developmentCapture: { installed: false } }] };
+    };
+    await repair.runOnce();
+    assert.equal(manager.calls.installAll.length, 0, 'a user disconnect during status scanning must cancel the repair');
+  }
   console.log('integration auto repair test PASS');
 })().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/startup-integration-isolation-test.js

@@ -0,0 +1,59 @@
+'use strict';
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const net = require('node:net');
+const { spawn } = require('node:child_process');
+const control = require('../lib/runtime-control');
+const { markIntent } = require('../lib/integration-intent');
+const root = process.env.KB_LAUNCHER_TEST_PACKAGE || path.resolve(__dirname, '../..');
+const data = fs.mkdtempSync(path.join(os.tmpdir(), 'kb-startup-integration-'));
+const marker = path.join(data, 'slow-native-check.pid');
+const preload = path.join(__dirname, 'fixtures/slow-startup-integration.cjs').replace(/\\/g, '/');
+let instance;
+async function freePort() {
+  const server = net.createServer();
+  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+  const port = server.address().port;
+  await new Promise(resolve => server.close(resolve)); return port;
+}
+async function main() {
+  markIntent(data, 'codex', 'connected');
+  const port = await freePort();
+  const started = Date.now();
+  const launched = await new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [path.join(root, 'bin/project-knowledge.js'), '--no-open', '--port', String(port)], {
+      windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env, KB_DATA_DIR: data, KB_MODULES_AUTOSTART: '0',
+        KB_LAUNCHER_TEST_PACKAGE: root, KB_STARTUP_INTEGRATION_MARKER: marker,
+        AI_CODING_EVENT_BRIDGE_HOME: path.join(data, 'events'), NODE_OPTIONS: `--require="${preload}"` },
+    });
+    let stdout = '', stderr = '';
+    const timer = setTimeout(() => { child.kill(); reject(new Error('Background launch timed out')); }, 20000);
+    child.stdout.on('data', value => { stdout += value; }); child.stderr.on('data', value => { stderr += value; });
+    child.once('error', reject); child.once('exit', code => { clearTimeout(timer); resolve({ code, stdout, stderr }); });
+  });
+  assert.equal(launched.code, 0, launched.stderr);
+  instance = (await control.request(data, { action: 'status' }, 1000)).instance;
+  assert(Date.now() - started < 5000, 'native integration checks must not delay the launcher ready acknowledgement');
+  for (let i = 0; i < 60 && !fs.existsSync(marker); i++) await new Promise(resolve => setTimeout(resolve, 50));
+  assert(fs.existsSync(marker), 'startup auto repair must still run');
+  assert.notEqual(Number(fs.readFileSync(marker, 'utf8')), instance.pid, 'native checks must run outside the HTTP process');
+  for (let i = 0; i < 3; i++) {
+    const response = await fetch(`http://127.0.0.1:${port}/api/health`, { signal: AbortSignal.timeout(1000) });
+    assert.equal(response.status, 200, 'HTTP must remain usable while a native check is blocked');
+    assert.equal((await control.request(data, { action: 'status' }, 1000)).instance.pid, instance.pid);
+  }
+  const stopAt = Date.now();
+  await control.request(data, { action: 'stop', pid: instance.pid, port, startedAt: instance.startedAt }, 4000);
+  assert(Date.now() - stopAt < 4000, 'shutdown must cancel the blocked repair worker');
+  instance = null;
+  console.log('Startup integration isolation PASS: background ready, HTTP/control usable during a blocked native probe, owned worker stopped');
+}
+main().catch(error => { console.error(error); process.exitCode = 1; }).finally(async () => {
+  try {
+    const info = instance || (await control.request(data, { action: 'status' }, 1000)).instance;
+    await control.request(data, { action: 'stop', pid: info.pid, port: info.port, startedAt: info.startedAt });
+  } catch {}
+});

package/_site/_test/startup-integration-repair-test.js

@@ -0,0 +1,43 @@
+'use strict';
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { StartupIntegrationRepair } = require('../lib/startup-integration-repair');
+const { markIntent } = require('../lib/integration-intent');
+const { isProcessAlive } = require('../lib/runtime-endpoint');
+const workerFile = path.join(__dirname, 'fixtures/startup-repair-worker.cjs');
+async function main() {
+  const empty = fs.mkdtempSync(path.join(os.tmpdir(), 'kb-startup-repair-empty-'));
+  markIntent(empty, 'codex', 'disconnected');
+  const idle = new StartupIntegrationRepair({ dataDir: empty, workerFile: 'does-not-exist' });
+  assert.deepEqual(await idle.runOnce(), {}); assert.equal(idle.child, null); await idle.close();
+  for (const mode of ['normal', 'manual', 'crash', 'hang']) {
+    const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kb-startup-repair-'));
+    markIntent(dataDir, 'claude', 'connected'); markIntent(dataDir, 'codex', 'connected');
+    markIntent(dataDir, 'zcode', 'disconnected');
+    const logs = [];
+    const repair = new StartupIntegrationRepair({ dataDir, managerOptions: { homeDir: mode }, workerFile,
+      timeoutMs: mode === 'hang' ? 150 : 3000, logger: { warn: (...args) => logs.push(args) } });
+    try {
+      const result = repair.runOnce();
+      assert.equal(repair.runOnce(), result, 'one startup event must not spawn duplicate repair jobs');
+      if (mode === 'manual') repair.markSucceeded(['claude']);
+      const status = await result;
+      assert.equal(status.zcode, undefined, 'disconnected clients must not acquire repair state');
+      if (mode === 'normal') {
+        assert.equal(status.claude.state, 'failed'); assert.equal(status.codex.state, 'repaired');
+        repair.markSucceeded(['claude']); assert.equal(repair.status().claude.state, 'repaired');
+      } else if (mode === 'manual') {
+        assert.equal(status.claude, undefined, 'late startup failure must not overwrite a manual install');
+        assert.equal(status.codex.state, 'repaired');
+      } else {
+        assert.equal(status.claude.state, 'failed'); assert.equal(status.codex.state, 'failed');
+        assert.equal(logs.length, 1, 'worker failure must be reported without automatic retries');
+      }
+    } finally { await repair.close(); }
+    assert.equal(isProcessAlive(repair.child.pid), false, 'owned worker must be reaped on close');
+  }
+  console.log('Startup repair worker PASS: intent isolation, one attempt, manual success precedence, timeout, crash and owned cleanup');
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/zcode-capture-integration-test.js

@@ -59,6 +59,8 @@ const { runCli } = require('../../bin/project-knowledge-integrations');
     assert.equal(fs.readFileSync(configFile, 'utf8'), untouched);
 
     const runtime = createRuntime({ dataDir: layout.getDataDir(), logger, analysisOwner: 'engine', bridgeAdapter: new BridgeAdapter({ dataDir: layout.getDataDir(), bridgeHomeDir }) });
+    let startupRepairStops = 0;
+    runtime.integrationAutoRepair = { close: async () => { startupRepairStops++; }, status: () => ({}) };
     server = http.createServer(createRequestHandler(runtime, { integrationOptions: options }));
     await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
     const base = `http://127.0.0.1:${server.address().port}`;
@@ -68,6 +70,7 @@ const { runCli } = require('../../bin/project-knowledge-integrations');
       return response.json();
     };
     const apiInstall = await request('/api/integrations/install', { clients: ['zcode'], captureOnly: true });
+    assert.equal(startupRepairStops, 1, 'manual install cancels concurrent startup repair');
     assert.equal(apiInstall.complete, true);
     assert(apiInstall.operationId);
     const apiStatus = await request('/api/integrations/status');
@@ -82,6 +85,7 @@ const { runCli } = require('../../bin/project-knowledge-integrations');
     assert(errors.some(entry => entry.operationId === failed.operationId && entry.context.client === 'zcode' && entry.error.message.includes('JSON')), 'actual failed phase and operation ID are persisted');
     fs.writeFileSync(configFile, JSON.stringify(twice));
     const removed = await request('/api/integrations/uninstall', { clients: ['zcode'], captureOnly: true });
+    assert.equal(startupRepairStops, 3, 'manual uninstall cancels startup repair before removing client hooks');
     assert.equal(removed.complete, true);
     assert.deepEqual(removed.clients, [], 'capture-only removal does not invoke knowledge plugin operations');
     assert.equal(removed.capture[0].state, 'removed');

package/_site/lib/integration-auto-repair.js

@@ -44,10 +44,12 @@ class IntegrationAutoRepair {
   async runOnce() {
     const intent = readIntent(this.dataDir);
     if (!intent) return this.status();
-    const status = await this.createManager().statusAll({});
+    const clients = Object.entries(intent.clients).filter(([, state]) => state === 'connected').map(([client]) => client);
+    if (!clients.length) return this.status();
+    const status = await this.createManager().statusAll({ clients });
     for (const entry of status?.clients || []) {
-      if (intent.clients[entry.client] !== 'connected') continue;
-      if (entry.developmentCapture?.installed === true) continue;
+      if (readIntent(this.dataDir)?.clients[entry.client] !== 'connected') continue;
+      if (entry.developmentCapture?.installed !== false) continue;
       if (this.attempted.has(entry.client)) continue;
       await this._attempt(entry.client);
     }

package/_site/lib/integration-repair-worker.js

@@ -0,0 +1,16 @@
+'use strict';
+const { IntegrationManager } = require('./integration-installer');
+const { IntegrationAutoRepair } = require('./integration-auto-repair');
+process.once('message', async input => {
+  const logger = Object.fromEntries(['info', 'warn', 'error'].map(level => [level, (...args) => {
+    if (process.connected) process.send({ kind: 'log', level, args });
+  }]));
+  try {
+    const repair = new IntegrationAutoRepair({ dataDir: input.dataDir, logger,
+      createManager: () => new IntegrationManager({ ...input.managerOptions, logger }) });
+    const results = await repair.runOnce();
+    process.send({ ok: true, results }, () => process.disconnect());
+  } catch {
+    process.send({ ok: false }, () => process.disconnect());
+  }
+});

package/_site/lib/server-app.js

@@ -1332,6 +1332,7 @@ function createRequestHandler(runtime, options = {}) {
       if (method === 'POST' && pathname === '/api/integrations/install') {
         runtime.integrationStatusScan?.invalidate();
         const body = await readJsonBody(req);
+        await runtime.integrationAutoRepair?.close();
         const manager = new IntegrationManager({ ...options.integrationOptions, rootDir: runtime.rootDir, logger: runtime.logger, operationId: requestOperationId, bridgeHomeDir: runtime.bridgeAdapter.hookBinding().bridgeHomeDir });
         const clients = Array.isArray(body.clients) && body.clients.length
           ? body.clients.map(client => String(client))
@@ -1355,6 +1356,7 @@ function createRequestHandler(runtime, options = {}) {
       }
       if (method === 'POST' && pathname === '/api/integrations/uninstall') {
         const body = await readJsonBody(req);
+        await runtime.integrationAutoRepair?.close();
         const manager = new IntegrationManager({ ...options.integrationOptions, rootDir: runtime.rootDir, logger: runtime.logger, operationId: requestOperationId, bridgeHomeDir: runtime.bridgeAdapter.hookBinding().bridgeHomeDir });
         if (body.disableAllCapture === true) {
           const summary = await manager.disableAllCapture({});
@@ -1563,17 +1565,17 @@ async function startServer(options = {}) {
   }
 
   // Startup-event integration repair: one attempt per connected-but-broken
-  // client, failures surfaced and never retried in this run. No timers.
+  // client, failures surfaced and never retried in this run. Native checks
+  // run in an owned worker so they cannot block HTTP or launcher readiness.
   try {
-    runtime.integrationAutoRepair = new (require('./integration-auto-repair').IntegrationAutoRepair)({
+    runtime.integrationAutoRepair = new (require('./startup-integration-repair').StartupIntegrationRepair)({
       dataDir: runtime.dataPath,
       logger: runtime.logger,
-      createManager: () => new IntegrationManager({
+      managerOptions: {
         ...options.integrationOptions,
         rootDir: runtime.rootDir,
-        logger: runtime.logger,
         bridgeHomeDir: runtime.bridgeAdapter.hookBinding().bridgeHomeDir,
-      }),
+      },
     });
     runtime.integrationAutoRepair.runOnce().catch(error => {
       runtime.logger.warn('integrations.auto_repair_skipped', '启动自动修复未完成。', { error });
@@ -1587,6 +1589,7 @@ async function startServer(options = {}) {
     if (stopping) return stopping;
     stopping = (async () => {
       runtime.integrationStatusScan?.close();
+      await runtime.integrationAutoRepair?.close();
       clearInterval(maintenanceTimer);
       clearInterval(configurationTimer);
       clearTimeout(readyTimer); runtime.moduleBridge.onReady = null;

package/_site/lib/startup-integration-repair.js

@@ -0,0 +1,77 @@
+'use strict';
+const path = require('node:path');
+const { fork, spawn } = require('node:child_process');
+const { readIntent } = require('./integration-intent');
+
+// Native client commands can block for minutes. Keep the whole startup
+// status/repair operation outside the HTTP and launcher readiness process.
+class StartupIntegrationRepair {
+  constructor({ dataDir, managerOptions = {}, logger, workerFile, timeoutMs = 120000 } = {}) {
+    this.dataDir = dataDir; this.managerOptions = managerOptions; this.logger = logger;
+    this.workerFile = workerFile || path.join(__dirname, 'integration-repair-worker.js');
+    this.timeoutMs = timeoutMs; this.results = {}; this.manualSuccess = new Set();
+    this.closed = false; this.promise = null; this.child = null;
+  }
+  status() { return { ...this.results }; }
+  markSucceeded(clients) {
+    for (const client of clients || []) {
+      this.manualSuccess.add(client);
+      if (this.results[client]?.state === 'failed') this.results[client] = { state: 'repaired', at: new Date().toISOString(), error: null };
+    }
+  }
+  runOnce() {
+    if (this.promise) return this.promise;
+    const clients = Object.entries(readIntent(this.dataDir)?.clients || {}).filter(([, state]) => state === 'connected').map(([client]) => client);
+    if (this.closed || !clients.length) return Promise.resolve(this.status());
+    this.promise = new Promise(resolve => {
+      const child = fork(this.workerFile, [], { stdio: ['ignore', 'ignore', 'ignore', 'ipc'], windowsHide: true, detached: process.platform !== 'win32' });
+      this.child = child;
+      let settled = false;
+      const finish = (results, code) => {
+        if (settled) return; settled = true; clearTimeout(timer);
+        if (!this.closed) {
+          for (const [client, result] of Object.entries(results || {})) {
+            if (clients.includes(client) && !this.manualSuccess.has(client)) this.results[client] = result;
+          }
+          if (code) {
+            for (const client of clients) if (!this.manualSuccess.has(client)) this.results[client] = { state: 'failed', at: new Date().toISOString(), error: '启动接入检查未完成，请在 Agent 接入中重试。' };
+            Promise.resolve(this.logger?.warn?.('integrations.auto_repair_skipped', '启动接入检查未完成，主界面继续可用。', { context: { code, clients } })).catch(() => {});
+          }
+        }
+        resolve(this.status());
+      };
+      const timer = setTimeout(() => { void this.terminate().catch(() => {}); finish(null, 'INTEGRATION_REPAIR_TIMEOUT'); }, this.timeoutMs);
+      child.on('message', message => {
+        if (message?.kind === 'log') {
+          if (['info', 'warn', 'error'].includes(message.level) && Array.isArray(message.args) && /^integrations?\./.test(message.args[0] || '')) {
+            Promise.resolve(this.logger?.[message.level]?.(...message.args)).catch(() => {});
+          }
+          return;
+        }
+        finish(message?.results, message?.ok ? null : 'INTEGRATION_REPAIR_FAILED');
+      });
+      child.once('error', () => finish(null, 'INTEGRATION_REPAIR_SPAWN_FAILED'));
+      child.once('exit', () => finish(null, this.closed ? null : 'INTEGRATION_REPAIR_EXITED'));
+      const allowed = ['rootDir', 'homeDir', 'version', 'packageSpec', 'marketplaceSource', 'codexMarketplaceSource', 'bridgeHomeDir', 'bridgeConsumerName', 'claudeSettingsFile', 'codexConfigFile', 'zcodeConfigFile', 'openCodePluginsDir', 'env'];
+      child.send({ dataDir: this.dataDir, managerOptions: Object.fromEntries(allowed.filter(key => this.managerOptions[key] !== undefined).map(key => [key, this.managerOptions[key]])) }, error => { if (error) finish(null, 'INTEGRATION_REPAIR_SEND_FAILED'); });
+    });
+    return this.promise;
+  }
+  terminate() {
+    const child = this.child;
+    if (!child?.pid || child.exitCode !== null || child.signalCode !== null) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error('启动接入检查进程尚未停止。')), 5000);
+      child.once('exit', () => { clearTimeout(timer); resolve(); });
+      if (process.platform === 'win32') {
+        // Only this live worker and its native probe children are owned here.
+        const killer = spawn('taskkill.exe', ['/PID', String(child.pid), '/T', '/F'], { windowsHide: true, stdio: 'ignore' });
+        killer.once('error', () => child.kill());
+      } else {
+        try { process.kill(-child.pid, 'SIGTERM'); } catch { child.kill('SIGTERM'); }
+      }
+    });
+  }
+  async close() { this.closed = true; await this.terminate(); }
+}
+module.exports = { StartupIntegrationRepair };

package/docs/fresh-v5-start.md

@@ -15,6 +15,8 @@ project-knowledge
 
 5.0.6 修复首次启动被未登记的旧工作台会话误拦截：仅有日志、默认提示词及孤立会话的目录可以创建空的新登记，孤立会话保留原字节但不会恢复或触发任务。实际旧项目、设置、引擎状态或维护任务仍拒绝迁移，错误列出具体目录和冲突项。后台启动命令等待 HTTP 就绪后才报成功；启动失败直接在终端显示原因并返回非零退出码，不提前打开浏览器。
 
+5.0.22 将启动时的 Agent 接入检查和自动修复放入独立进程，慢客户端命令不再占住后台就绪通知、网页或实例控制。检查失败可在 Agent 接入中重试，停止服务会同时结束自有检查进程；无需清空数据。若仍提示启动未完成，请同时保留 `project-knowledge --version`、`project-knowledge status` 和报错所指 `launcher.log` 的末尾记录，以区分进程失败与慢启动。
+
 在“系统状态”重新配置模型与后台默认模型、embedding 和知识根目录，然后在“领域与项目”导入代码目录及新的空知识目录。原代码目录无需移动。若残留旧知识库托管 Hook，导入预检会要求明确确认替换；不会覆盖第三方 Hook。导入建立 HEAD 基线，不分析已有历史。
 
 如果模块是自己独立启动的旧进程，请在它原来的终端中停止后重启新版外壳。外壳不会擅自杀死其他服务；版本或运行期鉴权不一致时显示具体连接阶段，不接管旧服务数据。

package/module-runtime-manifest.json

@@ -11,9 +11,9 @@
     "plugins/project-knowledge/hooks/codex.json": "216e03c07295606ef6ebb2c4f669ad0d790b5e7c4f3f34600488033db75e4239",
     "plugins/project-knowledge/scripts/context-hook.cjs": "da666153ad5723592cce42d25337ae649f7d93e43fab76b3c6d1263933de063f",
     "plugins/project-knowledge/scripts/mcp-launcher.cjs": "7c68830b5c73eb53ef030756a4de33987f7eab6b1a6cc15602835aac3f954893",
-    "plugins/project-knowledge/.claude-plugin/plugin.json": "c4069b87a8f1364bd6732fe9ec03b581bef06c14e80f910b550ec81ef6a0f00f",
-    "plugins/project-knowledge/.codex-plugin/plugin.json": "caa287c40fe42fae5a9e2faaae3ff4e0ff7fab64a45a27bd7a1193e429a175a9",
-    "plugins/project-knowledge/.mcp.json": "01edf4f4b4fc1db43fbe59892120f15b32d38e4b1460c431a454e5a4cdff70ef"
+    "plugins/project-knowledge/.claude-plugin/plugin.json": "acdbc819e7e3949a2b8e01380f3e8811d06f74e5578cc872d736faa0db4e2106",
+    "plugins/project-knowledge/.codex-plugin/plugin.json": "915cae73db9f32bbbcf9c5aee24aca9356bf730914489c8611f734616f1e4b6c",
+    "plugins/project-knowledge/.mcp.json": "9c493221141723265d80ebff5e68029e159d1688a8bfb121678ad93bf78ff6d8"
   },
   "modules": {
     "terminal": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanqianx/project-knowledge",
-  "version": "5.0.21",
+  "version": "5.0.22",
   "description": "Knowledge base manager with Git integration, AI-driven analysis, and bilingual (zh-CN/en-US) knowledge output",
   "main": "_site/server.js",
   "scripts": {

package/plugins/project-knowledge/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "project-knowledge",
   "hooks": "./hooks/claude.json",
-  "version": "5.0.21",
+  "version": "5.0.22",
   "description": "Read durable project decisions and implementation history from Project Knowledge.",
   "author": {
     "name": "SanQianX",

package/plugins/project-knowledge/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "project-knowledge",
-  "version": "5.0.21",
+  "version": "5.0.22",
   "description": "Read durable project decisions and implementation history from Project Knowledge.",
   "author": {
     "name": "SanQianX",

package/plugins/project-knowledge/.mcp.json

@@ -8,7 +8,7 @@
         "const fs=require('fs'),path=require('path'),os=require('os');const PKG='@sanqianx/project-knowledge',SC='project-knowledge/integration-runtime/v1';let f='';const root=process.env.CLAUDE_PLUGIN_ROOT||process.env.PLUGIN_ROOT;if(root){f=path.join(root,'scripts','mcp-launcher.cjs');if(!fs.existsSync(f))f=''}if(!f){const dd=process.env.KB_DATA_DIR||path.join(os.homedir(),'.project-knowledge-v5');try{const bp=path.join(dd,'integration-runtime.json');const st=fs.statSync(bp);if(st.isFile()&&st.size<=32768){const b=JSON.parse(fs.readFileSync(bp,'utf8'));if(b&&b.schema===SC&&b.packageName===PKG&&typeof b.packageRoot==='string'&&path.isAbsolute(b.packageRoot)){const c=path.join(b.packageRoot,'plugins','project-knowledge','scripts','mcp-launcher.cjs');const rr=fs.realpathSync(b.packageRoot),cr=fs.realpathSync(c);const rel=path.relative(rr,cr);if(rel&&rel!=='..'&&!rel.startsWith('..'+path.sep)&&!path.isAbsolute(rel)&&fs.statSync(cr).isFile())f=cr}}}catch(e){}}if(!f){console.error('[project-knowledge-mcp] 未能通过受信任插件根或已验证的安装绑定定位启动器，已停止；不访问网络，也不加载工作目录源码。');process.exit(127)}require(f);"
       ],
       "env": {
-        "KB_PLUGIN_VERSION": "5.0.21"
+        "KB_PLUGIN_VERSION": "5.0.22"
       }
     }
   }