@sanqianx/project-knowledge 5.0.16 → 5.0.17-rc.2

package/_site/lib/engine-connection.js

@@ -1,9 +1,17 @@
 const { DomainError } = require('./contracts');
 const { execGit } = require('./git-runner');
 
-async function connectEngine(runtime) {
-  if (runtime.analysisOwner === 'legacy' || runtime.engineConnecting) return;
-  runtime.engineConnecting = true;
+function connectEngine(runtime) {
+  if (runtime.analysisOwner === 'legacy') return Promise.resolve();
+  if (runtime.engineConnecting) { runtime.engineReconnectRequested = true; return runtime.engineConnecting; }
+  const job = connectEngineOnce(runtime).finally(() => {
+    runtime.engineConnecting = null;
+    if (runtime.engineReconnectRequested && !runtime.engineConnectionClosed) { runtime.engineReconnectRequested = false; void connectEngine(runtime); }
+  });
+  runtime.engineConnecting = job;
+  return job;
+}
+async function connectEngineOnce(runtime) {
   let step = 'engine-health';
   let projectId = '';
   let httpStatus = 0;
@@ -21,24 +29,36 @@ async function connectEngine(runtime) {
     httpStatus = auth.status;
     if (!auth.ok) throw new Error('RUNTIME_AUTH_REQUIRED');
     bridge.engineCompatible = true;
+    if (engine.executionEnabled === false) { bridge.resetRuntimeConfiguration?.(); runtime.projectConnections?.clear(); }
     step = 'project-wiring';
-    for (const id of runtime.registryStore.listIds()) {
-      projectId = id;
+    const remote = bridge._listEngineProjects ? await bridge._listEngineProjects() : [];
+    runtime.projectConnections ||= new Map();
+    const enabled = [], pending = [];
+    let cursor = 0;
+    const ids = runtime.registryStore.listIds();
+    const wire = async () => { while (cursor < ids.length) {
+      const id = ids[cursor++];
       if (!runtime.registryStore.readDisplaySnapshot(id)) continue;
       let config;
       try { config = runtime.projectStore.readConfig(id); }
-      catch (error) { if (!runtime.registryStore.readDisplaySnapshot(id)) continue; throw error; }
+      catch { pending.push({ projectId: id, code: 'PROJECT_CONFIG_UNAVAILABLE' }); continue; }
+      const fingerprint = JSON.stringify(config);
+      if (runtime.projectConnections.get(id) === fingerprint && remote.some(p => p.projectId === id && p.repoPath === config.repoPath && p.knowledgePath === config.knowledgePath)) { enabled.push(id); continue; }
+      try {
       const modules = await bridge.registerProjectLinks({ projectId: id, name: config.displayName, workspacePath: config.repoPath, knowledgePath: config.knowledgePath });
-      if (!modules.engine.ok || !modules.eventBridge.ok) throw new Error('PROJECT_WIRING_PENDING');
-    }
+      if (!modules.engine.ok || !modules.eventBridge.ok) { pending.push({ projectId: id, code: 'PROJECT_WIRING_PENDING' }); continue; }
+      runtime.projectConnections.set(id, fingerprint); enabled.push(id);
+      } catch { pending.push({ projectId: id, code: 'PROJECT_WIRING_PENDING' }); }
+    } };
+    await Promise.all([wire(), wire()]);
     projectId = '';
     step = 'runtime-configuration';
     await bridge.syncEngineConfiguration();
     step = 'engine-activation';
-    const activated = await bridge._fetch(`${bridge.engineUrl}/api/control`, { method: 'POST', headers, body: JSON.stringify({ enabled: true }) });
+    const activated = await bridge._fetch(`${bridge.engineUrl}/api/control`, { method: 'POST', headers, body: JSON.stringify({ enabled: true, projectIds: enabled }) });
     httpStatus = activated.status;
     if (!activated.ok) throw new Error(activated.status === 403 ? 'RUNTIME_AUTH_REQUIRED' : 'ENGINE_ACTIVATION_FAILED');
-    runtime.ownership = { owner: 'engine', ready: true };
+    runtime.ownership = { owner: 'engine', ready: true, ...(pending.length ? { pendingProjects: pending, message: '部分项目接线待恢复，其他已连接项目可正常维护。' } : {}) };
   } catch (error) {
     const codes = ['ENGINE_UNAVAILABLE', 'ENGINE_VERSION_MISMATCH', 'PROJECT_WIRING_PENDING', 'RUNTIME_AUTH_REQUIRED', 'ENGINE_ACTIVATION_FAILED'];
     const code = codes.includes(error.message) ? error.message : 'ENGINE_CONNECTION_FAILED';
@@ -52,7 +72,7 @@ async function connectEngine(runtime) {
     const previous = runtime.ownership?.error;
     runtime.ownership = { owner: 'engine', ready: false, message, error: { code, step, httpStatus, ...(projectId ? { projectId } : {}) } };
     if (previous?.code !== code || previous?.step !== step || (previous?.projectId || '') !== projectId) await runtime.logger.warn('engine.connection_pending', message, { component: 'engine-connection', phase: step, projectId, context: { code, httpStatus } });
-  } finally { runtime.engineConnecting = false; }
+  }
 }
 
 async function forwardCommitToBridge(runtime, event) {

package/_site/lib/live-gateway.js

@@ -0,0 +1,76 @@
+'use strict';
+const { WebSocketServer } = require('ws');
+const { TextDecoder } = require('node:util');
+
+function attachLiveGateway(server, runtime) {
+  const wss = new WebSocketServer({ noServer: true, maxPayload: 8192 });
+  function target(route) {
+    const url = new URL(route, 'http://local');
+    if (url.origin !== 'http://local' || !route.startsWith('/') || route.length > 2048) throw new Error('INVALID_ROUTE');
+    if ([...url.searchParams.keys()].some(k => !['after', 'projectId', 'level', 'component', 'event', 'q', 'operationId', 'runId', 'commitSha', 'limit', 'summary', 'jobId', 'since', 'streamCursor'].includes(k))) throw new Error('INVALID_QUERY');
+    const bridge = runtime.moduleBridge;
+    if (url.pathname === '/api/engine/progress') {
+      if (bridge.engineCompatible === false) throw new Error('ENGINE_CONNECTION_PENDING');
+      return `${bridge.engineUrl}/api/progress${url.search}`;
+    }
+    if (/^\/api\/terminal\/sessions\/[a-zA-Z0-9_-]+\/events$/.test(url.pathname)) return bridge._terminalApi(url.pathname) + url.search;
+    if (url.pathname === '/api/logs/stream') return `http://${runtime.liveAddress}${route}`;
+    throw new Error('INVALID_ROUTE');
+  }
+  server.on('upgrade', (req, socket, head) => {
+    const local = ['127.0.0.1', '::1', '::ffff:127.0.0.1'].includes(req.socket.remoteAddress);
+    let hostname; try { hostname = new URL(`http://${req.headers.host}`).hostname; } catch { socket.destroy(); return; }
+    if (req.url !== '/api/live' || !local || !['127.0.0.1', 'localhost', '[::1]'].includes(hostname) || req.headers.origin !== `http://${req.headers.host}`) { socket.destroy(); return; }
+    wss.handleUpgrade(req, socket, head, ws => wss.emit('connection', ws));
+  });
+  wss.on('connection', ws => {
+    const subscriptions = new Map();
+    const send = payload => {
+      if (ws.readyState !== 1) return;
+      if (ws.bufferedAmount > 1024 * 1024) { ws.close(1013, 'slow consumer'); return; }
+      ws.send(JSON.stringify(payload));
+    };
+    const stop = id => { subscriptions.get(id)?.abort(); subscriptions.delete(id); };
+    ws.on('message', async bytes => {
+      let message, controller;
+      try {
+        message = JSON.parse(String(bytes));
+        if (typeof message?.id !== 'string' || !/^[a-zA-Z0-9_-]{1,80}$/.test(message.id)) throw new Error('INVALID_SUBSCRIPTION');
+        if (message.type === 'unsubscribe') { stop(message.id); return; }
+        if (message.type !== 'subscribe' || subscriptions.size >= 8) throw new Error('INVALID_SUBSCRIPTION');
+        const url = target(message.route); stop(message.id);
+        controller = new AbortController(); subscriptions.set(message.id, controller);
+        const deadline = setTimeout(() => controller.abort(), 3000);
+        let upstream;
+        try { upstream = await fetch(url, { signal: controller.signal, headers: message.after ? { 'Last-Event-ID': String(message.after).slice(0, 128) } : {} }); }
+        finally { clearTimeout(deadline); }
+        if (!upstream.ok || !upstream.headers.get('content-type')?.includes('text/event-stream')) throw new Error('UPSTREAM_UNAVAILABLE');
+        send({ id: message.id, type: 'open' });
+        const decoder = new TextDecoder(); let buffer = '';
+        for await (const chunk of upstream.body) {
+          buffer += decoder.decode(chunk, { stream: true });
+          if (buffer.length > 2 * 1024 * 1024) throw new Error('EVENT_TOO_LARGE');
+          let boundary;
+          while ((boundary = /\r?\n\r?\n/.exec(buffer))) {
+            const block = buffer.slice(0, boundary.index); buffer = buffer.slice(boundary.index + boundary[0].length);
+            let event = 'message', data = [], cursor;
+            for (const line of block.split(/\r?\n/)) {
+              const colon = line.indexOf(':'), key = colon < 0 ? line : line.slice(0, colon), value = colon < 0 ? '' : line.slice(colon + 1).replace(/^ /, '');
+              if (key === 'event') event = value; else if (key === 'data') data.push(value); else if (key === 'id') cursor = value;
+            }
+            if (data.length && subscriptions.get(message.id) === controller) send({ type: 'event', id: message.id, event, data: data.join('\n'), cursor });
+          }
+        }
+        if (!controller.signal.aborted) throw new Error('UPSTREAM_CLOSED');
+      } catch {
+        if (controller) { if (subscriptions.get(message.id) === controller) { stop(message.id); send({ type: 'error', id: message.id, code: 'STREAM_UNAVAILABLE' }); } }
+        else send({ type: 'error', id: message?.id, code: 'INVALID_SUBSCRIPTION' });
+      }
+    });
+    const heartbeat = setInterval(() => { if (ws.isAlive === false) return ws.terminate(); ws.isAlive = false; ws.ping(); }, 30000);
+    ws.on('pong', () => { ws.isAlive = true; });
+    ws.on('close', () => { clearInterval(heartbeat); for (const id of subscriptions.keys()) stop(id); });
+  });
+  return { close() { for (const ws of wss.clients) ws.terminate(); wss.close(); } };
+}
+module.exports = { attachLiveGateway };

package/_site/lib/module-bridge.js

@@ -218,7 +218,7 @@ class ModuleBridge {
 
   async _listTerminalProjects() {
     try {
-      const response = await this._fetch(`${this.terminalUrl}/api/claude-workbench/v1/projects`);
+      const response = await this._fetch(`${this.terminalUrl}/api/claude-workbench/v1/projects`, { timeoutMs: 2500 });
       if (!response.ok) return [];
       const payload = await response.json();
       const list = Array.isArray(payload) ? payload : payload.projects;
@@ -228,7 +228,7 @@ class ModuleBridge {
 
   async _listVectorHubProjects() {
     try {
-      const response = await this._fetch(`${this.vectorHubUrl}/api/projects`);
+      const response = await this._fetch(`${this.vectorHubUrl}/api/projects`, { timeoutMs: 2500 });
       if (!response.ok) return [];
       const payload = await response.json();
       return Array.isArray(payload.projects) ? payload.projects : [];
@@ -237,7 +237,7 @@ class ModuleBridge {
 
   async _listEventBridgeProjects() {
     try {
-      const response = await this._fetch(`${this.eventBridgeUrl}/api/projects`);
+      const response = await this._fetch(`${this.eventBridgeUrl}/api/projects`, { timeoutMs: 2500 });
       if (!response.ok) return [];
       const payload = await response.json();
       return Array.isArray(payload.projects) ? payload.projects : [];
@@ -247,7 +247,7 @@ class ModuleBridge {
   async _listEngineProjects() {
     if (this.engineCompatible === false) return [];
     try {
-      const response = await this._fetch(`${this.engineUrl}/api/projects`);
+      const response = await this._fetch(`${this.engineUrl}/api/projects`, { timeoutMs: 2500 });
       if (!response.ok) return [];
       const payload = await response.json();
       return Array.isArray(payload.projects) ? payload.projects : [];
@@ -256,6 +256,7 @@ class ModuleBridge {
 
   /** Aggregated projection for the shell sidebar: pkb registry is the spine. */
   async aggregatedProjects() {
+    const healthJob = this.modulesHealth();
     const [terminalProjects, vectorHubProjects, eventBridgeProjects, engineProjects] = await Promise.all([
       this._listTerminalProjects(),
       this._listVectorHubProjects(),
@@ -295,12 +296,10 @@ class ModuleBridge {
         },
       };
     });
+    const health = (await healthJob).modules;
     return {
       projects,
-      terminalAvailable: terminalProjects.length > 0 || await this._probe(this.terminalUrl),
-      vectorHubAvailable: vectorHubProjects.length > 0 || await this._probe(this.vectorHubUrl),
-      eventBridgeAvailable: eventBridgeProjects.length > 0 || await this._probe(this.eventBridgeUrl),
-      engineAvailable: engineProjects.length > 0 || await this._probe(this.engineUrl),
+      terminalAvailable: health.terminal.up, vectorHubAvailable: health.vectorHub.up, eventBridgeAvailable: health.eventBridge.up, engineAvailable: health.engine.up,
     };
   }
 
@@ -324,14 +323,39 @@ class ModuleBridge {
     } };
   }
 
-  syncEngineConfiguration() {
-    if (this.configSyncPromise) return this.configSyncPromise.catch(() => undefined).then(() => this.syncEngineConfiguration());
-    const pending = this._syncEngineConfiguration().finally(() => { if (this.configSyncPromise === pending) this.configSyncPromise = null; });
+  syncEngineConfiguration({ force = false } = {}) {
+    const signature = () => { try { return crypto.createHash('sha256').update(JSON.stringify(this.settingsStore?.read() || {})).digest('hex'); } catch { return ''; } };
+    if (this.configSyncPromise) {
+      if (force || signature() !== this.configSyncSettings) this.configSyncDirty = true;
+      return this.configSyncPromise;
+    }
+    const pending = (async () => {
+      let result;
+      do { this.configSyncDirty = false; this.configSyncSettings = signature(); result = await this._syncEngineConfiguration(); } while (this.configSyncDirty && !this.stopped);
+      return result;
+    })().finally(() => { if (this.configSyncPromise === pending) this.configSyncPromise = null; });
     this.configSyncPromise = pending;
     return pending;
   }
 
+  resetRuntimeConfiguration() {
+    this.configFingerprints = {};
+    this.configGeneration = (this.configGeneration || 0) + 1;
+    if (this.configSyncPromise) this.configSyncDirty = true;
+  }
+
   async _syncEngineConfiguration() {
+    const applyConfiguration = async (key, url, body) => {
+      this.configFingerprints ||= {};
+      const generation = this.configGeneration;
+      const fingerprint = crypto.createHash('sha256').update(JSON.stringify(body)).digest('hex');
+      if (this.configFingerprints[key]?.fingerprint === fingerprint) return this.configFingerprints[key].result;
+      const response = await this._fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${this.runtimeToken}` }, body: JSON.stringify(body) });
+      const result = { ok: response.ok, data: response.ok ? await response.json().catch(() => ({})) : null };
+      if (result.ok && this.configGeneration === generation) this.configFingerprints[key] = { fingerprint, result };
+      else delete this.configFingerprints[key];
+      return result;
+    };
     const dataDir = this.dataDir || require('./data-dir').getDataDir();
     let indexPath = null;
     try { indexPath = new StorageLayout({ dataDir }).getVectorRootPath(this.settingsStore?.read()); }
@@ -344,7 +368,7 @@ class ModuleBridge {
         if (settings.knowledge.rootPath) {
           const brain = settings.brain;
           const root = path.join(settings.knowledge.rootPath, '_shared');
-          const response = await this._fetch(`${this.engineUrl}/api/snapshot`);
+          const response = await this._fetch(`${this.engineUrl}/api/snapshot?summary=1&limit=1`);
           if (!response.ok) throw new DomainError('ENGINE_UNAVAILABLE', '共享知识接线暂时不可用。');
           const prior = (await response.json()).sharedScopes || [];
           // Root settings govern new directories and derived indexes, never move
@@ -355,7 +379,7 @@ class ModuleBridge {
             return item.knowledgePath || existing?.knowledgePath || path.join(root, item.id);
           };
           const scopes = [{ id: brain.id, kind: 'brain', brainId: brain.id, name: brain.name, knowledgePath: binding(brain, 'brain') }, ...brain.domains.map(d => ({ id: d.id, kind: 'domain', brainId: brain.id, domainId: d.id, name: d.name, knowledgePath: binding(d, 'domain') }))];
-          const applied = await this._fetch(`${this.engineUrl}/api/scopes`, { method: 'POST', headers, body: JSON.stringify({ scopes }) });
+          const applied = await applyConfiguration('scopes', `${this.engineUrl}/api/scopes`, { scopes });
           if (!applied.ok) throw new DomainError('SHARED_SCOPE_APPLY_FAILED', '共享目录接线未完成。');
           await this.settingsStore.bindSharedKnowledgePaths?.(scopes);
           status.scopes = true; status.scopeStatus = { status: 'ready' };
@@ -372,7 +396,7 @@ class ModuleBridge {
         const response = await this._fetch(`${this.terminalUrl}/api/claude-workbench/v1/internal/maintenance-config`, { method: 'POST', headers, body: '{}' });
         if (response.ok) profile = await response.json();
       } catch { /* Missing configuration must clear a previously resolved key. */ }
-      const response = await this._fetch(`${this.engineUrl}/api/runtime-config`, { method: 'POST', headers, body: JSON.stringify({ projectId: 'default', profile }) });
+      const response = await applyConfiguration('model', `${this.engineUrl}/api/runtime-config`, { projectId: 'default', profile });
       status.model = response.ok && !!profile;
     } catch { /* Status projection only: never log resolved profiles or raw errors. */ }
     try {
@@ -381,10 +405,10 @@ class ModuleBridge {
         const resolved = await this._fetch(`${this.terminalUrl}/api/claude-workbench/v1/internal/embedding-config`, { method: 'POST', headers, body: '{}' });
         if (resolved.ok) settings = await resolved.json();
       } catch { /* Revocation wins over a previously cached runtime key. */ }
-      const applied = await this._fetch(`${this.vectorHubUrl}/api/internal/runtime-config`, { method: 'POST', headers, body: JSON.stringify({ settings, ...(indexPath ? { storageRoot: indexPath } : {}) }) });
+      const applied = await applyConfiguration('embedding', `${this.vectorHubUrl}/api/internal/runtime-config`, { settings, ...(indexPath ? { storageRoot: indexPath } : {}) });
       status.embedding = applied.ok && !!settings;
       if (applied.ok) {
-        const result = await applied.json();
+        const result = applied.data;
         status.indexStorage.actualPath = result.rootPath || null;
         status.indexStorage.status = result.rootPath && path.resolve(result.rootPath) === indexPath ? 'ready' : 'pending';
       }
@@ -593,13 +617,13 @@ class ModuleBridge {
    */
   async startSupervised() {
     if (String(process.env.KB_MODULES_AUTOSTART || '') === '0') return;
-    for (const spec of this._supervisedSpecs()) {
+    await Promise.all(this._supervisedSpecs().map(async spec => {
       if (await this._probe(spec.url)) {
         this.logger.info('modules.supervisor', 'Module service already up; not spawning.', { context: { name: spec.name, url: spec.url } });
-        continue;
+        this.onReady?.(spec.name); return;
       }
       this._spawnSupervised(spec);
-    }
+    }));
   }
 
   _supervisedSpecs() {
@@ -713,6 +737,14 @@ class ModuleBridge {
     });
     this.supervised.push(child);
     this.logger.info('modules.supervisor', 'Module service spawned.', { context: { name: spec.name, pid: child.pid } });
+    let attemptsReady = 0;
+    const checkReady = async () => {
+      if (this.stopped || child.exitCode !== null || ++attemptsReady > 20) return;
+      if (await this._probe(spec.url)) { this.resetRuntimeConfiguration(); this.onReady?.(spec.name); return; }
+      const timer = setTimeout(() => { this.restartTimers.delete(timer); checkReady(); }, 500);
+      this.restartTimers ||= new Set(); this.restartTimers.add(timer);
+    };
+    void checkReady();
   }
 
   async stopSupervised() {

package/_site/lib/server-app.js

@@ -916,8 +916,10 @@ function createRequestHandler(runtime, options = {}) {
       }
       if (method === 'POST' && pathname === '/api/modules/configure') {
         await readJsonBody(req);
+        runtime.moduleBridge.resetRuntimeConfiguration();
+        runtime.projectConnections?.clear();
         await connectEngine(runtime);
-        return send(res, 200, { ok: true, configuration: await runtime.moduleBridge.syncEngineConfiguration() });
+        return send(res, 200, { ok: true, configuration: await runtime.moduleBridge.syncEngineConfiguration({ force: true }) });
       }
       if (method === 'GET' && pathname === '/api/brain') {
         const settings = runtime.settingsStore.read();
@@ -986,6 +988,7 @@ function createRequestHandler(runtime, options = {}) {
         return send(res, 200, { ok: true, settings: { ...settings, ai: publicAiProfilesConfig(settings.ai) }, configuration });
       }
 
+      if (method === 'GET' && pathname === '/api/projects/projection') return send(res, 200, { ok: true, projects: listProjectViews(runtime.registryStore, runtime.projectStore).map(p => ({ projectId: p.projectId, name: p.config.displayName, workspacePath: p.config.repoPath, knowledgePath: p.config.knowledgePath, brainId: p.config.brainId, domainId: p.config.domainId, modules: Object.fromEntries(['terminal', 'vectorHub', 'eventBridge', 'engine'].map(key => { const module = p.state.modules?.[key] || {}; return [key, { projectId: module.projectId, projectName: module.projectName, status: module.status, registered: module.ok === true && module.status === 'registered' }]; })) })) });
       if (method === 'GET' && pathname === '/api/projects') return send(res, 200, { ok: true, projects: listProjectViews(runtime.registryStore, runtime.projectStore) });
       // T06: pure preflight endpoint — never mutates state. The UI calls
       // this on path pick / language change / profile change to keep the
@@ -1011,6 +1014,7 @@ function createRequestHandler(runtime, options = {}) {
           workspacePath: String(config.repoPath || body.path || ''),
           knowledgePath: String(body.knowledgePath || config.knowledgePath || ''),
         });
+        void connectEngine(runtime);
         return send(res, 201, { ...result, modules: moduleResult, project: projectPublicView(result.projectId, runtime.projectStore) });
       }
       const projectMatch = pathname.match(/^\/api\/projects\/([^/]+)$/);
@@ -1486,6 +1490,8 @@ async function startServer(options = {}) {
     startup = await initializeRuntime(runtime);
     const handler = createRequestHandler(runtime, { ...options, port, host });
     server = http.createServer(handler);
+    runtime.liveGateway = require('./live-gateway').attachLiveGateway(server, runtime);
+    runtime.liveAddress = `${host}:${port}`;
     await new Promise((resolve, reject) => {
       server.once('error', reject);
       server.listen(port, host, resolve);
@@ -1513,7 +1519,8 @@ async function startServer(options = {}) {
   maintenanceTimer.unref?.();
   const configurationTimer = setInterval(() => { connectEngine(runtime).catch(() => {}); }, 30000);
   configurationTimer.unref?.();
-  runtime.moduleBridge.syncEngineConfiguration().catch(() => {});
+  let readyTimer;
+  runtime.moduleBridge.onReady = () => { clearTimeout(readyTimer); readyTimer = setTimeout(() => { runtime.projectConnections?.clear(); connectEngine(runtime).catch(() => {}); }, 100); };
   connectEngine(runtime).catch(() => {});
 
   // T3.5 进程编排：拉起包内自带的模块服务并守护（默认开启，KB_MODULES_AUTOSTART=0 关闭）
@@ -1532,6 +1539,9 @@ async function startServer(options = {}) {
       runtime.integrationStatusScan?.close();
       clearInterval(maintenanceTimer);
       clearInterval(configurationTimer);
+      clearTimeout(readyTimer); runtime.moduleBridge.onReady = null;
+      runtime.engineConnectionClosed = true;
+      runtime.liveGateway?.close();
       await runtime.logger.info('server.shutdown_started', 'Server shutdown started.', { phase: 'shutdown', context: { reason } });
       const forceConnections = setTimeout(() => server.closeAllConnections?.(), Number(process.env.KB_SERVER_CLOSE_GRACE_MS || 2000));
       await new Promise(resolve => server.close(resolve));

package/_site/scripts/pack-module-candidates.js

@@ -53,7 +53,7 @@ function pack(sources) {
     process.stdout.write(`Packed ${key} ${pkg.version}: ${result.files.length} files\n`);
   }
   const manifestPath = path.join(output, 'module-candidates.json'); AtomicFile.writeJsonAtomic(manifestPath, manifest);
-  const productFiles = Object.fromEntries(['ui/index.html', 'ui/product.js', 'ui/product.css', 'ui/favicon.svg'].map(file => [file, hash(fs.readFileSync(path.join(root, file)))]));
+  const productFiles = Object.fromEntries(['ui/index.html', 'ui/product.js', 'ui/live-client.js', 'ui/product.css', 'ui/favicon.svg'].map(file => [file, hash(fs.readFileSync(path.join(root, file)))]));
   AtomicFile.writeJsonAtomic(path.join(root, 'module-runtime-manifest.json'), { schema: 'project-knowledge/module-content/v1', productFiles, modules: Object.fromEntries(Object.entries(manifest.modules).map(([key, module]) => [key, { name: module.name, installName: module.installName, version: module.version, files: module.files }])) });
   process.stdout.write(`MODULE_CANDIDATES ${manifestPath}\n`);
   return manifestPath;

package/_site/scripts/sync-product-content.js

@@ -3,6 +3,7 @@ const fs = require('node:fs');
 const path = require('node:path');
 const crypto = require('node:crypto');
 const { createRequire } = require('node:module');
+const { execFileSync } = require('node:child_process');
 const { safeRelative } = require('./pack-module-candidates');
 const AtomicFile = require('../lib/atomic-file');
 const root = path.resolve(__dirname, '../..');
@@ -18,8 +19,10 @@ for (const module of Object.values(manifest.modules)) {
   const expected = pkg.dependencies[module.installName];
   if (installed.name !== module.name || ![installed.version, `npm:${installed.name}@${installed.version}`].includes(expected)) throw new Error('Install the exact registry module version before content synchronization.');
   module.version = installed.version;
-  for (const relative of Object.keys(module.files)) { if (!safeRelative(relative)) throw new Error('Unsafe content path'); const target = path.join(directory, relative); if (fs.lstatSync(target).isSymbolicLink()) throw new Error('Unsafe content symlink'); module.files[relative] = digest(target); }
+  const npmCli = process.env.npm_execpath || path.join(path.dirname(process.execPath), 'node_modules/npm/bin/npm-cli.js');
+  const packed = JSON.parse(execFileSync(process.execPath, [npmCli, 'pack', '--dry-run', '--ignore-scripts', '--json'], { cwd: directory, windowsHide: true, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 }))[0];
+  module.files = Object.fromEntries(packed.files.map(entry => { const relative = entry.path; if (!safeRelative(relative)) throw new Error('Unsafe content path'); const target = path.join(directory, relative); if (fs.lstatSync(target).isSymbolicLink()) throw new Error('Unsafe content symlink'); return [relative, digest(target)]; }));
 }
-for (const relative of ['ui/index.html', 'ui/product.js', 'ui/product.css', 'ui/favicon.svg', 'plugins/project-knowledge/hooks/claude.json', 'plugins/project-knowledge/hooks/codex.json', 'plugins/project-knowledge/scripts/context-hook.cjs', 'plugins/project-knowledge/scripts/mcp-launcher.cjs', 'plugins/project-knowledge/.claude-plugin/plugin.json', 'plugins/project-knowledge/.codex-plugin/plugin.json', 'plugins/project-knowledge/.mcp.json']) manifest.productFiles[relative] = digest(path.join(root, relative));
+for (const relative of ['ui/index.html', 'ui/product.js', 'ui/live-client.js', 'ui/product.css', 'ui/favicon.svg', 'plugins/project-knowledge/hooks/claude.json', 'plugins/project-knowledge/hooks/codex.json', 'plugins/project-knowledge/scripts/context-hook.cjs', 'plugins/project-knowledge/scripts/mcp-launcher.cjs', 'plugins/project-knowledge/.claude-plugin/plugin.json', 'plugins/project-knowledge/.codex-plugin/plugin.json', 'plugins/project-knowledge/.mcp.json']) manifest.productFiles[relative] = digest(path.join(root, relative));
 AtomicFile.writeJsonAtomic(file, manifest);
 console.log('Updated content hashes from exact installed modules and reviewed product assets; this is not release acceptance.');

package/_site/scripts/verify-product-runtime.js

@@ -9,6 +9,7 @@ function verifyProductRuntime(coreRoot, resolveFrom = path.join(coreRoot, 'packa
   if (manifest.schema !== 'project-knowledge/module-content/v1' || Object.keys(manifest.modules).length !== 3) throw new Error('Incomplete module content manifest');
   for (const file of ['ui/index.html', 'ui/product.js', 'ui/product.css', 'ui/favicon.svg', 'plugins/project-knowledge/hooks/claude.json', 'plugins/project-knowledge/hooks/codex.json', 'plugins/project-knowledge/scripts/context-hook.cjs', 'plugins/project-knowledge/scripts/mcp-launcher.cjs', 'plugins/project-knowledge/.claude-plugin/plugin.json', 'plugins/project-knowledge/.codex-plugin/plugin.json', 'plugins/project-knowledge/.mcp.json']) if (!manifest.productFiles?.[file]) throw new Error(`Product asset missing from content manifest: ${file}`);
   const resolve = createRequire(resolveFrom);
+  if (!manifest.productFiles['ui/live-client.js']) throw new Error('Product live transport missing from content manifest');
   for (const [relative, expected] of Object.entries(manifest.productFiles || {})) {
     if (!safeRelative(relative) || crypto.createHash('sha256').update(fs.readFileSync(path.join(coreRoot, relative))).digest('hex') !== expected) throw new Error(`Product UI content mismatch: ${relative}`);
   }

package/docs/leader-glm-workbench-playbook.md

@@ -86,6 +86,12 @@ Leader 独立复测关键链路。源码、npm 候选、正式安装和真实模
 
 安装、配置修复、重启和发布需单独的操作合同及受保护备份。候选只发布 `next`；正式包验收通过后才更新 `latest`。用户仍须亲自审查确实变化的原生 Hook，不写入或绕过信任。
 
+正式包也必须使用自己的全新 npm 收据和隔离配置；复用已付费向量不等于复用旧插件市场。若手工传错 fixture，外层设置了新收据也不能替旧版本背书，先核对环境文件的实际包路径和版本，错误采样明确作废。对话中的独立审查结果不替代 Leader 读取真实事件、文件与工具结果。
+
+提交标识查询可能合法返回 `markdown-hybrid-fallback`：它只说明返回行未采用向量通道，不应以一个后端标签否认实际检索。验收须结构化匹配项目、完整提交、服务来源、成功 tool-id 和写前顺序，并独立检查真实非空向量和语义查询；不能把文本命中当向量成功。模型注释中的正常换行也不应被误判为缺少 SHA，需保留稳定反例与复测。
+
+Windows 的 npm 全局更新还需确认独立 MCP 客户端已释放原生库。主服务停止不代表 IDE 自己启动的 MCP 子进程已退出。本轮通过进程模块只读检查定位到本会话的本产品 MCP，而非批量终止 Node；校验精确入口、父进程和 DLL 后仅关闭该子进程，再重做完整保真升级。不能据此终止来源不明或被安全检查禁止停止的旧实例。启动后等待四模块及引擎 API 就绪，不把网页端口在线当作所有功能就绪。
+
 临时工作树不得通过目录联接共用需要保留的 `node_modules` 后直接递归清理。本轮清理带联接的工作树后，主源码依赖目录为空；因此清理前必须枚举链接、核对真实目标并先安全解除联接本身，不能让递归操作越出临时目录。依赖恢复按原锁文件执行，保留首失败，不以恢复后的结果覆盖环境事故。
 
 ## 验收记录
@@ -99,3 +105,15 @@ Leader 独立复测关键链路。源码、npm 候选、正式安装和真实模
 - 原生 Hook 是否需要再次审核取决于实际定义哈希，不由版本号猜测。rc.6 审核后 rc.8 的哈希未变、原生仍为 trusted；确实变化才请求用户审核，不绕过信任。
 
 本轮的会话、提交、源码回归、npm 下载和真实维护结果见 [5.0.16 验收记录](release-5.0.16-acceptance.md)。操作手册与版本放行结果分开维护。
+
+## 网页响应性与历史修复（2026-10-15）
+
+本批继续采用 Leader 关键开发、真实 GLM-5.3 独立故障审查：Workbench `sess-8155764fec1e`，外壳 `sess-68d4d397c7f5`。GLM 只写指定测试和审查报告，不改生产实现、不发布、不改用户配置。Leader 独立复测测试文件与真实安装包，不将报告摘要当作成功凭证。
+
+- 缓存 TTL 的确定性测试使用注入时钟；20ms 真实时间在完整回归负载下会过期，不应靠增大等待掩盖测试竞态。
+- 原生 SDK 已发出最终 result，不代表异步迭代器必定立即 EOF。旧工作台的独立审查会话曾在最终报告后仍显示 running；Leader 核对报告完整后显式中止清理。新实现以 result 为本轮边界并在 finally 关闭自己的 query，另用真实 npm 工作台任务验证自然 idle，不能只补假流单测。
+- 浏览器滚动默认动作是异步的；滚轮后同一时刻读取 scrollTop 可能仍为旧值。要同时验证向上意图、后续内容增长和稳定阅读位置，不能只取输入后的单帧。
+- 新增异步发现后要审查诊断与 runtime 旁路，确保没有保留同步命令查找，也不能为了消除阻塞而丢掉注册表安装路径。
+- 多标签连接测试使用八个真实浏览器标签页；Node WebSocket 测试只证明协议行为，不能代替浏览器同源连接限制的验收。
+
+本批完整记录见 [5.0.17 验收记录](release-5.0.17-acceptance.md)。

package/docs/release-5.0.16-acceptance.md

@@ -2,7 +2,36 @@
 
 ## 当前结论
 
-`5.0.16-rc.8` 的 30/30 核心门禁及二次开发闭环已通过，现冻结正式包 `5.0.16`，仅发布 next 后重新下载验收；正式包尚未验收，不更新 latest（仍为 5.0.14）。保留 rc.6／rc.7 首失败，不用候选通过冒充正式通过。
+正式 `5.0.16` 已通过官方独立下载、30/30 核心门禁、真实二次开发闭环、本机保留数据升级及日常 latest 重装。npm 的 latest 与 next 均为 5.0.16，本机也运行正式 npm 包；保留候选与正式包首失败，不用候选通过冒充正式通过。
+
+### 正式包验收
+
+官方收据：`kb-registry-product-9bwo5b/registry-installation.json`，sourceCommit `3a2740b6467b8d26fa05cb494c85e396132b136b`。主包 integrity 为 `sha512-VztZ6sJAg6Th0B+Rn4prfjfIfyG6JxNFe/sEUIe2++xI5niP7+q1icqWplLMf3R48Ix554PWh0yKc8e7TgET6g==`；精确模块版本与下方 rc.8 表一致。正式包与候选的收据、运行结果分别绑定，未将旧同名报告计入正式通过。
+
+| 范围 | 正式包证据与结果 |
+|---|---|
+| 源码 | 冻结外壳 3a2740b 在 Node 22/24 各 139/139；引擎测试辅助代码最终 f1248a6 各 182 通过、1 项 Windows 符号链接权限跳过，40 个发布运行文件与 vendored 7c6812f 完全相同；其余模块使用精确版本、精确提交的源码回归 |
+| 安装版与故障 | GLM-5.3 独立运行 Node 22/24 正常网页、一次 profiles 503 恢复、故障与生命周期八项，全部通过；测试替身仅用于确定性故障，不冒称真实模型 |
+| 真模型十项 | `scoped-memories/run-1792038371463/report.json`，fixture fcKCDT，真实 MiniMax 候选提取、分级确认编辑、范围隔离、UI/API/CLI/MCP、流式、单提交与跨项目重叠、重启保真 10/10 |
+| 质量与性能 | 20 条固定留出问题 Recall@5=1、MRR=0.9667、拒答准确率=1；8 项目/1000 文档热查询 P95=699.9054ms，四次真实查询 embedding，1536 维非空索引；复用付费文档向量，无重建冒充 |
+| 原生送达 | Claude Code、ZCode 真实用户配置通过；Codex Hook 原生 trusted、MCP 实际 initialize 为 5.0.16，首次真实 MiniMax 请求含当前事实及已确认产品记忆；OpenCode 实际 CLI 检索与引用通过，不宣称自动前置注入 |
+| 工作台 | 真实网页发送、增量流式、最终持久化和右侧引用通过；回答实际引用单写者英文原文及完整提交，不只验证 SHA。1920×1080 截图已人工核对 |
+| 连续开发 | `retrieval-formal-live-development24-1792038616093.json`：分析期间再提交、保留未提交草稿、同项目 FIFO、三次真实自动维护与页面自动刷新通过 |
+| 二次开发 | `retrieval-formal-secondary24-1792039028998.json`：原任务真实 search/get 先于 Write，代码及测试通过，随后真实 Hook、冻结对话、晋升、索引、再次检索通过；恢复验收未手工改写原任务文件、引用或事件 |
+| 本机保真升级 | `retrieval-formal-user-upgrade24-1792039474426.json`，备份 `user-upgrade-1792039475645`；原 7 项目、知识、历史、配置和记忆保留，593 个索引文件字节不变，实际位置仍为 `D:\SanQian.Xu\knowledge\.indexes`；全局运行文件与官方收据逐文件相同 |
+| 本机接线 | 正式全局安装后的公开接线操作 `op-69195d8fbbc84e49b54875134ed2727f` 四客户端完成；临时验收目录的市场来源及运行绑定已切回全局 npm 包，第三方 Hook、通知和用户原生信任保留 |
+| 真实用户环境 | `retrieval-formal-user-native24-1792039600245.json`：在实际 knowledge-engine 仓库、实际用户插件下，未提醒检索的普通只读任务，其首次真实模型请求收到本项目知识；工作树不变，不以受控 fixture 代替此项 |
+| 日常 latest 安装 | `retrieval-formal-user-latest24-1792039770873.json`，详细记录 `daily-latest-1792039770931/result.json`：真实 stop、npm 官方 @latest 全局安装、版本检查、启动、受管进程退出、四模块恢复、原有数据与 593 个索引文件保真、官方包逐字节核对均通过，耗时 62.4 秒 |
+
+正式核心汇总为 `knowledge-engine/.agent-state/acceptance/system-regression/retrieval-release-5.0.16.json`。30/30 与本机升级、日常安装、真实用户补验分别记录，不互相冒充。最终交付回执为同目录 `retrieval-system-5.0.16-final.json`，还会核对本说明提交后的实际自动维护、知识文件、索引和再次检索，以及 daily 重启后的真实原生读取。
+
+#### 正式阶段保留的首失败
+
+- 离线插件案例首次复用 rc.8 的隔离市场目录，因与正式包来源路径不同被保护逻辑拒绝；改用本轮全新 fcKCDT 隔离目录后，真实 Claude CLI 在 GitHub 不通条件下安装与幂等检查通过。一次 Leader 手工补验误指旧 rc.5 fixture（1792038460071）不计正式证据，正确正式补验为 1792038543299。
+- 二次开发首失败 1792038714956：实际 seq18 查询、21 成功返回、108/111 get 成功、139 才 Write；旧测试错误要求 SHA 查询必须带向量命中标签，且不能解析跨 `//` 注释换行的完整 SHA。结构化项目/来源/完整提交/匹配 tool-id/写前顺序校验及解析回归已补齐，文本事实不冒称向量成功。原任务同文件恢复后通过，未重造原成功记录。重复无活动子进程的 teardown 也有独立回归，不能借此放行真正被中断的任务。修复仅在测试辅助代码（3eb54b4、f1248a6），未改正式包运行文件；GLM 独立复核 10 项定向测试通过。
+- 本机首次 npm 升级 1792039147807 失败为 Windows `EBUSY`：本会话独立 MCP 子进程持有全局包的 LanceDB 原生文件。只在校验精确命令路径、父进程及 DLL 后关闭本产品 MCP 子进程，未关闭 Codex 应用或无关 Node；旧包逐文件完整性通过后恢复旧服务，再重做受保护升级。冷启动时两次过早读取引擎 API 的失败也保留；重试前已等待四模块归属及引擎 API 真正就绪。
+
+Windows 日常 npm 更新前应先断开仍连接本产品 MCP 的编程会话；`stop` 管理主服务及其子进程，不意味着独立 IDE 的 MCP 连接已经关闭。遇到 EBUSY 不清空数据、不删除原生文件、不批量结束 Node。另一台电脑及其私有语料、本轮未操作的原生目录弹窗、不具备权限的 Windows 符号链接场景不计为自动通过。
 
 ### rc.8 候选验收
 

package/docs/release-5.0.17-acceptance.md

@@ -0,0 +1,74 @@
+# 5.0.17 网页加载、刷新与完整历史验收
+
+## 发布状态
+
+2026-10-15：候选验收和最终复核进行中，正式 `latest` 仍为 `5.0.16`。本文件不得被解读为正式版已发布。Electron、Windows 安装包和窄屏矩阵均不在本次范围；用户报告故障的另一台电脑尚需更新后回验。
+
+## 交付范围
+
+- 首屏按区域独立加载、普通读取 3 秒超时，失败保留已有有效数据。
+- Agent 异步扫描最多两个并发，单探测 5 秒、整次 12 秒，手动刷新绕过缓存。
+- 嵌入工作台只初始化一次，切页、项目和重连通过已有消息/快照恢复，不重设 iframe 地址。
+- 每标签一个同源 WebSocket，合并工作台、引擎及日志；独立模块保留 SSE。
+- 引擎服务归属与项目接线分离，失败项目独立恢复；未完成安全接线的项目不执行写入。
+- 运行摘要分页，完整提交证据延迟读取；配置指纹合并下发并防止模块重启后的迟到回执污染缓存。
+- 工作中向上滚动立即暂停跟随；新增持久化完整会话历史与向前分页，旧 Claude 原生历史尽可能只读恢复。
+
+旧会话若从未持久化且原生文件已经不存在，不能凭空恢复；页面明确显示历史不完整。新增完整归档不再依赖 5000 条驱动事件缓存。
+
+## 源码及独立审查
+
+| 范围 | 结果与证据 |
+|---|---|
+| Workbench 首批 | `c0ad1f4439cf9ddd81f1277924dd6a01ddd212aa`，400 项通过；134 个 JS 文件为后续补测后的数量，首批为 133 |
+| 引擎 | `10c940a2425daaf27d24500c6f2ba21b79cb91d4`，185 通过、1 项既有跳过，不把跳过计为通过 |
+| 外壳首批 | `17bab6279035b3120a4dfbbe998f7e7a53772094`，backend-only 133 通过；补 configuration-generation 后最终 134 项全部通过（233968ms）；浏览器测试排除不计通过，见下方真实桌面验收 |
+| GLM-5.3 | Workbench 13 项定向审查；外壳 14 项当前通过，冻结基线 9 项预期失败。真实会话和报告位置见操作手册 |
+| 诊断补漏 | `98258aa`：runtime 改走异步解析，doctor 与扫描共用 ZCode 注册表后备发现；新增三项先红后绿，Workbench 全套 403 通过 |
+| 启动补漏 | `cbba73a`：GLM 同时指出任务与命令发现的同步 PATH 后备；改为一次异步解析，保留兼容同步导出，扫描中止信号传入子进程；新增先红后绿，Workbench 全套 404 通过 |
+
+GLM 报告分别保存在两个仓库的 `.local-test-data/ui-refresh-2026-10-15/`，不是生产知识文档。Leader 独立执行安装、真实模型和浏览器验收。
+
+## 首个候选 5.0.17-rc.1
+
+官方独立缓存收据：`D:\SanQian.Xu\.pk-acceptance-temp\kb-registry-product-ErheAk\registry-installation.json`。
+
+- 主包提交 `17bab6279035b3120a4dfbbe998f7e7a53772094`。
+- integrity：`sha512-QdcreZSakB55UyBDJ1rCmULxwOxem5qmQYVWFDYXH+yzp9qceqJl+EsOeq2qOMLKW1oUIPPucB+oMWiRO5Vjdw==`。
+- 精确模块：Workbench `0.13.2-rc.14`、vector-hub `1.0.8-rc.8`、bridge `0.7.2`、vendored engine `0.2.7-rc.10`。
+- 包内四模块哈希及依赖官方 integrity 通过，不依赖兄弟源码运行。
+- 四个真实受管模块退出后守护恢复、项目投影保留、CLI 大写 STOP 定向停止、所有受管子进程正常退出通过。证据在收据根目录 `acceptance-data/installed-*-acceptance.json`。
+
+### 真实模型与向量
+
+隔离环境：`D:\SanQian.Xu\.pk-acceptance-temp\智脑桌面验收-6PYtN8`，原供应商配置只读，隔离凭据目录受 ACL 保护。使用真实 MiniMax 对话与 embo-01，不使用模型/embedding 替身。
+
+`real-agent-rc1-refresh-acceptance.json`：
+
+- 单提交 `efb58c0cbe8b48dd5132b7ea1931b30d884a4d73` 晋升、索引及 commit 引用通过。
+- 两项目提交 `334f69b08fb759e4cbfca3d8398a02ea74eff5ea`、`21706feebe3fb695ac1b9444bc2d9078cafbe994` 均完成。
+- 分析区间分别为 12:23:29.417–12:23:54.088 UTC、12:23:30.428–12:24:03.577 UTC，确实重叠，不以两个排队状态冒充并发。
+- 浏览器通过包内 Workbench 发送真实任务，会话 `sess-98c93fa8072c` 返回知识原文及对应 commit；两轮流式回答后自然 idle，不需手动中止。
+
+### 桌面浏览器
+
+真实 Edge 正常桌面视口 1436×756，无尺寸覆盖、无横向溢出。
+
+- 源码受控五服务环境：八个真实标签页均加载工作台，每页 1 条 WebSocket / 2 个订阅；无同源六连接堵塞。
+- npm 候选真实模型环境：上下滚动、输出期间暂停跟随、切页保留草稿、断网恢复、引用保持、单连接复用通过。滚动后内容高度由 2233 增至 4495，阅读位置仍停留较早内容，而非被拉到底部。
+- 真实回答明确引用 `Knowledge has one writer: the engine promotion path. Preserve native workbench streaming and keep the product simple.`，不只匹配提交号。
+- 截图：`project-knowledge-base/.local-test-data/ui-refresh-2026-10-15/rc1-real-workbench.jpg`。
+
+## 性能与保留的首次失败
+
+- 一个模块挂起时，聚合项目读取从约 12038ms 降至 2509ms；模块健康读取约 2014ms，均为本机受控测量，不是所有设备保证。
+- 四个真实慢 CLI 子进程、最多两个并发时，轻量 HTTP P95 约 2.35–12.84ms；不再同步阻塞整个后台。
+- 1000 个运行的摘要只返回 50 条且小于 10KB，详情仍保留证据。
+- 初次候选 registry 尚在异步处理中时下载校验因 next 仍旧版本失败；等待 registry 可见后使用新的独立缓存下载通过，不覆盖原失败。
+- 原全套回归暴露配置同步过程中知识根变化未再次下发；已修复合并任务的 dirty 循环，重测通过。
+- GLM 的 TTL 20ms 墙钟测试在负载下偶发失效，改为注入时钟并全套复跑；不将测试竞态当产品回归。
+- 诊断复核发现 runtime 同步旁路与 registry-only ZCode 遗漏；首个候选不晋升 latest，补测试和修复后重新验收。
+
+## 最终放行
+
+待补：最终候选的官方收据、正式包收据及安装版重测结果。未填写之前不报告正式交付完成。