@sanqianx/project-knowledge 5.0.18 → 5.0.19

package/.claude-plugin/marketplace.json

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

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [5.0.19] - 2026-10-16
+
+- 工作台展示来自真实 SDK 事件的后台任务、工具活动及完成结果；主回复结束后可继续输入，后台任务继续归属原会话，切换和刷新可恢复。
+- 移除外壳列表定时轮询，复用实时连接推送摘要变化并增量更新侧栏；草稿按服务入口、项目和会话隔离，保护发送失败、迟到创建和附件读取的原始归属。
+- 修复新会话创建时的旧会话误用、追加消息 409、汇总回复重复展示，以及重启读取项目列表失败导致的重复登记与接线缓存问题。
+- 候选内容清单按 npm 实际安装行为规范 CLI shebang 的换行符，避免 Windows 工作树打包后产生错误的内容哈希告警；普通文件与脚本正文继续逐字节校验。
+- 自动长期记忆仅接受具有冻结人类原句与来源证据的跨项目长期规范；代理派单、单次修复和项目版本事实保留为项目知识。旧候选不自动改写。
+- 纳入 Workbench 0.13.2-rc.21 和经过真实向量回归的引擎修复；固定 30 条检索查询全部通过，109 处引用一致，真实修复提交完成分析、晋升、索引并由下一轮 GLM 实际采用。验收范围见 5.0.19 记录。
+
 ## [5.0.17] - 2026-10-15
 
 - 修复网页首屏被慢模块拖住、开始工作 Agent 探测同步阻塞与返回页面状态不刷新的问题；独立读取、明确失败状态和缓存保留，iframe 不重建。

package/_modules/knowledge-engine/src/analysis-contract.js

@@ -14,10 +14,11 @@ function frameFrozenEvidence(prompt) {
 }
 
 function memoryCandidateContract(entryId) {
-  return `\nMEMORY CANDIDATE CONTRACT: When the frozen owner explicitly states a durable preference, quote it exactly in a written knowledge document and propose memoryCandidates in manifest.json. With no explicit owner preference, omit candidates; never infer preferences from code style, test fixtures or assistant claims alone.
-Shape: [{"text":"the summarized preference","entryId":${JSON.stringify(entryId)},"quote":"an exact excerpt from that written document","scopeType":"project"}].
+  return `\nMEMORY CANDIDATE CONTRACT: An automatic long-term memory may ONLY be the owner's own explicit, durable, cross-project statement: a global convention or a domain norm the owner stated in a frozen user event whose inputOrigin is "human". Assistant replies, generated knowledge documents, code, test fixtures and agent-delegation prompts are never owner statements, even when they contain preference-like wording. Project architecture, version facts, one-off fixes and temporary task discipline belong in project knowledge only: do not propose them as candidates. With no such owner statement, omit candidates entirely.
+Shape: [{"text":"the owner's verbatim durable statement or a contiguous excerpt of quote; never a paraphrase","entryId":${JSON.stringify(entryId)},"quote":"the owner's exact original sentence, copied verbatim into that written document","sourceEventId":"the eventId of that frozen human user event","sourceHash":"that event's contentHash","scopeType":"domain" or "global","eligibility":{"durable":true,"crossProject":true,"reason":"why this statement is long-term rather than one-off, grounded in the owner's wording","scopeReason":"why it applies across the whole domain or all projects"}}].
+The engine independently verifies every field against the frozen conversation snapshot of this claim: sourceEventId must be one of its user events with inputOrigin "human"; sourceHash must equal that event's contentHash; quote must appear verbatim both in that event's content and in the entryId document; eligibility must be fully attested with non-empty reasons; scopeType must be "domain" or "global" — automatic candidates have no project scope. A failed check only rejects the candidate, never the knowledge promotion, so attest honestly: self-reported labels cannot substitute for the frozen source, and one-time instructions, project-local conventions or delegated task orders must not be proposed.
 entryId MUST equal an operations[].path for a create/replace in THIS manifest. It is the final knowledge-relative .md document path, NOT a candidate identifier, NOT an absolute path, NOT files/<path>. For example, when the quoted text is in files/${entryId}, entryId is ${JSON.stringify(entryId)}. If another written document contains the quote, use that document's exact operations[].path instead.
-quote must appear verbatim in that document and have at least 8 characters; text is 1–2000 characters. Check the document and entryId before submitting the manifest. scopeType is project (default), domain or global. Recommend domain/global only when the quoted owner requirement explicitly applies across that domain/all projects; ambiguous or local requirements stay project-scoped. Do not invent scope target IDs. Candidates remain unconfirmed until the user reviews content and scope.`;
+quote must appear verbatim in that document and have at least 8 characters; text is 1–2000 characters. Check the document, the entryId and the frozen event before submitting the manifest. Prefer "domain" when the owner's wording explicitly spans the current domain and "global" when it spans all projects; do not invent scope target IDs. Candidates remain unconfirmed until the user reviews content and scope.`;
 }
 
 function requireAnalysisOutput(manifestPath) {

package/_modules/knowledge-engine/src/coordinator.js

@@ -41,6 +41,7 @@ class EngineCoordinator extends EventEmitter {
     this.sharedIndexDirty = new Set();
     this.sharedIndexQueue = Promise.resolve();
     this.memories = new MemoryService(store, {
+      readSnapshot: (projectId, commitSha) => this.conversations.readSnapshot(projectId, commitSha),
       getIndexStatus: scope => scope && this.memoryIndexUpdates.has(scope.id) && this.sharedIndexJobs.has(scope.id) ? 'pending' : null,
       onMaterialized: scope => { this.memoryIndexUpdates.add(scope.id); this.indexSharedScope(scope).catch(() => {}); },
       onSyncChange: (scope, code) => {

package/_modules/knowledge-engine/src/memories.js

@@ -5,6 +5,7 @@ const crypto = require('node:crypto');
 const AtomicFile = require('./runtime/atomic-file');
 const { RuntimeLayout } = require('./runtime/layout');
 const { validateProjectId, DomainError } = require('./runtime/contracts');
+const { MemoryEligibility } = require('./memory-eligibility');
 
 const TYPES = ['global', 'domain', 'project'];
 const normalized = text => String(text).toLowerCase().replace(/\s+/g, ' ').trim();
@@ -15,6 +16,7 @@ class MemoryService {
     this.store = store; this.layout = new RuntimeLayout(store.dataDir); this.onMaterialized = options.onMaterialized;
     this.syncErrors = new Map(); this.closed = false; this.onSyncChange = options.onSyncChange; this.writes = new Set();
     this.getIndexStatus = options.getIndexStatus;
+    this.eligibility = new MemoryEligibility({ readSnapshot: options.readSnapshot || null });
   }
   lock() { return this.layout.getRuntimePath('locks', 'memories.lock'); }
   scopeOf(memory) { return { type: memory.scopeType || 'global', id: memory.scopeId || memory.brainId || 'brain-default' }; }
@@ -101,6 +103,7 @@ class MemoryService {
     const project = this.store.getProject(run.projectId);
     if (!project || !run.promotedAt) return report;
     const candidates = Array.isArray(run.staging?.memoryCandidates) ? run.staging.memoryCandidates : [];
+    const snapshot = this.eligibility.resolve(run);
     const before = this.store.state.memories, next = [...before];
     for (const [index, raw] of candidates.slice(0, 20).entries()) {
       const reject = code => report.rejected.push({ index, code });
@@ -114,12 +117,14 @@ class MemoryService {
       if (!this.layout.isPathInside(project.knowledgePath, file, { realpath: true })) { reject('PATH_OUTSIDE_ROOT'); continue; }
       try { if (!fs.readFileSync(file, 'utf8').includes(quote)) { reject('QUOTE_MISMATCH'); continue; } }
       catch { reject('EVIDENCE_UNREADABLE'); continue; }
+      const provenance = this.eligibility.verify(raw, snapshot, project);
+      if (!provenance.ok) { reject(provenance.code); continue; }
       const brainId = project.brainId || 'brain-default';
-      const scopeType = raw.scopeType === 'global' ? 'global' : raw.scopeType === 'domain' && project.domainId ? 'domain' : 'project';
-      const scopeId = scopeType === 'global' ? brainId : scopeType === 'domain' ? project.domainId : project.projectId;
+      const scopeType = raw.scopeType;
+      const scopeId = scopeType === 'global' ? brainId : project.domainId;
       const key = fingerprint(brainId, scopeType, scopeId, text);
-      if (next.some(m => m.captureFingerprint === key || fingerprint(m.brainId || 'brain-default', this.scopeOf(m).type, this.scopeOf(m).id, m.text) === key || !m.scopeType && m.evidence.projectId === project.projectId && normalized(m.originalText || m.text) === normalized(text))) { report.deduplicated++; continue; }
-      next.push({ id: `memory-${crypto.randomUUID()}`, fingerprint: key, captureFingerprint: key, brainId, domainId: project.domainId || null, scopeType, scopeId, text, originalText: text, status: 'candidate', evidence: { projectId: project.projectId, commitSha: run.commitSha, runId: run.runId, entryId, quote }, createdAt: new Date().toISOString(), updatedAt: new Date().toISOString() });
+      if (next.some(m => m.captureFingerprint === key || fingerprint(m.brainId || 'brain-default', this.scopeOf(m).type, this.scopeOf(m).id, m.text) === key || !m.scopeType && m.evidence?.projectId === project.projectId && normalized(m.originalText || m.text) === normalized(text))) { report.deduplicated++; continue; }
+      next.push({ id: `memory-${crypto.randomUUID()}`, fingerprint: key, captureFingerprint: key, brainId, domainId: project.domainId || null, scopeType, scopeId, text, originalText: text, status: 'candidate', sourceEventId: provenance.sourceEventId, sourceHash: provenance.sourceHash, eligibility: provenance.eligibility, evidence: { projectId: project.projectId, commitSha: run.commitSha, runId: run.runId, entryId, quote }, createdAt: new Date().toISOString(), updatedAt: new Date().toISOString() });
       report.accepted++;
     }
     if (report.accepted) {
@@ -183,7 +188,7 @@ class MemoryService {
       // Preserve legacy global bytes until the user actually edits that record.
       const scopeText = m.scopeType ? `适用范围：${{ global: '全局', domain: '领域', project: '项目' }[scope.type]} · ${scope.id}\n\n` : '';
       const text = m.scopeType ? m.text.replace(/^\s*(#{1,6})\s/gm, '\\$1 ') : m.text;
-      const source = m.sourceType === 'manual' ? '手动添加（用户确认）' : `${m.evidence.projectId} · ${m.evidence.commitSha} · ${m.evidence.entryId}`;
+      const source = m.sourceType === 'manual' ? '手动添加（用户确认）' : m.evidence ? `${m.evidence.projectId} · ${m.evidence.commitSha} · ${m.evidence.entryId}` : '历史记录（来源未记录）';
       return `## ${m.id}\n\n${scopeText}${text}\n\n来源：${source}\n`;
     }).join('\n');
   }

package/_modules/knowledge-engine/src/memory-eligibility.js

@@ -0,0 +1,74 @@
+'use strict';
+
+// Hard provenance gate for automatic long-term memory admission. The
+// maintenance model owns the semantic judgment (its prompt contract demands
+// durable, cross-project owner preferences); this gate never re-classifies
+// text and never trusts model self-reports over the frozen snapshot of the
+// claim being captured.
+const SHARED_SCOPES = new Set(['domain', 'global']);
+
+function indexUserEvents(snapshot) {
+  const events = new Map();
+  for (const turn of snapshot?.turns || []) {
+    for (const event of turn.userEvents || []) {
+      if (event?.eventId) events.set(String(event.eventId), event);
+    }
+  }
+  return events;
+}
+
+function conversationReferences(run) {
+  const references = new Set();
+  for (const operation of run?.staging?.operations || []) {
+    for (const reference of operation.evidenceReferences || []) {
+      if (typeof reference === 'string' && reference.startsWith('conversation:')) references.add(reference.slice('conversation:'.length));
+    }
+  }
+  return references;
+}
+
+class MemoryEligibility {
+  constructor(options = {}) {
+    this.readSnapshot = typeof options.readSnapshot === 'function' ? options.readSnapshot : null;
+  }
+
+  // The snapshot must exist AND be bound to this run's promoted operations
+  // through a `conversation:<snapshotHash>` evidence reference, so a foreign
+  // or later-frozen conversation can never vouch for this claim.
+  resolve(run) {
+    if (!this.readSnapshot) return null;
+    const references = conversationReferences(run);
+    if (!references.size) return null;
+    let snapshot = null;
+    try { snapshot = this.readSnapshot(run.projectId, run.commitSha); } catch { return null; }
+    return snapshot && references.has(snapshot.snapshotHash) ? snapshot : null;
+  }
+
+  verify(candidate, snapshot, project) {
+    if (!snapshot) return { ok: false, code: 'SNAPSHOT_UNAVAILABLE' };
+    const sourceEventId = String(candidate.sourceEventId || '');
+    if (!sourceEventId) return { ok: false, code: 'SOURCE_EVENT_MISSING' };
+    const event = indexUserEvents(snapshot).get(sourceEventId);
+    if (!event) return { ok: false, code: 'SOURCE_EVENT_NOT_FOUND' };
+    if ((event.inputOrigin || 'unknown') !== 'human') return { ok: false, code: 'SOURCE_NOT_HUMAN' };
+    if (String(candidate.sourceHash || '') !== String(event.contentHash || '')) return { ok: false, code: 'SOURCE_HASH_MISMATCH' };
+    if (!String(event.content || '').includes(String(candidate.quote || '').trim())) return { ok: false, code: 'QUOTE_NOT_IN_SOURCE' };
+    if (!String(candidate.quote || '').includes(String(candidate.text || '').trim())) return { ok: false, code: 'TEXT_NOT_IN_QUOTE' };
+    const eligibility = candidate.eligibility;
+    if (!eligibility || typeof eligibility !== 'object' || Array.isArray(eligibility)) return { ok: false, code: 'ELIGIBILITY_MISSING' };
+    if (eligibility.durable !== true) return { ok: false, code: 'ELIGIBILITY_NOT_DURABLE' };
+    if (eligibility.crossProject !== true) return { ok: false, code: 'ELIGIBILITY_NOT_CROSS_PROJECT' };
+    if (!String(eligibility.reason || '').trim()) return { ok: false, code: 'ELIGIBILITY_REASON_MISSING' };
+    if (!String(eligibility.scopeReason || '').trim()) return { ok: false, code: 'ELIGIBILITY_SCOPE_REASON_MISSING' };
+    if (!SHARED_SCOPES.has(candidate.scopeType)) return { ok: false, code: 'SCOPE_NOT_SHARED' };
+    if (candidate.scopeType === 'domain' && !project.domainId) return { ok: false, code: 'SCOPE_DOMAIN_UNBOUND' };
+    return {
+      ok: true,
+      sourceEventId,
+      sourceHash: String(event.contentHash),
+      eligibility: { durable: true, crossProject: true, reason: String(eligibility.reason).trim(), scopeReason: String(eligibility.scopeReason).trim() },
+    };
+  }
+}
+
+module.exports = { MemoryEligibility };

package/_modules/knowledge-engine/src/retrieval-ranking.js

@@ -47,7 +47,8 @@ function intent(query) {
   const text = String(query || '').trim();
   if (/^(?:hello|hi|hey|你好|您好|早上好|晚上好|在吗)[\s!！。?？]*$/i.test(text)) return 'greeting';
   if (/^(?:为什么|怎么回事|这是什么意思|继续|然后呢|展开说说|why|continue|tell me more)[\s!！。?？]*$/i.test(text)) return 'followup';
-  if (/(你|本轮|本次|刚才|上一条|这段).*(知识|记忆|上下文|context|memory).*(来源|哪里|什么地方|收到|读取|获取|from|received)/i.test(text)) return 'followup';
+  const concreteTask = /(修复|实现|新增|设计|为什么|为何|如何|怎样|避免|并发|草稿|implement|fix|design|why|how)/i.test(text);
+  if (!concreteTask && /(你|本轮|本次|刚才|上一条|这段).*(知识|记忆|上下文|context|memory).*(来源|哪里|什么地方|收到|读取|获取|from|received)/i.test(text)) return 'followup';
   if (/(最近|最新|上次|上一[次回]|recent|latest|last)/i.test(text) && /(进度|开发|提交|修改|更新|改动|progress|commit|develop|change|update)/i.test(text)) return 'recent';
   return 'search';
 }
@@ -80,6 +81,23 @@ function lexical(candidates, query, ignoredTerms = []) {
 }
 
 function rank(candidates, query, scoreIdentity, options = {}) {
+  // Named technologies select evidence, not merely a similar subject. A
+  // calibrated embedding can place an unrelated document nearby; it cannot
+  // establish that PostgreSQL/OpenTelemetry exists in the current knowledge.
+  // Filenames are excluded because new files legitimately seek analogies.
+  const topicQuery = String(query).replace(/[A-Za-z0-9_./\\-]+\.[A-Za-z0-9]{1,8}\b/g, '');
+  const named = [...new Set((topicQuery.match(/\b[A-Z][A-Za-z0-9]*[a-z][A-Z][A-Za-z0-9]*\b/g) || []).map(name => name.toLowerCase()))];
+  if (named.length) {
+    const documented = new Map();
+    for (const c of candidates) {
+      const key = `${c.spaceId}:${c.entryId}`;
+      const text = `${c.title}\n${c.chunkText}`.toLowerCase();
+      const found = documented.get(key) || new Set();
+      for (const name of named) if (text.includes(name)) found.add(name);
+      documented.set(key, found);
+    }
+    candidates = candidates.filter(c => named.every(name => documented.get(`${c.spaceId}:${c.entryId}`)?.has(name)));
+  }
   // A resolved commit already constrains provenance. Repeated SHA text in a
   // heading is not evidence for the topic asked about within that commit.
   lexical(candidates, query, options.commitPrefixes || []);

package/_modules/knowledge-engine/src/runtime/commit-conversation-binder.js

@@ -9,6 +9,7 @@ function projectEvent(event) {
     sequence: event.sequence,
     content: event.content,
     contentHash: event.contentHash,
+    inputOrigin: event.inputOrigin || 'unknown',
     capturedAt: event.capturedAt,
   };
 }

package/_modules/knowledge-engine/src/runtime/commit-prompt.js

@@ -33,18 +33,21 @@ function formatRequirements(records) {
   ].join('\n')).join('\n');
 }
 
-function formatConversationUserTruth(snapshot) {
-  if (!snapshot || !Array.isArray(snapshot.turns) || snapshot.turns.length === 0) return REQUIREMENT_UNAVAILABLE;
-  return snapshot.turns.flatMap(turn => turn.userEvents.map(event => [
-    `- turnId: ${turn.turnId}`,
-    `  eventId: ${event.eventId}`,
-    `  source/session: ${turn.source}/${turn.sessionId || '(unavailable)'}`,
+function formatConversationUserTruth(snapshot) {
+  if (!snapshot || !Array.isArray(snapshot.turns) || snapshot.turns.length === 0) return REQUIREMENT_UNAVAILABLE;
+  const rendered = snapshot.turns.flatMap(turn => turn.userEvents.map(event => [
+    `- turnId: ${turn.turnId}`,
+    `  eventId: ${event.eventId}`,
+    `  inputOrigin: ${event.inputOrigin || 'unknown'}`,
+    `  contentHash: ${event.contentHash}`,
+    `  source/session: ${turn.source}/${turn.sessionId || '(unavailable)'}`,
     `  binding: ${turn.bindingKind}`,
     `  capturedAt: ${event.capturedAt}`,
     '  userPrompt: |',
-    ...String(event.content || '').split(/\r?\n/).map(line => `    ${line}`),
-  ].join('\n'))).join('\n');
-}
+    ...String(event.content || '').split(/\r?\n/).map(line => `    ${line}`),
+  ].join('\n'))).join('\n');
+  return `inputOrigin marks who typed each frozen user event: only "human" is the owner speaking; "agent-delegation" is a delegated task order from another agent; "unknown" cannot be verified. Memory candidates may rely on "human" events only.\n${rendered}`;
+}
 
 function formatAssistantEvidence(snapshot) {
   if (!snapshot || !Array.isArray(snapshot.turns)) return '(no assistant conversation evidence was frozen)';

package/_modules/knowledge-engine/src/runtime/conversation-store.js

@@ -46,6 +46,7 @@ function normalizeConversationEvent(projectId, input = {}) {
     source: String(input.source || ''),
     eventType: String(input.eventType || ''),
     role,
+    inputOrigin: ['human', 'agent-delegation'].includes(input.inputOrigin) ? input.inputOrigin : 'unknown',
     content,
     contentHash: sha256(content),
     sessionId: optionalString(input.sessionId),
@@ -235,6 +236,7 @@ class ConversationStore {
       source: bridgeEvent.source,
       eventType: bridgeEvent.eventType,
       role: bridgeEvent.role,
+      inputOrigin: bridgeEvent.inputOrigin || bridgeEvent.meta?.inputOrigin || /:origin=(human|agent-delegation|unknown)$/.exec(String(bridgeEvent.eventKey || ''))?.[1],
       content: bridgeEvent.content == null ? '' : bridgeEvent.content,
       sessionId: bridgeEvent.sessionId,
       turnId: bridgeEvent.turnId,

package/_site/_test/candidate-bin-content-test.js

@@ -0,0 +1,35 @@
+'use strict';
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { installedFileBytes } = require('../scripts/pack-module-candidates');
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'kb-bin-content-'));
+const npmCli = process.env.npm_execpath || path.join(path.dirname(process.execPath), 'node_modules/npm/bin/npm-cli.js');
+function npm(args, cwd) {
+  const result = spawnSync(process.execPath, [npmCli, ...args], { cwd, encoding: 'utf8', windowsHide: true });
+  assert.equal(result.status, 0, result.stderr);
+  return result.stdout;
+}
+try {
+  const source = path.join(root, 'source'), installed = path.join(root, 'installed');
+  fs.mkdirSync(source); fs.mkdirSync(installed);
+  const pkg = { name: 'kb-bin-content-fixture', version: '1.0.0', bin: { 'kb-content-fixture': './bin.js' }, files: ['bin.js', 'readme.txt'] };
+  const bytes = Buffer.from('#!/usr/bin/env node\r\nconsole.log("安装验收");\r\n');
+  fs.writeFileSync(path.join(source, 'package.json'), JSON.stringify(pkg));
+  fs.writeFileSync(path.join(source, 'bin.js'), bytes);
+  fs.writeFileSync(path.join(source, 'readme.txt'), bytes);
+  assert.equal(typeof installedFileBytes, 'function', 'candidate hashes must model npm bin normalization');
+  const packed = JSON.parse(npm(['pack', '--ignore-scripts', '--json', '--pack-destination', root], source))[0];
+  fs.writeFileSync(path.join(installed, 'package.json'), JSON.stringify({ name: 'kb-bin-consumer', version: '1.0.0', private: true }));
+  npm(['install', `file:${path.join(root, packed.filename)}`, '--ignore-scripts', '--no-audit', '--no-fund', '--package-lock=false'], installed);
+  const actual = fs.readFileSync(path.join(installed, 'node_modules', pkg.name, 'bin.js'));
+  assert.notDeepEqual(actual, bytes, 'npm changes a CRLF shebang on installation');
+  assert.deepEqual(installedFileBytes(pkg, 'bin.js', bytes), actual, 'manifest bytes match actual npm installation');
+  assert.deepEqual(installedFileBytes(pkg, 'readme.txt', bytes), bytes, 'ordinary files retain their exact bytes');
+  assert.deepEqual(installedFileBytes({ bin: 'bin.js' }, 'bin.js', bytes), actual, 'string bin form is supported');
+  assert.deepEqual(installedFileBytes(pkg, 'bin.js', actual), actual, 'an already normalized bin is unchanged');
+  assert.ok(actual.includes(Buffer.from('验收");\r\n')), 'only the shebang is normalized');
+  console.log('candidate-bin-content-test PASS');
+} finally { fs.rmSync(root, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); }

package/_site/_test/candidate-product-assets-test.js

@@ -0,0 +1,13 @@
+'use strict';
+const assert=require('node:assert/strict'),fs=require('node:fs'),path=require('node:path'),os=require('node:os'),crypto=require('node:crypto');
+const {productFiles}=require('../scripts/pack-module-candidates');
+const root=fs.mkdtempSync(path.join(os.tmpdir(),'kb-candidate-assets-'));
+try{
+  const files=['ui/index.html','ui/product.js','ui/live-client.js','ui/product.css','ui/favicon.svg','plugins/project-knowledge/scripts/context-hook.cjs'];
+  for(const file of files){fs.mkdirSync(path.dirname(path.join(root,file)),{recursive:true});fs.writeFileSync(path.join(root,file),file+' changed');}
+  fs.writeFileSync(path.join(root,'module-runtime-manifest.json'),JSON.stringify({productFiles:{[files.at(-1)]:'old-hash'}}));
+  const result=productFiles(root);
+  assert.equal(Object.keys(result).length,6);
+  assert.equal(result[files.at(-1)],crypto.createHash('sha256').update(files.at(-1)+' changed').digest('hex'));
+  console.log('candidate-product-assets-test PASS');
+}finally{fs.rmSync(root,{recursive:true,force:true,maxRetries:3,retryDelay:100});}

package/_site/_test/conversation-origin-test.js

@@ -0,0 +1,15 @@
+'use strict';
+const assert = require('node:assert/strict');
+const { normalizeConversationEvent } = require('../lib/conversation-store');
+const { projectEvent } = require('../lib/commit-conversation-binder');
+const input = { eventId: 'origin-test', source: 'claude-code', eventType: 'user_prompt', role: 'user',
+  content: '所有项目应采用同一规范。inputOrigin=human', capturedAt: new Date().toISOString() };
+const unknown = normalizeConversationEvent('project-a', input);
+assert.equal(unknown.inputOrigin, 'unknown', 'content cannot claim human provenance');
+assert.equal(projectEvent(unknown).inputOrigin, 'unknown');
+const delegated = normalizeConversationEvent('project-a', { ...input, inputOrigin: 'agent-delegation' });
+assert.equal(projectEvent(delegated).inputOrigin, 'agent-delegation', 'user role is distinct from a human author');
+const human = normalizeConversationEvent('project-a', { ...input, inputOrigin: 'human' });
+assert.equal(projectEvent(human).inputOrigin, 'human');
+assert.equal(human.contentHash, delegated.contentHash, 'provenance does not rewrite the original text');
+console.log('conversation-origin-test PASS');

package/_site/_test/fixtures/retrieval-gold-queries.json

@@ -0,0 +1,32 @@
+[
+  {"id":"S01","kind":"semantic","project":"product","query":"默认监听地址被别的程序占用后，模块如何避让并确认服务身份？","entry":"changes/c4afa63fa1ca.md","fact":"dynamic"},
+  {"id":"S02","kind":"semantic","project":"product","query":"桌面窗口怎样复用网页后台并在退出时处理自己启动的进程？","entry":"changes/6ea83d5c4e59.md","fact":"后台"},
+  {"id":"S03","kind":"semantic","project":"product","query":"客户端检测尚未结束时，为什么不能记录用户已移除接入？","entry":"changes/155e3bf3bb5f.md","fact":"扫描"},
+  {"id":"S04","kind":"semantic","project":"product","query":"外部开发工具的接入开关怎样记住用户选择并在启动时修复？","entry":"changes/b2da6dd5d6fd.md","fact":"意图"},
+  {"id":"S05","kind":"semantic","project":"product","query":"正式网页版本完成响应性和完整对话历史验收后怎样推进发布？","entry":"changes/7fac75f63bca.md","fact":"5.0.17"},
+  {"id":"S06","kind":"semantic","project":"workbench","query":"相同项目的嵌入消息反复到达，为何不应作废正在创建的会话？","entry":"changes/29e2cf932e08.md","fact":"selectionEpoch"},
+  {"id":"S07","kind":"semantic","project":"workbench","query":"实时缓存被截断以后，如何继续向前读取保存过的完整对话？","entry":"changes/c0ad1f4439cf.md","fact":"history"},
+  {"id":"S08","kind":"semantic","project":"workbench","query":"会话完成一轮输出后，列表上的最近活动时间为何仍停在创建时？","entry":"changes/b79e8bb03b48.md","fact":"updatedAt"},
+  {"id":"S09","kind":"semantic","project":"workbench","query":"保存模型供应商后，怎样避免复用保存之前仍在途的旧目录请求？","entry":"changes/3e8c9924e673.md","fact":"afterMutation"},
+  {"id":"S10","kind":"semantic","project":"workbench","query":"异步查找客户端期间任务已取消，如何阻止迟到的初始化再启动进程？","entry":"changes/1b028da75b0b.md","fact":"sdkTurnGeneration"},
+  {"id":"E01","kind":"exact","project":"product","query":"提交 c4afa63fa1ca 的端口扫描耗尽错误是什么？","entry":"changes/c4afa63fa1ca.md","fact":"NO_FREE_MODULE_PORT"},
+  {"id":"E02","kind":"exact","project":"product","query":"提交 155e3bf3bb5f 如何处理尚未落定的扫描？","entry":"changes/155e3bf3bb5f.md","fact":"扫描"},
+  {"id":"E03","kind":"exact","project":"workbench","query":"提交 b79e8bb03b48 的 updatedAt 修改涉及什么驱动？","entry":"changes/b79e8bb03b48.md","fact":"updatedAt"},
+  {"id":"E04","kind":"exact","project":"workbench","query":"提交 29e2cf932e08 如何保护新会话创建？","entry":"changes/29e2cf932e08.md","fact":"selectionEpoch"},
+  {"id":"E05","kind":"exact","project":"workbench","query":"提交 3e8c9924e673 的 afterMutation 机制是什么？","entry":"changes/3e8c9924e673.md","fact":"afterMutation"},
+  {"id":"I01","kind":"isolation","project":"product","query":"会话创建 selectionEpoch 如何处理？"},
+  {"id":"I02","kind":"isolation","project":"workbench","query":"模块默认端口全被占用时如何处理？"},
+  {"id":"I03","kind":"isolation","project":"engine","query":"桌面窗口退出如何保留网页后台？","empty":true},
+  {"id":"I04","kind":"isolation","project":"engine","query":"供应商保存后 afterMutation 如何处理？","empty":true},
+  {"id":"I05","kind":"isolation","project":"product","query":"从未维护的项目完整历史分页怎么加载？"},
+  {"id":"D01","kind":"stale","project":"product","query":"c4afa63fa1ca 动态端口","entry":"changes/c4afa63fa1ca.md"},
+  {"id":"D02","kind":"stale","project":"product","query":"6ea83d5c4e59 桌面薄壳","entry":"changes/6ea83d5c4e59.md"},
+  {"id":"D03","kind":"stale","project":"product","query":"155e3bf3bb5f 意图迁移","entry":"changes/155e3bf3bb5f.md"},
+  {"id":"D04","kind":"stale","project":"workbench","query":"29e2cf932e08 会话创建","entry":"changes/29e2cf932e08.md"},
+  {"id":"D05","kind":"stale","project":"workbench","query":"b79e8bb03b48 最近活动时间","entry":"changes/b79e8bb03b48.md"},
+  {"id":"N01","kind":"unsupported","project":"product","query":"当前项目 PostgreSQL 主从故障切换与 WAL 归档策略是什么？","empty":true},
+  {"id":"N02","kind":"unsupported","project":"product","query":"当前项目 OpenTelemetry 追踪数据上报到哪里？","empty":true},
+  {"id":"N03","kind":"unsupported","project":"workbench","query":"当前项目 ElasticSearch 搜索集群如何备份？","empty":true},
+  {"id":"N04","kind":"unsupported","project":"workbench","query":"当前项目 TensorFlow 模型训练批次如何配置？","empty":true},
+  {"id":"N05","kind":"unsupported","project":"product","query":"当前项目 ClickHouse 分片副本如何部署？","empty":true}
+]

package/_site/_test/module-index-proxy-test.js

@@ -0,0 +1,33 @@
+'use strict';
+const assert = require('node:assert/strict');
+const http = require('node:http');
+const { ModuleBridge } = require('../lib/module-bridge');
+(async () => {
+  const upstream = http.createServer((req, res) => {
+    const timer = setTimeout(() => { res.writeHead(200, { 'Content-Type': 'application/json' }); res.end('{"ok":true}'); }, 75);
+    res.on('close', () => clearTimeout(timer));
+  });
+  await new Promise(resolve => upstream.listen(0, '127.0.0.1', resolve));
+  const bridge = new ModuleBridge({ vectorHubUrl: `http://127.0.0.1:${upstream.address().port}` });
+  const timer = global.setTimeout;
+  const budgets = [];
+  // Scale only the two product deadlines, preserving real HTTP cancellation.
+  global.setTimeout = (fn, ms, ...args) => {
+    if (ms === 10000 || ms === 120000) { budgets.push(ms); return timer(fn, ms === 10000 ? 25 : 500, ...args); }
+    return timer(fn, ms, ...args);
+  };
+  const server = http.createServer((req, res) => bridge.proxy(req, res, `http://127.0.0.1:${upstream.address().port}${req.url}`));
+  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+  try {
+    const base = `http://127.0.0.1:${server.address().port}`;
+    const indexed = await fetch(`${base}/api/sync`, { method: 'POST', body: '{}' });
+    assert.equal(indexed.status, 200, 'a real embedding pass must use the engine indexing budget rather than the interactive deadline');
+    assert.equal(budgets[0], 120000);
+    const health = await fetch(`${base}/api/health`);
+    assert.equal(health.status, 502, 'ordinary reads keep their bounded interactive deadline');
+    console.log('module-index-proxy-test PASS');
+  } finally {
+    global.setTimeout = timer;
+    for (const s of [server, upstream]) { s.closeAllConnections(); await new Promise(resolve => s.close(resolve)); }
+  }
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/module-terminal-restart-test.js

@@ -0,0 +1,63 @@
+'use strict';
+const assert = require('node:assert/strict');
+const { ModuleBridge } = require('../lib/module-bridge');
+const { connectEngine } = require('../lib/engine-connection');
+
+async function main() {
+  const state = { modules: { terminal: { projectId: 'terminal-original' } } };
+  const config = { repoPath: process.cwd(), knowledgePath: process.cwd(), displayName: 'Restart' };
+  const projects = ['terminal-original', 'terminal-duplicate'].map(id => ({ id, rootPath: config.repoPath }));
+  let listFailure = 'status';
+  let creations = 0;
+  const bridge = new ModuleBridge({
+    terminalUrl: 'http://terminal.test', vectorHubUrl: 'http://vector.test',
+    eventBridgeUrl: 'http://event.test', engineUrl: 'http://engine.test',
+    registryStore: { listIds: () => ['project-restart'], readDisplaySnapshot: () => ({}) },
+    projectStore: { readConfig: () => config, readState: () => state, updateState: async (_id, apply) => apply(state) },
+  });
+  bridge.modulesHealth = async () => ({ modules: Object.fromEntries(['terminal', 'vectorHub', 'eventBridge', 'engine'].map(key => [key, { up: true }])) });
+  bridge._fetch = async (url, options = {}) => {
+    if (url === 'http://terminal.test/api/claude-workbench/v1/projects') {
+      if (options.method === 'POST') { creations += 1; return { ok: true, status: 201, json: async () => ({ id: 'unexpected-new' }) }; }
+      if (listFailure === 'network') throw new Error('service starting');
+      if (listFailure === 'status') return { ok: false, status: 503 };
+      return { ok: true, json: async () => listFailure === 'payload' ? {} : { projects } };
+    }
+    return { ok: true, status: 200, json: async () => ({ projects: [], project: { id: 'journal-restart' }, sequence: 0 }) };
+  };
+  const input = { projectId: 'project-restart', name: config.displayName, workspacePath: config.repoPath, knowledgePath: config.knowledgePath };
+  for (const failure of ['status', 'network', 'payload']) {
+    listFailure = failure;
+    const result = await bridge.registerProjectLinks(input);
+    assert.equal(result.terminal.status, 'pending', `${failure} is not an empty registry`);
+    assert.equal(creations, 0, 'a failed registry read must never create a workspace');
+    assert.equal(state.modules.terminal.projectId, 'terminal-original', 'retain the last known binding');
+  }
+  listFailure = null;
+  const recovered = await bridge.registerProjectLinks(input);
+  assert.equal(recovered.terminal.projectId, 'terminal-original');
+  assert.equal(recovered.terminal.reused, true);
+  const projection = await bridge.aggregatedProjects();
+  assert.equal(projection.projects[0].modules.terminal.projectId, 'terminal-original', 'saved binding wins over duplicate path entries');
+  assert.equal(creations, 0);
+  let wiringCalls = 0;
+  const runtime = {
+    registryStore: bridge.registryStore, projectStore: bridge.projectStore,
+    moduleBridge: {
+      engineUrl: 'http://engine.test', runtimeToken: 'fixture',
+      _fetch: async () => ({ ok: true, status: 200, json: async () => ({ name: 'knowledge-engine', dataSchemaVersion: 3 }) }),
+      _listEngineProjects: async () => [{ projectId: 'project-restart', ...config }],
+      registerProjectLinks: async () => ({ engine: { ok: true }, eventBridge: { ok: true }, terminal: { ok: ++wiringCalls > 1 } }),
+      syncEngineConfiguration: async () => ({}),
+    },
+    logger: { warn: async () => {} },
+  };
+  await connectEngine(runtime);
+  assert.equal(runtime.ownership.ready, true, 'terminal recovery does not block the knowledge engine');
+  assert.equal(runtime.projectConnections.has('project-restart'), false, 'incomplete terminal wiring must remain retryable');
+  await connectEngine(runtime);
+  assert.equal(wiringCalls, 2, 'the next connection pass retries incomplete terminal wiring');
+  assert.equal(runtime.projectConnections.has('project-restart'), true);
+  console.log('module-terminal-restart-test PASS');
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/registry-events-test.js

@@ -0,0 +1,38 @@
+'use strict';
+const assert = require('node:assert/strict');
+const http = require('node:http');
+const { RegistryEvents } = require('../lib/registry-events');
+const { createRequestHandler } = require('../lib/server-app');
+
+(async () => {
+  const events = new RegistryEvents(), received = [];
+  const off = events.subscribe(event => received.push(event));
+  assert.equal(received[0].type, 'registry-snapshot');
+  const runtime = { registryEvents: events, logger: { debug: async () => {}, info: async () => {} },
+    moduleBridge: { syncEngineConfiguration: async () => ({}) },
+    settingsStore: { read: () => ({ brain: { id: 'brain-default', name: 'before' }, knowledge: { rootPath: '' } }), updatePatch: async patch => ({ brain: patch.brain }) } };
+  // Exercise the real HTTP completion hook independently of business stores.
+  const handler = createRequestHandler(runtime, { host: '127.0.0.1', port: 0 });
+  const server = http.createServer(handler);
+  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+  try {
+    const base = `http://127.0.0.1:${server.address().port}`;
+    const reader = await fetch(`${base}/api/registry/events`);
+    const stream = reader.body.getReader();
+    const first = new TextDecoder().decode((await stream.read()).value);
+    assert.match(first, /registry-snapshot/);
+    const mutation = await fetch(`${base}/api/brain`, { method: 'PATCH', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ name: 'after' }) });
+    assert.equal(mutation.status, 200);
+    const change = new TextDecoder().decode((await stream.read()).value);
+    assert.match(change, /registry-changed/);
+    assert.equal(received[1].revision, 1);
+    const reconnect = []; events.subscribe(event => reconnect.push(event))();
+    assert.equal(reconnect[0].revision, 1);
+    assert.equal(reconnect[0].instanceId, received[0].instanceId);
+    await stream.cancel();
+    off(); events.publish(['brain']);
+    assert.equal(received.length, 2, 'unsubscribed observers receive no more updates');
+    assert.notEqual(new RegistryEvents().instanceId, events.instanceId, 'restart makes old revisions distinguishable');
+    console.log('registry-events-test PASS (real SSE, reconnect identity and unsubscribe)');
+  } finally { server.closeAllConnections(); await new Promise(resolve => server.close(resolve)); }
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/workbench-context-receipts-test.js

@@ -0,0 +1,22 @@
+'use strict';
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const source = fs.readFileSync(path.join(__dirname, '../../ui/product.js'), 'utf8');
+const code = source.slice(source.indexOf('  function frameContext('), source.indexOf('  function setView('));
+const messages = [], frame = { ready: false }, state = { epoch: 1, scope: 'project' };
+const project = { projectId: 'a', workspacePath: '/workspace', modules: { terminal: { projectId: 'context-a' } } };
+const ctx = vm.createContext({ state, frames: { terminal: frame }, activeProject: () => project,
+  document: { documentElement: { dataset: { theme: 'light' } } }, frameVisible: () => true,
+  post: (_key, message) => messages.push(message) });
+vm.runInContext(code, ctx);
+vm.runInContext('frameContext("terminal")', ctx);
+assert.equal(messages.length, 0);
+frame.ready = true;
+vm.runInContext('frameContext("terminal"); frameContext("terminal")', ctx);
+assert.equal(messages.filter(m => m.type === 'kb:select-project').length, 1, 'identical context receipts are not repeated');
+state.epoch++;
+vm.runInContext('frameContext("terminal")', ctx);
+assert.equal(messages.filter(m => m.type === 'kb:select-project').length, 2, 'a real selection still reaches the iframe');
+console.log('workbench-context-receipts-test PASS');

package/_site/lib/commit-conversation-binder.js

@@ -10,6 +10,7 @@ function projectEvent(event) {
     sequence: event.sequence,
     content: event.content,
     contentHash: event.contentHash,
+    inputOrigin: event.inputOrigin || 'unknown',
     capturedAt: event.capturedAt,
   };
 }

package/_site/lib/conversation-store.js

@@ -46,6 +46,7 @@ function normalizeConversationEvent(projectId, input = {}) {
     source: String(input.source || ''),
     eventType: String(input.eventType || ''),
     role,
+    inputOrigin: ['human', 'agent-delegation'].includes(input.inputOrigin) ? input.inputOrigin : 'unknown',
     content,
     contentHash: sha256(content),
     sessionId: optionalString(input.sessionId),
@@ -234,6 +235,7 @@ class ConversationStore {
       source: bridgeEvent.source,
       eventType: bridgeEvent.eventType,
       role: bridgeEvent.role,
+      inputOrigin: bridgeEvent.inputOrigin || bridgeEvent.meta?.inputOrigin || /:origin=(human|agent-delegation|unknown)$/.exec(String(bridgeEvent.eventKey || ''))?.[1],
       content: bridgeEvent.content == null ? '' : bridgeEvent.content,
       sessionId: bridgeEvent.sessionId,
       turnId: bridgeEvent.turnId,

package/_site/lib/engine-connection.js

@@ -47,7 +47,10 @@ async function connectEngineOnce(runtime) {
       try {
       const modules = await bridge.registerProjectLinks({ projectId: id, name: config.displayName, workspacePath: config.repoPath, knowledgePath: config.knowledgePath });
       if (!modules.engine.ok || !modules.eventBridge.ok) { pending.push({ projectId: id, code: 'PROJECT_WIRING_PENDING' }); continue; }
-      runtime.projectConnections.set(id, fingerprint); enabled.push(id);
+      // Engine activation can proceed while the terminal starts, but caching
+      // that partial wiring would prevent subsequent readiness passes repairing it.
+      if (modules.terminal?.ok !== false) runtime.projectConnections.set(id, fingerprint);
+      enabled.push(id);
       } catch { pending.push({ projectId: id, code: 'PROJECT_WIRING_PENDING' }); }
     } };
     await Promise.all([wire(), wire()]);

package/_site/lib/live-gateway.js

@@ -7,13 +7,15 @@ function attachLiveGateway(server, runtime) {
   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');
+    if ([...url.searchParams.keys()].some(k => !['after', 'projectId', 'contextId', '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/terminal/sessions/changes') return bridge._terminalApi(url.pathname) + url.search;
+    if (url.pathname === '/api/registry/events') return `http://${runtime.liveAddress}${route}`;
     if (url.pathname === '/api/logs/stream') return `http://${runtime.liveAddress}${route}`;
     throw new Error('INVALID_ROUTE');
   }