@sanqianx/project-knowledge 5.0.27 → 5.0.29

package/.claude-plugin/marketplace.json

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

package/_modules/knowledge-engine/README.md

@@ -69,6 +69,7 @@ node src/bin.js serve [--port 5790] [--host 127.0.0.1] [--data DIR]
 | POST | `/api/bridge/notify` | 唤醒 journal 消费；通知丢失仍由轮询恢复 |
 | GET / PATCH | `/api/memories`、`/api/memories/:id` | 按 status/scopeType/scopeId 筛选；一次编辑内容、适用范围和确认状态；来源证据只读 |
 | POST | `/api/memories` | `{ text, brainId?, scopeType?, scopeId? }` → 手动添加已确认记忆；默认全局，领域/项目必须指定已登记目标，不接受伪造来源 |
+| DELETE | `/api/memories/:id` | 软删除为无正文墓碑：默认列表与新任务不再使用，原始对话与知识来源保留；重复删除返回 404；完整契约见下方记忆删除边界 |
 | POST | `/api/scopes` | 外壳投影智脑、领域共享目录；受运行期鉴权保护 |
 | POST | `/api/runtime-config` | 运行期模型配置，仅保留在内存；受鉴权保护 |
 | GET | `/api/runtime-auth` | 本机服务确认运行期鉴权；受鉴权保护，不对浏览器反代 |
@@ -109,6 +110,7 @@ node src/bin.js serve [--port 5790] [--host 127.0.0.1] [--data DIR]
 - 长期记忆统一保存在已绑定的智脑共享目录：`memories/confirmed.md`（全局）、`memories/domains/<id>.md`、`memories/projects/<id>.md`。不创建第二份项目知识目录。现有 v5 缺少范围字段的记忆仍按全局解释；不读取 pre-v5 状态、不重扫历史。
 - 手动记忆以用户确认作为来源，记录 `sourceType: manual`、`evidence: null`，不伪造提交或分析运行。内容限制为 1–2000 字符，同范围内容去重；创建、编辑、投影与恢复复用引擎受控写入。空项目列表也可添加全局记忆，但必须已绑定共享目录；无需模型分析或 Git 提交，索引状态独立报告。
 - 任务检索只允许当前项目、当前所属领域与全局的已确认记忆，即使检索整个智脑也不放宽专属记忆范围。过滤在排名之前完成，`get` 同样校验；向量旧内容不能绕过当前状态和文件一致性校验。已确认记录修改范围会同步清理旧投影；写入失败显示待同步并自动重试，未同步文件不能进入上下文。
+- 删除记忆写入无正文墓碑记录：删除后默认列表与新任务上下文不再使用该记忆，原始对话与知识来源保持保留；同文本的自动候选按墓碑去重不会复活，同一适用范围仍可手动重加；重复删除返回 404；派生记忆文件写入失败时如实记录待同步并自动重试，不伪造一致状态。
 - 旧格式不读取、不自动迁移。损坏的正式状态不覆盖、不清空。
 - 引擎状态复用受控原子写入：独占随机临时文件、文件同步、Windows 短暂共享冲突有界重试；永久失败保留原状态并清理本次临时文件，绝不先删正式状态。
 

package/_modules/knowledge-engine/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanqianx/ai-coding-knowledge-engine",
-  "version": "0.2.7-rc.11",
+  "version": "0.2.7-rc.12",
   "description": "Knowledge engine module for project-knowledge: commit-boundary triggered knowledge analysis/generation (trigger plane) and retrieval for development assistants (retrieval plane).",
   "license": "Apache-2.0",
   "main": "src/server.js",

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

@@ -96,7 +96,7 @@ class MemoryService {
   }
   list({ brainId, status, scopeType, scopeId } = {}) {
     if (scopeType && !TYPES.includes(scopeType)) throw new DomainError('INVALID_ARGUMENT', '记忆筛选范围无效。');
-    return this.store.state.memories.filter(m => (!brainId || m.brainId === brainId) && (!status || m.status === status) && (!scopeType || this.scopeOf(m).type === scopeType) && (!scopeId || this.scopeOf(m).id === scopeId)).map(m => this.project(m));
+    return this.store.state.memories.filter(m => (m.status !== 'deleted' || status === 'deleted') && (!brainId || m.brainId === brainId) && (!status || m.status === status) && (!scopeType || this.scopeOf(m).type === scopeType) && (!scopeId || this.scopeOf(m).id === scopeId)).map(m => this.project(m));
   }
   capture(run) {
     const report = { accepted: 0, deduplicated: 0, rejected: [] };
@@ -123,7 +123,15 @@ class MemoryService {
       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; }
+      // Tombstones never hold text, so they dedup through their fingerprints:
+      // the fresh pair covers the record's last scope and text, while the kept
+      // original capture key still covers a pre-edit/pre-move scope.
+      const duplicateOf = m => {
+        if (m.captureFingerprint === key) return true;
+        if (m.status === 'deleted') return m.fingerprint === key || m.originalCaptureFingerprint === key;
+        return 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);
+      };
+      if (next.some(duplicateOf)) { 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++;
     }
@@ -145,7 +153,9 @@ class MemoryService {
       this.validateScope(type, targetId, brainId);
       if (!this.brainScope(brainId)) throw new DomainError('INVALID_ARGUMENT', '请先绑定智脑共享目录。', { status: 409 });
       const text = input.text.trim(), key = fingerprint(brainId, type, targetId, text);
-      if (this.store.state.memories.some(m => fingerprint(m.brainId || 'brain-default', this.scopeOf(m).type, this.scopeOf(m).id, m.text) === key)) throw new DomainError('MEMORY_DUPLICATE', '该范围内已存在相同记忆。', { status: 409 });
+      // An explicit manual add is the user changing their mind after a delete:
+      // tombstones never block it, only another live record in the same scope does.
+      if (this.store.state.memories.some(m => m.status !== 'deleted' && fingerprint(m.brainId || 'brain-default', this.scopeOf(m).type, this.scopeOf(m).id, m.text) === key)) throw new DomainError('MEMORY_DUPLICATE', '该范围内已存在相同记忆。', { status: 409 });
       // User confirmation is the provenance; never invent a model run or Git commit.
       const now = new Date().toISOString();
       const memory = { id: `memory-${crypto.randomUUID()}`, fingerprint: key, brainId, scopeType: type, scopeId: targetId, sourceType: 'manual', text, originalText: text, status: 'confirmed', evidence: null, createdAt: now, updatedAt: now };
@@ -162,7 +172,7 @@ class MemoryService {
     if (Object.keys(input).some(key => !['text', 'status', 'scopeType', 'scopeId'].includes(key))) throw new DomainError('INVALID_ARGUMENT', '来源证据和文件路径不能修改。');
     const job = AtomicFile.withFileLock(this.lock(), async () => {
       const memory = this.store.state.memories.find(m => m.id === id);
-      if (!memory) throw new DomainError('PROJECT_NOT_FOUND', '记忆不存在。', { status: 404 });
+      if (!memory || memory.status === 'deleted') throw new DomainError('PROJECT_NOT_FOUND', '记忆不存在。', { status: 404 });
       if (input.text !== undefined && (typeof input.text !== 'string' || !input.text.trim() || input.text.length > 2000)) throw new DomainError('INVALID_ARGUMENT', '记忆内容必须为 1–2000 个字符。');
       if (input.status !== undefined && !['confirmed', 'ignored'].includes(input.status)) throw new DomainError('INVALID_ARGUMENT', '记忆状态无效。');
       if (memory.status === 'ignored') throw new DomainError('INVALID_ARGUMENT', '该候选已忽略。', { status: 409 });
@@ -172,7 +182,7 @@ class MemoryService {
       if (input.status !== 'ignored' || input.scopeType !== undefined || input.scopeId !== undefined) this.validateScope(type, targetId, brainId);
       if ((input.status || memory.status) === 'confirmed' && !this.brainScope(brainId)) throw new DomainError('INVALID_ARGUMENT', '请先绑定智脑共享目录。', { status: 409 });
       const text = input.text?.trim() || memory.text, key = fingerprint(brainId, type, targetId, text);
-      if (this.store.state.memories.some(m => m.id !== id && fingerprint(m.brainId || 'brain-default', this.scopeOf(m).type, this.scopeOf(m).id, m.text) === key)) throw new DomainError('MEMORY_DUPLICATE', '该范围内已存在相同记忆。', { status: 409 });
+      if (this.store.state.memories.some(m => m.id !== id && m.status !== 'deleted' && fingerprint(m.brainId || 'brain-default', this.scopeOf(m).type, this.scopeOf(m).id, m.text) === key)) throw new DomainError('MEMORY_DUPLICATE', '该范围内已存在相同记忆。', { status: 409 });
       const next = { ...memory, originalText: memory.originalText || memory.text, captureFingerprint: memory.captureFingerprint || fingerprint(brainId, old.type, old.id, memory.originalText || memory.text), fingerprint: key, scopeType: type, scopeId: targetId, text, status: input.status || memory.status, updatedAt: new Date().toISOString() };
       const before = this.store.state.memories;
       this.store.state.memories = before.map(m => m.id === id ? next : m);
@@ -182,6 +192,41 @@ class MemoryService {
     this.writes.add(job);
     try { return await job; } finally { this.writes.delete(job); }
   }
+  async remove(id) {
+    if (this.closed) throw new DomainError('PROJECT_BUSY', '引擎正在关闭，请稍后重试。', { status: 409 });
+    if (typeof id !== 'string' || !id.trim()) throw new DomainError('INVALID_ARGUMENT', '记忆 ID 无效。');
+    const job = AtomicFile.withFileLock(this.lock(), async () => {
+      const memory = this.store.state.memories.find(m => m.id === id);
+      if (!memory || memory.status === 'deleted') throw new DomainError('PROJECT_NOT_FOUND', '记忆不存在。', { status: 404 });
+      const brainId = memory.brainId || 'brain-default', scope = this.scopeOf(memory);
+      // A tombstone keeps only the dedup fingerprints and audit metadata; the
+      // text and quote are dropped so a deleted memory never returns through
+      // lists, markdown, retrieval or context injection, and the fingerprints
+      // stop the same candidate from coming back on the next capture. Legacy
+      // records may predate originalText/captureFingerprint/createdAt, so both
+      // keys are always computed from the live record, and a stored original
+      // capture key from before an edit or scope move is preserved separately.
+      const now = new Date().toISOString();
+      const captureKey = fingerprint(brainId, scope.type, scope.id, memory.originalText || memory.text);
+      const originalCaptureKey = typeof memory.captureFingerprint === 'string' && /^[a-f0-9]{64}$/.test(memory.captureFingerprint) && memory.captureFingerprint !== captureKey ? memory.captureFingerprint : null;
+      const tombstone = {
+        id: memory.id, brainId, scopeType: scope.type, scopeId: scope.id,
+        ...(memory.sourceType !== undefined ? { sourceType: memory.sourceType } : {}),
+        status: 'deleted',
+        fingerprint: fingerprint(brainId, scope.type, scope.id, memory.text),
+        captureFingerprint: captureKey,
+        ...(originalCaptureKey ? { originalCaptureFingerprint: originalCaptureKey } : {}),
+        evidence: memory.evidence ? { projectId: memory.evidence.projectId, commitSha: memory.evidence.commitSha, runId: memory.evidence.runId || null, entryId: memory.evidence.entryId || '' } : null,
+        createdAt: typeof memory.createdAt === 'string' && Number.isFinite(Date.parse(memory.createdAt)) ? memory.createdAt : now, updatedAt: now, deletedAt: now,
+      };
+      const before = this.store.state.memories;
+      this.store.state.memories = before.map(m => m.id === id ? tombstone : m);
+      try { this.store.save(); } catch (error) { this.store.state.memories = before; throw error; }
+      await this.materialize(); return this.project(tombstone);
+    });
+    this.writes.add(job);
+    try { return await job; } finally { this.writes.delete(job); }
+  }
   content(brainId, entry = 'memories/confirmed.md') {
     return '# 已确认的长期记忆\n\n' + this.confirmed(brainId, entry).map(m => {
       const scope = this.scopeOf(m);

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

@@ -115,6 +115,11 @@ async function api(method, pathname, search, body, store, coordinator, ctx) {
     coordinator.emit('progress', store.addEvent({ type: 'memory.updated', summary: memory.status === 'confirmed' ? '已确认长期记忆' : memory.status === 'ignored' ? '已忽略记忆候选' : '已编辑记忆候选' }));
     return { memory };
   }
+  if (method === 'DELETE' && memoryMatch) {
+    const memory = await coordinator.memories.remove(decodeURIComponent(memoryMatch[1]));
+    coordinator.emit('progress', store.addEvent({ type: 'memory.deleted', summary: '已删除长期记忆' }));
+    return { memory };
+  }
   if (method === 'POST' && pathname === '/api/projects') {
     const result = store.addProject(body);
     if (!result.reused) store.addEvent({ type: 'project.register', projectId: body.projectId, summary: `登记 ${result.project.name}` });

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

@@ -40,8 +40,18 @@ class EngineStore {
       for (const [journalId, sequence] of Object.entries(raw.journalCursors || {})) if (!/^(global|sha256:[a-f0-9]{64})$/.test(journalId) || !Number.isSafeInteger(sequence) || sequence < 0) throw new Error('Invalid journal cursor');
       for (const scope of raw.sharedScopes || []) if (!scope || !['brain', 'domain'].includes(scope.kind) || !path.isAbsolute(scope.knowledgePath || '')) throw new Error('Invalid shared scope');
       for (const memory of raw.memories || []) {
-        if (!memory || !['candidate', 'confirmed', 'ignored'].includes(memory.status) || typeof memory.text !== 'string' || memory.sourceType !== undefined && !['manual', 'agent'].includes(memory.sourceType)) throw new Error('Invalid memory record');
-        if (memory.sourceType === 'manual') {
+        if (!memory || !['candidate', 'confirmed', 'ignored', 'deleted'].includes(memory.status) || memory.sourceType !== undefined && !['manual', 'agent'].includes(memory.sourceType)) throw new Error('Invalid memory record');
+        if (memory.status === 'deleted') {
+          // Tombstones carry no text: the dedup fingerprint and audit metadata
+          // are the whole record, so validate those instead of the live shape.
+          validateProjectId(memory.brainId);
+          // R101: the `memory-` prefix is only a generation convention; records
+          // written before it (any stable non-empty string id, ASCII or
+          // Unicode) load and delete legally, and the id never reaches a file
+          // path — so the tombstone validates the same id contract they had.
+          if (typeof memory.id !== 'string' || !memory.id || typeof memory.fingerprint !== 'string' || !/^[a-f0-9]{64}$/.test(memory.fingerprint) || memory.captureFingerprint !== undefined && !/^[a-f0-9]{64}$/.test(memory.captureFingerprint) || memory.originalCaptureFingerprint !== undefined && !/^[a-f0-9]{64}$/.test(memory.originalCaptureFingerprint) || memory.evidence !== null && (!memory.evidence.projectId || !/^[a-f0-9]{40}$/.test(memory.evidence.commitSha || '')) || !Number.isFinite(Date.parse(memory.createdAt)) || !Number.isFinite(Date.parse(memory.deletedAt))) throw new Error('Invalid deleted memory record');
+        } else if (typeof memory.text !== 'string') throw new Error('Invalid memory record');
+        else if (memory.sourceType === 'manual') {
           validateProjectId(memory.brainId);
           if (memory.status === 'candidate' || !memory.text.trim() || memory.text.length > 2000 || !memory.scopeType || memory.evidence !== null || !Number.isFinite(Date.parse(memory.createdAt)) || !Number.isFinite(Date.parse(memory.updatedAt))) throw new Error('Invalid manual memory record');
         } else if (!memory.evidence?.projectId || !/^[a-f0-9]{40}$/.test(memory.evidence.commitSha || '')) throw new Error('Invalid memory evidence');

package/_site/_test/helpers/qa-r91-harness.cjs

@@ -0,0 +1,531 @@
+'use strict';
+// _site/_test/helpers/qa-r91-harness.cjs — P-MEMORY-DELETE-R91
+//
+// Copy of helpers/parallel-memory-shell.js (the P-MEMORY-01 lane harness)
+// with exactly one product difference: the in-process knowledge engine is
+// loaded from the R91 SOURCE CHECKOUT (sibling knowledge-engine repository,
+// override with QA_R91_ENGINE_SRC) instead of the root's _modules pin, so
+// the browser exercises the lane's own delete implementation. The installed
+// core modules and the _modules pin are never touched.
+//
+// Everything else keeps the original lane discipline: own port/data dir/
+// knowledge root/bridge journal home, declared stand-in analyzer, token
+// pass-through proxy in front of the engine, real HTTP module services,
+// real Chrome in its own profile, and no contact with the live
+// 5757/5790/8787/8790 endpoints, the real HOME or the real memories.
+//
+// R99 (P-MEMORY-RELEASE-PREP-R99): startHarness({ productRoot }) — or the
+// QA_R91_PRODUCT_ROOT env — runs the SAME isolated acceptance against an
+// explicitly chosen OFFICIAL installed prefix: the spawned product server,
+// its cwd and the static UI come from <productRoot>/_site/lib/server-app.js,
+// and the in-process engine defaults to the prefix's vendored
+// _modules/knowledge-engine (QA_R91_ENGINE_SRC still overrides). Helpers,
+// isolation and stand-in analyzers stay canonical. Invalid roots are
+// rejected by resolveProductRoot BEFORE any spawn; the default source-root
+// behaviour is unchanged.
+
+const assert = require('node:assert/strict');
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const { spawnServer } = require('../helpers/spawn-server');
+const { findChrome } = require('../helpers/find-chrome');
+const { launchCdpBrowser, waitFor } = require('../helpers/cdp-browser');
+const { attachNetworkCapture } = require('../helpers/cdp-network-capture');
+const { createModuleFixture, createUpstreamProxy } = require('../helpers/module-fixture');
+const freePort = require('../helpers/free-port');
+const { createMemoryStandinAnalyzer } = require('./parallel-memory-analyzer');
+const { createEventBridgeStandin } = require('./parallel-memory-event-bridge');
+const { applyDriverIsolation } = require('./parallel-qa-engine-endpoint-isolate');
+const { assertOwnedEndpoint, createEngineVectorStandin } = require('./parallel-qa-engine-endpoint-guard');
+
+const ROOT = path.resolve(__dirname, '../../..');
+const LIVE_PORTS = new Set([5757, 5760, 5790, 8787, 8790]);
+const ENGINE_SRC_ENV = process.env.QA_R91_ENGINE_SRC;
+const ENGINE_SOURCE_ROOT = path.resolve(ENGINE_SRC_ENV || path.join(ROOT, '..', 'knowledge-engine'));
+const ENGINE_SOURCE_SERVER = path.join(ENGINE_SOURCE_ROOT, 'src', 'server.js');
+// R99: captured at MODULE LOAD, before applyDriverIsolation can replace the
+// process environment (the isolate helper wipes process.env). These are the
+// REAL system locations a product root must never live in: the live npm
+// global prefix, per-user program installs, Program Files, and any prefix
+// surfaced through NPM_CONFIG_PREFIX. Reading them later would see the
+// ISOLATED values and the protection would silently vanish.
+const REAL_ENV_MARKERS = {
+  appdata: process.env.APPDATA,
+  localAppdata: process.env.LOCALAPPDATA,
+  programFiles: process.env.ProgramFiles,
+  programFilesX86: process.env['ProgramFiles(x86)'],
+  npmConfigPrefix: process.env.NPM_CONFIG_PREFIX,
+};
+const PRODUCT_ROOT_ENV = process.env.QA_R91_PRODUCT_ROOT;
+const DENY_ROOTS_ENV = process.env.QA_R99_DENY_ROOTS;
+
+const PRODUCT_SITE_ENTRY = path.join('_site', 'lib', 'server-app.js');
+
+function invalidProductRoot(reason, detail) {
+  return Object.assign(new Error(`QA_R91_PRODUCT_ROOT ${reason}: ${detail}`), { code: 'INVALID_PRODUCT_ROOT', reason });
+}
+
+function pathInside(parent, child) {
+  const rel = path.relative(path.resolve(parent), path.resolve(child));
+  return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+
+// R99: validates an explicitly chosen product root for official-artifact
+// acceptance. A product root is where a REAL installed prefix lives: the
+// spawned server, its cwd and its static UI all come from
+// <root>/_site/lib/server-app.js. Location rules run BEFORE the existence
+// check, so a protected location is rejected deterministically even when the
+// path does not exist yet. The canonical source checkout stays reachable
+// only through the DEFAULT behaviour (no productRoot).
+function resolveProductRoot(candidate) {
+  if (typeof candidate !== 'string' || candidate.trim() === '') {
+    throw invalidProductRoot('NOT_ABSOLUTE', `the product root must be a non-empty absolute path, got ${JSON.stringify(candidate)}`);
+  }
+  if (!path.isAbsolute(candidate)) {
+    throw invalidProductRoot('NOT_ABSOLUTE', `relative product root ${JSON.stringify(candidate)} — the official prefix must be given as an absolute path`);
+  }
+  const root = path.resolve(candidate);
+
+  const protectedLocations = [];
+  if (REAL_ENV_MARKERS.appdata) protectedLocations.push({ label: 'the live npm global prefix', dir: path.join(REAL_ENV_MARKERS.appdata, 'npm') });
+  if (REAL_ENV_MARKERS.localAppdata) protectedLocations.push({ label: 'per-user program installs', dir: path.join(REAL_ENV_MARKERS.localAppdata, 'Programs') });
+  if (REAL_ENV_MARKERS.programFiles) protectedLocations.push({ label: 'Program Files', dir: REAL_ENV_MARKERS.programFiles });
+  if (REAL_ENV_MARKERS.programFilesX86) protectedLocations.push({ label: 'Program Files (x86)', dir: REAL_ENV_MARKERS.programFilesX86 });
+  if (REAL_ENV_MARKERS.npmConfigPrefix) protectedLocations.push({ label: 'NPM_CONFIG_PREFIX', dir: REAL_ENV_MARKERS.npmConfigPrefix });
+  for (const deny of (DENY_ROOTS_ENV || '').split(path.delimiter).map(entry => entry.trim()).filter(Boolean)) {
+    protectedLocations.push({ label: 'QA_R99_DENY_ROOTS', dir: deny });
+  }
+  for (const spot of protectedLocations) {
+    if (pathInside(spot.dir, root)) throw invalidProductRoot('PROTECTED_LOCATION', `${root} is inside ${spot.label} ${spot.dir} — the real installed prefix must never be a test root`);
+  }
+  // A product root must be a separate installed location: the canonical
+  // source checkout and the engine source checkout are not official prefixes
+  // (and overlapping them in either direction would blur source/default runs).
+  for (const spot of [{ label: 'the canonical test repository', dir: ROOT }, { label: 'the engine source checkout', dir: ENGINE_SOURCE_ROOT }]) {
+    if (pathInside(spot.dir, root) || pathInside(root, spot.dir)) throw invalidProductRoot('PROTECTED_SOURCE_ROOT', `${root} overlaps ${spot.label} ${spot.dir}`);
+  }
+
+  if (!fs.existsSync(root)) throw invalidProductRoot('MISSING_ROOT', `${root} does not exist`);
+  const siteEntry = path.join(root, PRODUCT_SITE_ENTRY);
+  if (!fs.existsSync(siteEntry)) throw invalidProductRoot('MISSING_SITE_ENTRY', `${siteEntry} not found — not a product prefix`);
+  let packageJson;
+  try {
+    packageJson = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+  } catch (error) {
+    throw invalidProductRoot('INVALID_PACKAGE', `package.json unreadable: ${error.message}`);
+  }
+  if (!packageJson || typeof packageJson.name !== 'string' || !packageJson.name || typeof packageJson.version !== 'string' || !packageJson.version) {
+    throw invalidProductRoot('INVALID_PACKAGE', `package.json must carry name and version, got ${JSON.stringify({ name: packageJson && packageJson.name, version: packageJson && packageJson.version })}`);
+  }
+  return { root, packageJson, siteEntry, engineRoot: path.join(root, '_modules', 'knowledge-engine') };
+}
+
+function r91CreateEngineServer(options = {}, engineSourceRoot = ENGINE_SOURCE_ROOT) {
+  // Same fail-closed endpoint discipline as the R5 guard, but the module is
+  // the R91 source checkout under review (or, under a product root, the
+  // prefix's vendored engine).
+  const engineServerPath = path.join(engineSourceRoot, 'src', 'server.js');
+  if (!fs.existsSync(engineServerPath)) throw new Error(`R91 engine source not found: ${engineServerPath}`);
+  assertOwnedEndpoint(options.vectorUrl, { role: 'vectorUrl' });
+  if (options.bridge === undefined) assertOwnedEndpoint(options.bridgeUrl, { role: 'bridgeUrl' });
+  const { createEngineServer } = require(engineServerPath);
+  return createEngineServer(options);
+}
+
+function git(cwd, args) {
+  const result = spawnSync('git', ['-C', cwd, ...args], { encoding: 'utf8', windowsHide: true, env: { ...process.env, GIT_TERMINAL_PROMPT: '0' } });
+  assert.equal(result.status, 0, `git ${args.join(' ')} failed: ${result.stderr}`);
+  return String(result.stdout || '').trim();
+}
+
+/** A real Git repository with real commits: the product imports it for real. */
+function makeRepo(root, name, files = { 'README.md': `# ${name}\n` }) {
+  const repo = path.join(root, name);
+  fs.mkdirSync(repo, { recursive: true });
+  git(repo, ['init', '-q', '-b', 'main']);
+  git(repo, ['config', 'user.email', 'qa-r91@local.invalid']);
+  git(repo, ['config', 'user.name', 'QA R91 Regression']);
+  git(repo, ['config', 'commit.gpgsign', 'false']);
+  for (const [file, content] of Object.entries(files)) fs.writeFileSync(path.join(repo, file), content, 'utf8');
+  git(repo, ['add', '.']);
+  git(repo, ['commit', '-qm', 'baseline']);
+  return { path: repo, headCommit: git(repo, ['rev-parse', 'HEAD']) };
+}
+
+function commitFile(repo, file, content, message = 'follow-up') {
+  const full = path.join(repo.path, file);
+  fs.mkdirSync(path.dirname(full), { recursive: true });
+  // R94: every fixture commit must be MEANINGFUL. Re-committing identical
+  // bytes leaves nothing to stage and fails the git assert; instead the file
+  // gains a distinct revision line so the repository always moves forward
+  // with a real, distinct commit.
+  let revision = 0;
+  do {
+    fs.writeFileSync(full, revision === 0 ? content : `${content}\n// qa-revision-${revision}\n`, 'utf8');
+    revision += 1;
+  } while (git(repo.path, ['status', '--porcelain']).length === 0 && revision < 50);
+  git(repo.path, ['add', '.']);
+  git(repo.path, ['commit', '-qm', message]);
+  repo.headCommit = git(repo.path, ['rev-parse', 'HEAD']);
+  return repo.headCommit;
+}
+
+async function startHarness({ tag, evidenceDir, productRoot, viewport = { width: 1600, height: 900 } } = {}) {
+  // R99: validate an explicit product root BEFORE isolation and BEFORE any
+  // spawn — a bad root fails synchronously here, no child process starts.
+  // Without productRoot (option or QA_R91_PRODUCT_ROOT env) the default
+  // source-root behaviour is byte-for-byte unchanged.
+  const requestedProductRoot = productRoot || PRODUCT_ROOT_ENV || null;
+  const product = requestedProductRoot ? resolveProductRoot(requestedProductRoot) : null;
+  // Engine source: an explicit QA_R91_ENGINE_SRC always wins; under a product
+  // root the default becomes the prefix's vendored engine; otherwise the
+  // sibling source checkout (unchanged default).
+  const harnessEngineSource = ENGINE_SRC_ENV ? ENGINE_SOURCE_ROOT : (product ? product.engineRoot : ENGINE_SOURCE_ROOT);
+  if (product && !fs.existsSync(path.join(harnessEngineSource, 'src', 'server.js'))) {
+    throw invalidProductRoot('MISSING_PRODUCT_ENGINE', `no vendored engine under the official prefix: ${path.join(harnessEngineSource, 'src', 'server.js')} (set QA_R91_ENGINE_SRC to override)`);
+  }
+
+  const applied = applyDriverIsolation({ prefix: `pk-qa-r91-${tag}`, captureChrome: true });
+  const tempRoot = applied.layout.temp;
+
+  const fixture = fs.mkdtempSync(path.join(tempRoot, `pk-qa-r91-${tag}-`));
+  const evidence = evidenceDir || path.join(fixture, 'evidence');
+  fs.mkdirSync(evidence, { recursive: true });
+  const dataDir = path.join(fixture, 'data');
+  const knowledgeRoot = path.join(fixture, 'knowledge');
+  fs.mkdirSync(knowledgeRoot, { recursive: true });
+
+  const plan = { document: '', memoryCandidates: [] };
+  const engineToken = crypto.randomBytes(24).toString('hex');
+  const engineVector = createEngineVectorStandin({ label: 'r91-engine-vector' });
+  await engineVector.ready;
+  const terminal = createModuleFixture({ kind: 'terminal', tag: `${tag}-terminal` });
+  const vectorHub = createModuleFixture({ kind: 'vectorHub', tag: `${tag}-vectorhub` });
+  const eventBridge = await createEventBridgeStandin({ tag: `${tag}-eventbridge` });
+  await terminal.start();
+  await vectorHub.start();
+  await eventBridge.start();
+
+  const engineDataDir = path.join(fixture, 'engine');
+  // R94: `let`, not `const` — restartEngine reassigns this handle so cleanup
+  // and every in-process helper always act on the LIVE engine (closing the
+  // closed original left the restarted server handle open and hung Node).
+  let engine = r91CreateEngineServer({
+    dataDir: engineDataDir,
+    runtimeToken: engineToken,
+    debug: true,
+    consume: false,
+    analyzer: createMemoryStandinAnalyzer({ plan }),
+    vectorUrl: engineVector.url,
+    bridgeUrl: eventBridge.url,
+  }, harnessEngineSource);
+  await engine.ready;
+  await new Promise(resolve => engine.server.listen(0, '127.0.0.1', resolve));
+  const enginePort = engine.server.address().port;
+  assert.equal(LIVE_PORTS.has(enginePort), false, 'the lane engine must never use a live port');
+  const engineUrl = `http://127.0.0.1:${enginePort}`;
+  const engineProxy = createUpstreamProxy({ target: engineUrl, token: engineToken, tag: 'engine' });
+  await engineProxy.start();
+
+  const port = await freePort();
+  const base = `http://127.0.0.1:${port}`;
+  const server = spawnServer({
+    // R99: under a product root the SERVER, its cwd and the static UI come
+    // from the official prefix; helpers and fixtures stay canonical.
+    root: product ? product.root : ROOT,
+    port,
+    dataDir,
+    tag: `qa-r91-${tag}`,
+    analysisOwner: 'engine',
+    extraEnv: {
+      KB_MODULES_REGISTER: '1',
+      KB_MODULES_AUTOSTART: '0',
+      KB_TERMINAL_URL: terminal.url,
+      KB_VECTORHUB_URL: vectorHub.url,
+      KB_EVENTBRIDGE_URL: eventBridge.url,
+      KB_KNOWLEDGE_ENGINE_URL: engineProxy.url,
+    },
+  });
+
+  const productApi = async (method, route, body) => {
+    const response = await fetch(base + route, {
+      method,
+      headers: body === undefined ? undefined : { 'Content-Type': 'application/json' },
+      body: body === undefined ? undefined : JSON.stringify(body),
+      signal: AbortSignal.timeout(20000),
+    });
+    return { status: response.status, body: await response.json().catch(() => null) };
+  };
+
+  const engineApi = async (method, route, body) => {
+    const response = await fetch(engineUrl + route, {
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        ...(engineToken ? { Authorization: `Bearer ${engineToken}` } : {}),
+      },
+      body: body === undefined ? undefined : JSON.stringify(body),
+      signal: AbortSignal.timeout(20000),
+    });
+    return { status: response.status, body: await response.json().catch(() => null) };
+  };
+
+  await waitFor(async () => {
+    try { return (await productApi('GET', '/api/health')).status === 200; } catch { return false; }
+  }, 'the isolated product instance', 30000);
+  const settings = await productApi('PATCH', '/api/settings', { knowledge: { rootPath: knowledgeRoot } });
+  assert.equal(settings.status, 200, `the isolated instance accepts its own knowledge root: ${JSON.stringify(settings.body)}`);
+
+  let browser = null;
+  let network = null;
+  try {
+    browser = await launchCdpBrowser({
+      chrome: findChrome(),
+      profileDir: path.join(fixture, 'browser'),
+      url: `${base}/`,
+      width: viewport.width,
+      height: viewport.height,
+    });
+    await browser.setViewport(viewport.width, viewport.height);
+    await browser.send('Network.enable');
+    network = attachNetworkCapture(browser);
+  } catch (error) {
+    await server.cleanup();
+    await engineProxy.close();
+    await terminal.close();
+    await vectorHub.close();
+    await eventBridge.close();
+    await engine.close().catch(() => {});
+    fs.rmSync(fixture, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+    throw error;
+  }
+
+  const run = expression => browser.evaluate(expression);
+  const wait = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+  const reload = async () => {
+    const startedAt = Date.now();
+    await run('window.__pkShellReloadMark = Date.now(), true');
+    await browser.send('Page.reload', {});
+    await waitFor(
+      () => run("document.readyState === 'complete' && typeof window.__pkShellReloadMark === 'undefined' && document.querySelector('.view.active') !== null"),
+      'the reloaded page is the fresh document and its boot finished',
+      20000,
+    );
+    return Date.now() - startedAt;
+  };
+
+  const selectOption = async (selector, value) => {
+    const changed = await run(`(() => {
+      const el = document.querySelector(${JSON.stringify(selector)});
+      if (!el) return { missing: true };
+      el.value = ${JSON.stringify(value)};
+      el.dispatchEvent(new Event('change', { bubbles: true }));
+      return { value: el.value };
+    })()`);
+    assert.ok(changed && !changed.missing, `the select ${selector} must exist`);
+    assert.equal(changed.value, value, `the select ${selector} must accept the value ${value}`);
+  };
+
+  const nativeClick = async selector => {
+    const probe = await run(`(() => {
+      const el = document.querySelector(${JSON.stringify(selector)});
+      if (!el) return { missing: true };
+      const rect = el.getBoundingClientRect();
+      if (rect.width <= 0 || rect.height <= 0) return { invisible: true };
+      const x = rect.left + rect.width / 2;
+      const y = rect.top + rect.height / 2;
+      const hit = document.elementFromPoint(x, y);
+      return { x, y, hitIsTarget: Boolean(hit && (hit === el || el.contains(hit))), label: (el.textContent || '').trim().slice(0, 40) };
+    })()`);
+    assert.ok(probe && !probe.missing, `the control ${selector} must exist in the page`);
+    assert.ok(!probe.invisible, `the control ${selector} must be visible`);
+    assert.ok(probe.hitIsTarget, `the control ${selector} must be the hit target; something else is on top`);
+    const common = { x: probe.x, y: probe.y, button: 'left', clickCount: 1 };
+    await browser.send('Input.dispatchMouseEvent', { type: 'mouseMoved', x: probe.x, y: probe.y, button: 'none', clickCount: 0 });
+    await browser.send('Input.dispatchMouseEvent', { type: 'mousePressed', ...common });
+    await browser.send('Input.dispatchMouseEvent', { type: 'mouseReleased', ...common });
+    return probe;
+  };
+
+  const typeText = async text => {
+    for (const character of String(text)) {
+      const upper = character.toUpperCase();
+      const isLower = character >= 'a' && character <= 'z';
+      const isUpper = character >= 'A' && character <= 'Z';
+      const isDigit = character >= '0' && character <= '9';
+      const code = isLower ? `Key${upper}` : isUpper ? `Key${character}` : isDigit ? `Digit${character}` : '';
+      const keyCode = isLower ? upper.charCodeAt(0) : isUpper || isDigit ? character.charCodeAt(0) : 0;
+      const base = { key: character, code, windowsVirtualKeyCode: keyCode, nativeVirtualKeyCode: keyCode };
+      await browser.send('Input.dispatchKeyEvent', { type: 'keyDown', ...base, text: character, unmodifiedText: character });
+      await browser.send('Input.dispatchKeyEvent', { type: 'keyUp', ...base });
+    }
+  };
+
+  const importProject = async (repo, displayName, { domainId } = {}) => {
+    const knowledgePath = path.join(knowledgeRoot, displayName);
+    fs.mkdirSync(knowledgePath, { recursive: true });
+    const result = await productApi('POST', '/api/projects/import', { localPath: repo.path, knowledgePath, displayName });
+    assert.equal(result.status, 201, `the project import must succeed: ${JSON.stringify(result.body)}`);
+    const projectId = result.body.projectId;
+    if (domainId) {
+      const patched = await productApi('PATCH', `/api/projects/${encodeURIComponent(projectId)}`, { domainId });
+      assert.equal(patched.status, 200, `the domain binding must succeed: ${JSON.stringify(patched.body)}`);
+    }
+    return { projectId, project: result.body.project, knowledgePath, modules: result.body.modules };
+  };
+
+  const addDomain = async name => {
+    const result = await productApi('POST', '/api/domains', { name });
+    assert.equal(result.status, 201, `the brain domain must be accepted: ${JSON.stringify(result.body)}`);
+    return result.body.domain;
+  };
+
+  const brainScopePath = () => {
+    const scope = engine.store.state.sharedScopes.find(entry => entry.kind === 'brain');
+    assert.ok(scope, 'the engine must know the brain scope');
+    return scope.knowledgePath;
+  };
+
+  const productMemories = async () => {
+    const snapshot = await productApi('GET', '/api/engine/snapshot?summary=1&limit=50');
+    assert.equal(snapshot.status, 200, `the product snapshot must be readable: ${JSON.stringify(snapshot.body)}`);
+    return snapshot.body.memories || [];
+  };
+
+  const injectedMemories = async projectId => {
+    const context = await engineApi('POST', '/api/context', { projectId, query: '长期记忆', task: 'qa-r91' });
+    assert.equal(context.status, 200, `the engine context must be readable: ${JSON.stringify(context.body)}`);
+    return context.body.memories || [];
+  };
+
+  const memoryCandidate = ({ text, event, scopeType = 'global' }) => ({
+    text,
+    quote: text,
+    scopeType,
+    sourceEventId: event.eventId,
+    sourceHash: event.contentHash,
+    eligibility: {
+      durable: true,
+      crossProject: true,
+      reason: '人工明确表达的长期偏好',
+      scopeReason: scopeType === 'global' ? '适用于所有领域与项目' : '适用于指定领域',
+    },
+  });
+
+  const ingestUserEvent = async ({ projectId, commitSha, content, inputOrigin = 'human' }) => {
+    const id = `event-${crypto.randomUUID()}`;
+    const turn = `turn-${crypto.randomUUID()}`;
+    const result = await engine.coordinator.conversations.appendEvent(projectId, {
+      eventId: id,
+      sequence: 1,
+      source: 'claude-code',
+      eventType: 'user_prompt',
+      role: 'user',
+      inputOrigin,
+      content,
+      sessionId: `session-${projectId}`,
+      turnId: turn,
+      capturedAt: new Date().toISOString(),
+      identityConfidence: 'exact',
+      explicitCommitSha: commitSha,
+    });
+    return { eventId: id, turnId: turn, contentHash: result.event.contentHash, inputOrigin: result.event.inputOrigin };
+  };
+
+  const triggerRun = async (projectId, commitSha, timeoutMs = 60000) => {
+    const started = await engineApi('POST', '/api/runs', { projectId, commitSha });
+    assert.equal(started.status, 200, `the run must be accepted: ${JSON.stringify(started.body)}`);
+    const runId = started.body.run.runId;
+    const deadline = Date.now() + timeoutMs;
+    let last = null;
+    while (Date.now() < deadline) {
+      const current = await engineApi('GET', `/api/runs/${encodeURIComponent(runId)}`);
+      last = current.body && current.body.run;
+      if (last && ['succeeded', 'failed'].includes(last.state)) {
+        if (last.state === 'failed') throw new Error(`the run failed: ${JSON.stringify(last.error)}`);
+        return last;
+      }
+      if (last && last.promotedAt && last.memoryCapture) return last;
+      await wait(150);
+    }
+    throw new Error(`the run did not finish in time: ${JSON.stringify(last)}`);
+  };
+
+  const produceCandidate = async ({ repo, projectId, text, scopeType = 'global', file = 'src/candidate.js' }) => {
+    const head = commitFile(repo, file, `// ${text}\n`, 'candidate commit');
+    const event = await ingestUserEvent({ projectId, commitSha: head, content: `人工要求：${text}` });
+    plan.document = `# 冻结证据\n\n${text}\n`;
+    plan.memoryCandidates = [memoryCandidate({ text, event, scopeType })];
+    const run = await triggerRun(projectId, head);
+    return { run, event, commitSha: head, capture: run.memoryCapture };
+  };
+
+  // Restart the in-process engine on its own data dir and port: the shell's
+  // proxy keeps its target, so the browser sees a real engine restart.
+  // R94: the handle is REASSIGNED, so cleanup()/brainScopePath() always act
+  // on the live restarted engine, never on the already-closed original.
+  const restartEngine = async () => {
+    await engine.close();
+    engine = r91CreateEngineServer({
+      dataDir: engineDataDir,
+      runtimeToken: engineToken,
+      debug: true,
+      consume: false,
+      analyzer: createMemoryStandinAnalyzer({ plan }),
+      vectorUrl: engineVector.url,
+      bridgeUrl: eventBridge.url,
+    }, harnessEngineSource);
+    await engine.ready;
+    await new Promise(resolve => engine.server.listen(enginePort, '127.0.0.1', resolve));
+    return engine;
+  };
+
+  // R94: every cleanup step is bounded. A wedged child or an uncooperative
+  // close used to turn the whole driver into an unkillable lane process (the
+  // Node 17840 hang was exactly this); each step now gets a deadline and a
+  // failure is reported instead of blocking the teardown forever.
+  const cleanupStep = async (label, task, deadlineMs = 15000) => {
+    let timer = null;
+    try {
+      await Promise.race([
+        Promise.resolve().then(task).catch(error => { console.error(`[qa-r91-harness] cleanup step ${label} failed:`, error && error.message); }),
+        new Promise(resolve => { timer = setTimeout(resolve, deadlineMs); if (typeof timer.unref === 'function') timer.unref(); }),
+      ]);
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+
+  const cleanup = async () => {
+    await cleanupStep('browser', () => browser?.close() || Promise.resolve());
+    await cleanupStep('server', () => server.cleanup());
+    await cleanupStep('engineProxy', () => engineProxy.close());
+    await cleanupStep('terminal', () => terminal.close());
+    await cleanupStep('vectorHub', () => vectorHub.close());
+    await cleanupStep('eventBridge', () => eventBridge.close());
+    await cleanupStep('engine', () => engine.close());
+    await cleanupStep('engineVector', () => engineVector.close());
+    fs.rmSync(fixture, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+  };
+
+  return {
+    fixture, evidence, dataDir, knowledgeRoot, tempRoot, plan,
+    base, server, productApi, engineApi, engineUrl, enginePort, engineProxy, engineDataDir,
+    terminal, vectorHub, eventBridge, engineVector,
+    // R94: a getter, not a snapshot — harness.engine always resolves to the
+    // LIVE engine handle after restartEngine().
+    get engine() { return engine; },
+    browser, run, wait, waitFor, network, reload,
+    selectOption, nativeClick, typeText,
+    importProject, addDomain, ingestUserEvent, triggerRun,
+    brainScopePath, productMemories, injectedMemories,
+    memoryCandidate, produceCandidate, restartEngine,
+    cleanup,
+  };
+}
+
+module.exports = { startHarness, makeRepo, commitFile, resolveProductRoot, ROOT, ENGINE_SOURCE_ROOT, REAL_ENV_MARKERS, PRODUCT_SITE_ENTRY };

package/module-runtime-manifest.json

@@ -1,19 +1,19 @@
 {
   "schema": "project-knowledge/module-content/v1",
   "productFiles": {
-    "ui/index.html": "f7e87c2006f27f4d1824c0f3778a03160a530ccb15346323944a07584e05e8d8",
+    "ui/index.html": "e7758ae86968ea78f6f7ad591def9695bb4551056d7a6ac54adad6aafe381733",
     "ui/knowledge-panel.html": "dfd85f15759472252d797853263e9da0054b251c56bb9ccdc8a75e6301334ca8",
-    "ui/product.js": "26b2cc5438fdc331c0aeb1f77bdb1c8340ca1468211f78a5348d84706e953feb",
+    "ui/product.js": "8c0d9b64872f5770f14e525401f9cce8b5dcd3c4c78977c83ade6258b093c57d",
     "ui/live-client.js": "0d81fa894c629bb839e1931fc3c5ebad4d831aae8232d6ce8c0f542e9e3559e8",
-    "ui/product.css": "7347c47148891b7799b5d3711baff1c7fe5db08c6209c30c391d6aee7eb30be8",
+    "ui/product.css": "d24e57fcd49024ca44a49b80099a60258a34f553029e60c203a54527645d7e27",
     "ui/favicon.svg": "c48be946b224112ebb0238b44263f7a61bda31e531afa895c2e9801c0ff24f32",
     "plugins/project-knowledge/hooks/claude.json": "d61510327e3e1facbb4c645228e9f50cad05a88b33d80c4c22e5ba9f8b9f5359",
     "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": "69461540e532f7445db3a8d13a2d311a1718c0b9d0819b3809dfc580b17f6f57",
-    "plugins/project-knowledge/.codex-plugin/plugin.json": "87bcfbe7857526e622c72c3a0dd10b47d94d5009f17b065870dec81de829a178",
-    "plugins/project-knowledge/.mcp.json": "d4da3fa5d4e547604f4343f56ebfa5cb209503eded6ea4a2c54267cb268a9ef0",
+    "plugins/project-knowledge/.claude-plugin/plugin.json": "05540c83b56c758154c1b91e066f7e78ddfb98a4fab92e9f1b8dcea85bb9147e",
+    "plugins/project-knowledge/.codex-plugin/plugin.json": "065dceaa1cb91d3711f03887aba4bfbb4ff7f3cc6e21561b54b9ee79e33f74c4",
+    "plugins/project-knowledge/.mcp.json": "56b134a154c2a6b7814dd7efa52bdf9da279af45409b3df9be24c649f0ba616f",
     "ui/version-info.js": "01a82217b031de54b80d6c7974da9c70888c4c90a046bd4248a808f7989ddce7",
     "ui/version-info.css": "209fad8e42b661f72d2aba3280e1ca47768b5cefb776fe5459538d34fbad120f"
   },
@@ -21,14 +21,14 @@
     "terminal": {
       "name": "@sanqianx/claude-ai-workbench",
       "installName": "claude-ai-workbench",
-      "version": "0.13.10",
+      "version": "0.13.12",
       "files": {
         "LICENSE": "c1b9df1275e769f3dbab000d1e457a2d4b0f28eb5da6c77e48dc37eeba202ed7",
-        "README.md": "43938c8a64397d340dcf633edc40a7cea7dd8a95b5f82cf612b2c15b66c380b6",
+        "README.md": "557784a0c9c60e57c2ab0ad7d4d3a34f6c35198d021165e3adc961008baed056",
         "apps/agent-terminal/app.css": "6198b425dc1957380e7adc25212b4dc9345b58331976d19b374d2b22b682a18b",
-        "apps/agent-terminal/app.js": "4f22473d2aa1142d8e8101c5df14f365427ea8e7fbd05bdd33f2b1c5f64c59e9",
+        "apps/agent-terminal/app.js": "4f469f3e83d9778bb70d1d3ed737b6269f007f0764ae9e7da8dcc2594b23033c",
         "apps/agent-terminal/conversation-composer.js": "4f0135fa61f3a19de9bc518cb7001dcc333a793db6de643d4ee6eaa629489c58",
-        "apps/agent-terminal/index.html": "95c45bfccba80018cdf01b81ea18b486f8d7ecc862bf1f6e3c5dc272382bf30c",
+        "apps/agent-terminal/index.html": "8850d107bc2b9b118be09b4bdd0a57cbd56774ae2a9e68770fc907791ca0dd30",
         "apps/agent-terminal/panel-host-proof.html": "b4b5c69cbd4d019002dd63b364523875f9b5e58c75c8fa873ed05d3717229fa6",
         "apps/agent-terminal/panel-proof-content.html": "87f59cf76fc5e78aa24d51432d358aa15fc8242f469cabb164bf181d23f85778",
         "apps/agent-terminal/right-dock-panel-registry.js": "07a4b6d31b1b2d678f92b6f0786cf49129708bd38ef4a15976d824150cbadec6",
@@ -38,30 +38,29 @@
         "apps/ai-profile-settings-host/index.html": "bc158f68954506d2b8e43c690f28dbe931eff9a02b1524855ac17e74ea4df736",
         "apps/ai-profile-settings-host/page.css": "8b75cbf7f1ea5aaa92f2889390720ece310a8fd4b9ca38c890fa447d4323a557",
         "apps/ai-profile-settings-host/page.js": "8ab508cb50f9765d148cd93f4d4f4f440f94731dbf43850cfb51cca1c869b070",
-        "apps/minimal-test-host/README.md": "fa73136f4ee3865c2d91eb97b2e8c03679aa4688e44c1e1c8ec6e27d604b0de5",
         "apps/minimal-test-host/host.css": "b870f0816a1fcd27b73ed20b4785b46f95729e55a6a5a56624234c74a012a915",
         "apps/minimal-test-host/host.js": "c316871e616afe66898eb22a9fa71d8ed530886cdad1b1eb6ae870373994962a",
         "apps/minimal-test-host/index.html": "a43ca39a89d9877bc658efc02f9de26ecd68356bd35078dfa440e11b7ba11394",
         "apps/minimal-test-host/optional-mock/fault-injection.js": "4749c8210e5a2b9eab5c8b8188b9c9b2ce9dfc9bcb5eeb0d2d745042453f87f5",
+        "apps/minimal-test-host/README.md": "fa73136f4ee3865c2d91eb97b2e8c03679aa4688e44c1e1c8ec6e27d604b0de5",
         "docs/sdk/FILE_LAYOUT.md": "17882f96505c8161bfb66876684b9d2d3f50021a111b8b844502d3cb4e97870a",
         "docs/sdk/INTEGRATION.md": "d4c0c80d2d2fc610205102d703a429bfaa20f9f3a48f1718f5bab02ee90138df",
+        "docs/sdk/openapi.yaml": "3423cba522bfe441c28e0cb44f524a9bdd8fa7a2341ec1fc6b26d8af05940a37",
         "docs/sdk/README.md": "7ab591d39c36a3b84cfdf487ff567040ec453975f3ef0fba86dc822094667b61",
         "docs/sdk/SESSION_EVENTS.md": "a964f85616ae55e0743e5cf75bad43dee2f9055acad301b134b3553e825102d7",
-        "docs/sdk/openapi.yaml": "a768f48671c1d40dd703e36767b46d4b58efe9892a6718d5571b46c181bdcebc",
-        "package.json": "1a3a3d70a4013e68813ffb7c73989e42541ed94781c8888aaf182dbd85d7ff90",
+        "package.json": "8b4b3c26344c0b5b421c7b58ea8d6415673327a6237e7ba4e393837c871f3724",
+        "packages/client/index.d.ts": "4c4a00577ad427215d9b91d6794a98a4c0ede06bafcf7c9904e53363c7c8bf9d",
+        "packages/client/index.js": "5458fa35fd260178927ad6eb6e1a84cd8cce3e173260acf46872554e3e36ad65",
+        "packages/client/package.json": "f0974f7ecd19620b2917c7d19542e6d308a49e1c18326b2bcdfe1d4bba41ae46",
         "packages/client/README.md": "e0962d561dad6b50837b0f8099f6931aad14d2dabb683556b88aae0ff485b675",
-        "packages/client/index.d.ts": "0366cc96ff2e83814d0dcad34899a26068f7ab5d0b15f9f1c02a7e976db28215",
-        "packages/client/index.js": "493938f0ff357aea6db136fca216c6cfcb542d51f6628e1994a179b5ec296a12",
-        "packages/client/package.json": "65ee054aa54e3de419922f99b219ce144bd71397d7c82d585415839765553b30",
-        "packages/contracts/README.md": "44d83a3cc508cec6c5c20dfa1f2c08d5ea03e3afb2853639fdc0a9cc8eb5b9c8",
         "packages/contracts/index.d.ts": "2947ab3e5d4408afa7af5095e23733e983c6845994217cab202e737268f61da1",
-        "packages/contracts/index.js": "2640531e4ef5fd4ea5f56e63cc099f9d6357de7306ef9e6fe3dff3b97f3d9304",
-        "packages/contracts/package.json": "ed36a4e1e8027460d5d4068a56a0d44611ac75ced53cfd30ddec97167d60909a",
-        "packages/core/README.md": "e222c546104a168f1038d95c6c4efb8e5603edd6145ab2cab79cab977fb710e5",
+        "packages/contracts/index.js": "253f530ce74028e77748a09b5d32d775a9fb3e7f09c867613b06e074db7b8ab9",
+        "packages/contracts/package.json": "6e4b5300a7d37612f0e18d2b9f46dd0f6f7c197cd241a047f4169c138cc236d7",
+        "packages/contracts/README.md": "44d83a3cc508cec6c5c20dfa1f2c08d5ea03e3afb2853639fdc0a9cc8eb5b9c8",
         "packages/core/index.d.ts": "c95b24a13f8aeeb128497833cf298790563baca6036ea5d29a9d8daff53199d7",
         "packages/core/index.js": "825640d0edc7dd130f22da1f580d2cda355566a40b0b36e42e5f38909605bbfa",
-        "packages/core/package.json": "93a7f67ff91800570d93bd081124935fa14858e8e1a30ab8ed6cfd7f4ebf87c5",
-        "packages/server/README.md": "a34cfaa4f4e859008b44e2be8e1aafb56e97fe83e6129c968a8562945fa843f3",
+        "packages/core/package.json": "cddc0172abace3ed839eac53337c9e0c39f62ab912a36d3dba092f125c9f91a0",
+        "packages/core/README.md": "e222c546104a168f1038d95c6c4efb8e5603edd6145ab2cab79cab977fb710e5",
         "packages/server/bin/agent-terminal-server.js": "01ac54215f1fcbe64c4b78ce9cd83f66215177f67cdccddad30491c94f3b6746",
         "packages/server/bin/claude-workbench-server.js": "73fc7f1022b8cd5bbe8aed0eb105223e83627960e7208cffa6c29a2879932f38",
         "packages/server/bin/claude-workbench.js": "98dbd550d4d657056a75a190e7ee0dffd9f760fba58783f3ffb8d389ad7a32de",
@@ -88,9 +87,9 @@
         "packages/server/lib/drivers/zcode-profile-runtime.js": "77c5ac83551cc424375918863d4a31039984492c3a1c987a615a072ac7cb1f14",
         "packages/server/lib/event-stream.js": "cfbe8207594f004ed0ad65a907401eef833f641b94064fa88852b9ae8c15fe59",
         "packages/server/lib/folder-picker.js": "da2caf8b6a4c00a22556fe355d28d735d78dd814fa0aa7edfc6c4cde8ca8c384",
-        "packages/server/lib/history-prepare-worker.js": "26d5ad3cdd27e60ed0a9208ddced27bd8009455cf355709d522325fe06327026",
+        "packages/server/lib/history-prepare-worker.js": "5e5a4e0998a906ac4a98439c85c00e5122f4074eee7972b3875cf3db8587b1a9",
         "packages/server/lib/history-prepare.js": "27f9b67b1f4012d002c4464dfa837e5144dab9adcb5a41b0b9ae3b0d1d1c18b7",
-        "packages/server/lib/http-handler.js": "7dd1cfafac4d1d9b9603bc084d55c45548ab3d1fb12d015c8aec6271ca4db3ca",
+        "packages/server/lib/http-handler.js": "dedbd3938ec4b35c0730336d095ff8e08825217d1e3cdeccccbf0afc569f8fd9",
         "packages/server/lib/json-file.js": "4252b57abcd0aafa45c584bac98fcbaf09174774addbb5a4798b381a7aeb35cc",
         "packages/server/lib/knowledge-context.js": "c3d8a9545547c636e6cdf908be53bef4968e674d2aab235562e762e25c210c06",
         "packages/server/lib/model-detection.js": "fa52213200c1f1a1f00e463ada57c415bf1bd4e2aedfebd04de50750509d06cf",
@@ -100,20 +99,22 @@
         "packages/server/lib/project-store.js": "5225c78f3216340f01b99356496c8e2c2d9cfc6247954a3f00b273dd2cc5b692",
         "packages/server/lib/runtime-loader.js": "33e152cb630d986581946928d7ab7d25d53e63647a433b0c1ff4d02c32a6298f",
         "packages/server/lib/session-archive-store.js": "d3335b832a6e9fb9792991056f6596a997a4959efa6e62b60fb60133fb724196",
-        "packages/server/lib/session-history.js": "7f5121cfd13e240c074462da040bb47655e80edb1e03205db07603aa0538c638",
+        "packages/server/lib/session-history-main-index.js": "1a408f2f644e4dfc600640e0146cd18e9727b2cacaac80f29e11b24ab31cd617",
+        "packages/server/lib/session-history.js": "e935e5fd560a72baed2fe32dfbb395f6a63926019c7e78296f44fe4c1f914c16",
         "packages/server/lib/system-doctor.js": "d098a046f425e90ef25209be69d78beefdfd9c2af92f08068a9bfc52053a8f7d",
         "packages/server/lib/ui-preferences-store.js": "e108cb22e7cc1f3438704913d5401e01de2c0e717eb2abd3bdc4727209393819",
         "packages/server/lib/user-questions.js": "dc30f92095113279ab0bafe5aa4c16a48f97bad18bd13f0ca3ac74018254005a",
-        "packages/server/lib/workbench-service.js": "3a4262ce20cd531374850e427852f3d2870df07a94473a63c5362cc134f67ba8",
-        "packages/server/package.json": "be007aba64a79ca55e8bb09e4194cc07fc280aeb4741f180f4d5f3e0f365b4d2",
-        "packages/ui/README.md": "793c4a9c286fee23f39062a1976ca3afe9d2816dcdb55e156ba940e1ef514f89",
+        "packages/server/lib/workbench-service.js": "ea9fbf88139d3c476624354af0f237062b038ce201283d2d513eac6ef1fdcc42",
+        "packages/server/package.json": "dc9cc98f27b89a587b6f61a64956fa25b3e268228fca9eb593cc868820a761c8",
+        "packages/server/README.md": "a34cfaa4f4e859008b44e2be8e1aafb56e97fe83e6129c968a8562945fa843f3",
         "packages/ui/ai-profile-settings.d.ts": "10cdc96fb20c1f47a18a984638a26bd69972fc0cacf7bd56f4f64ead593e7a36",
         "packages/ui/ai-profile-settings.js": "3c7a75833a3c4f607739ecf71a0716e27c8594cecd9d84e2f8ac99498a59e0e7",
         "packages/ui/claude-terminal.d.ts": "2e8b4ae14f69ec791e2aacbec48ea2bc6e0076e0445a38e99cc477cf2e0a3011",
         "packages/ui/claude-terminal.js": "96bd217a4a7e4792ae3fbaaf46249ecee13b0f4e01fc6d25a1b8b22d8f8fe00c",
         "packages/ui/index.d.ts": "e547ab39640fe7519fb367b78442dc8a2c51b2efd17b66f8b0a003b154b36ead",
         "packages/ui/index.js": "f4394aabd395938f5c3fe587e430471d4033e83945a9b9c7e0149ad4040982c9",
-        "packages/ui/package.json": "690e1d78f7f307bc32b267fbb5c65fd278ef77b30eafc13266963eab5169bf8a",
+        "packages/ui/package.json": "3250143f06bdcd9e61296428af523680ac2bb6c1d5535465bb880bd53c9e17d1",
+        "packages/ui/README.md": "793c4a9c286fee23f39062a1976ca3afe9d2816dcdb55e156ba940e1ef514f89",
         "packages/ui/theme.css": "8f03a081272a7db11b196f7a70d0fafb1f8d954778f329f1ba53d110d9d5fd98",
         "src/assets/claude-prompts.json": "cb111f2e0a45afe8a31c251a504d1ab5375966ed61291660e61fd2efd77f6d9f",
         "src/backend/http/ai-profile-routes.js": "4b13a8e9ccbb0317f2ae7b3d468c060c33a9e1ffa49b781a495193a8eebaca68",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanqianx/project-knowledge",
-  "version": "5.0.27",
+  "version": "5.0.29",
   "description": "Knowledge base manager with Git integration, AI-driven analysis, and bilingual (zh-CN/en-US) knowledge output",
   "main": "_site/server.js",
   "scripts": {
@@ -93,7 +93,7 @@
     "@sanqianx/vector-hub": "1.0.8-rc.8",
     "buffer": "^6.0.3",
     "cheerio": "^1.2.0",
-    "claude-ai-workbench": "npm:@sanqianx/claude-ai-workbench@0.13.10",
+    "claude-ai-workbench": "npm:@sanqianx/claude-ai-workbench@0.13.12",
     "cross-spawn": "7.0.6",
     "dotenv": "^17.4.2",
     "gpt-tokenizer": "^3.4.0",

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.27",
+  "version": "5.0.29",
   "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.27",
+  "version": "5.0.29",
   "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.27"
+        "KB_PLUGIN_VERSION": "5.0.29"
       }
     }
   }

package/ui/index.html

@@ -58,6 +58,7 @@
 <dialog id="importDialog"><form id="importForm"><div class="dialog-heading"><h2>导入项目</h2><button type="button" data-close="importDialog" aria-label="关闭">×</button></div><p class="muted">绑定代码与新的空知识目录。只建立跟踪基线，不读取旧知识、不分析全部历史。</p><label>代码目录<div class="input-with-action"><input name="localPath" id="importCode" required placeholder="D:\SanQian.Xu\my-project"><button type="button" id="pickCode">选择</button></div></label><label>项目名称<input name="displayName" id="importName" required maxlength="200"></label><label>知识目录<div class="input-with-action"><input name="knowledgePath" id="importKnowledge" required placeholder="D:\SanQian.Xu\knowledge\my-project"><button type="button" id="pickKnowledge">选择</button></div></label><label>所属领域<select name="domainId" id="importDomain"></select></label><label id="gitInitChoice" class="checkbox" hidden><input type="checkbox" name="confirmGitInit">这个目录不是 Git 仓库，我确认初始化 Git。</label><label id="replaceHookChoice" class="checkbox" hidden><input type="checkbox" name="confirmReplaceHook">目录留有旧知识库的托管 Hook，我确认替换为新项目接线。不会覆盖第三方 Hook。</label><div id="preflightStatus" class="feedback" role="status">填写目录后检查导入条件。</div><button type="button" id="setupImportRoot" hidden>设置知识根目录</button><div class="dialog-actions"><button type="button" data-close="importDialog">取消</button><button type="submit" class="primary" id="confirmImport" disabled>导入项目</button></div></form></dialog>
 <dialog id="domainDialog"><form id="domainForm"><div class="dialog-heading"><h2>创建领域</h2><button type="button" data-close="domainDialog" aria-label="关闭">×</button></div><label>领域名称<input name="name" required maxlength="100" placeholder="例如：开发工具"></label><p class="muted">领域用于共享相关项目的知识，不是新的代码项目。</p><div class="dialog-actions"><button type="button" data-close="domainDialog">取消</button><button class="primary" type="submit">创建领域</button></div></form></dialog>
 <dialog id="memoryDialog"><form id="memoryForm"><div class="dialog-heading"><h2 id="memoryDialogTitle">审核记忆</h2><button type="button" data-close="memoryDialog" aria-label="关闭">×</button></div><p id="manualMemoryHint" class="muted" hidden>来源为手动添加。确认后保存为已确认记忆，无需等待提交或 Agent 提取。</p><label>记忆内容<textarea id="memoryText" maxlength="2000" required rows="5" placeholder="例如：对外错误信息使用中文；优先复用已有模块。"></textarea></label><label>适用范围<select id="memoryScope"><option value="global">全局：所有领域与项目</option><option value="domain">领域：指定领域内的项目</option><option value="project">项目：仅指定项目</option></select></label><label id="memoryTargetLabel">适用目标<select id="memoryTarget" required></select></label><p id="memoryScopeHint" class="muted"></p><details class="memory-evidence" id="memoryEvidenceDetails"><summary>原始总结与来源依据（只读）</summary><p id="memoryOriginal"></p><p id="memoryEvidence" class="muted"></p><blockquote id="memoryQuote"></blockquote></details><p id="memoryFeedback" class="feedback" hidden role="status"></p><div class="dialog-actions"><button type="button" data-close="memoryDialog">取消</button><button type="submit" id="saveMemoryCandidate" data-mode="candidate">保存候选</button><button type="submit" id="confirmMemory" class="primary" data-mode="confirmed">确认并保存</button></div></form></dialog>
+<dialog id="memoryDeleteDialog"><div class="dialog-heading"><h2>删除记忆</h2><button type="button" data-close="memoryDeleteDialog" aria-label="关闭">×</button></div><p id="memoryDeleteText"></p><p id="memoryDeleteScope" class="muted"></p><p class="muted">删除后这条记忆不再作为长期记忆使用，也不会出现在记忆列表或新任务的参考内容中。原始对话和知识来源保持不变。之后仍可随时手动重新添加。</p><p id="memoryDeleteFeedback" class="feedback" hidden role="status"></p><div class="dialog-actions"><button type="button" data-close="memoryDeleteDialog">取消</button><button type="button" class="danger" id="confirmMemoryDelete">删除</button></div></dialog>
 <dialog id="unbindDialog"><form id="unbindForm"><div class="dialog-heading"><h2>解绑项目</h2><button type="button" data-close="unbindDialog" aria-label="关闭">×</button></div><p id="unbindProjectName"></p><p class="muted">项目将从列表移除，取消尚未开始的维护任务。代码、知识文件、提交证据和会话历史仍保留。正在执行的知识写入结束前不会解绑。</p><p id="unbindFeedback" class="feedback" role="status"></p><div class="dialog-actions"><button type="button" data-close="unbindDialog">取消</button><button class="primary" type="submit" id="confirmUnbind">解绑并保留数据</button></div></form></dialog>
 <dialog id="referenceDialog" class="reference-dialog"><div class="dialog-heading"><h2 id="referenceTitle">知识引用</h2><div class="actions"><button id="copyReference">复制引用</button><button data-close="referenceDialog" aria-label="关闭">×</button></div></div><p id="referenceMeta" class="muted"></p><pre id="referenceContent"></pre></dialog>
 <dialog id="engineDialog" class="engine-dialog"><div class="dialog-heading"><h2>知识引擎诊断</h2><button data-close="engineDialog" aria-label="关闭">×</button></div><iframe id="engineFrame" title="知识引擎诊断" referrerpolicy="same-origin"></iframe></dialog>

package/ui/product.css

@@ -7,7 +7,7 @@ label>.detail-path{display:block;width:100%;margin:8px 0 0;color:var(--text)}
 @media(prefers-reduced-motion:reduce){*,*::before,*::after{scroll-behavior:auto!important;animation:none!important;transition:none!important}}
 .reference{overflow-wrap:anywhere}.reference small{min-width:0;max-width:100%}
 html[data-theme=dark]{--page:#171a1f;--surface:#20252d;--surface2:#252b34;--surface3:#2c333e;--line:#39424f;--text:#e6ebf0;--muted:#a0aaba;--faint:#788393;--nav:#1b2028;--accent:#8aa8cf;--accent-soft:#293748;--good:#81b29a;--bad:#d88b8b;--bad-soft:#39292d;color-scheme:dark}
-*{box-sizing:border-box}[hidden]{display:none!important}html,body{height:100%}body{margin:0;overflow:hidden;background:var(--page);color:var(--text);font:13px/1.6 -apple-system,BlinkMacSystemFont,"Segoe UI","Microsoft YaHei",sans-serif}button,input,select,textarea{font:inherit;color:inherit}button{cursor:pointer;display:inline-flex;align-items:center;justify-content:center;gap:8px;min-height:34px;padding:6px 12px;border:1px solid var(--line);border-radius:8px;background:var(--surface)}button:hover{background:var(--surface3)}button:disabled{opacity:.5;cursor:not-allowed}button.primary{background:var(--accent);color:#fff;border-color:var(--accent)}button:focus-visible,input:focus-visible,select:focus-visible,textarea:focus-visible{outline:2px solid var(--accent);outline-offset:3px}svg{width:18px;height:18px;fill:none;stroke:currentColor;stroke-width:1.7;stroke-linecap:round;stroke-linejoin:round;flex:none}h1,h2,h3,p{margin:0}h1{font-size:18px;font-weight:650}h2{font-size:16px;font-weight:600}h3{font-size:13px;font-weight:600}small,.muted{color:var(--muted)}small{font-size:11px}p{color:var(--muted);margin-top:8px}input,select,textarea{background:var(--surface);border:1px solid var(--line);border-radius:8px;padding:8px 12px;min-width:0}label{display:block;font-size:12px;margin:16px 0;color:var(--muted)}label>input,label>select,label>textarea{display:block;width:100%;margin-top:8px;color:var(--text)}pre{font:12px/1.8 Consolas,"Microsoft YaHei",monospace;white-space:pre-wrap;overflow-wrap:anywhere;color:var(--text)}
+*{box-sizing:border-box}[hidden]{display:none!important}html,body{height:100%}body{margin:0;overflow:hidden;background:var(--page);color:var(--text);font:13px/1.6 -apple-system,BlinkMacSystemFont,"Segoe UI","Microsoft YaHei",sans-serif}button,input,select,textarea{font:inherit;color:inherit}button{cursor:pointer;display:inline-flex;align-items:center;justify-content:center;gap:8px;min-height:34px;padding:6px 12px;border:1px solid var(--line);border-radius:8px;background:var(--surface)}button:hover{background:var(--surface3)}button:disabled{opacity:.5;cursor:not-allowed}button.primary{background:var(--accent);color:#fff;border-color:var(--accent)}button.danger{background:var(--bad);color:#fff;border-color:var(--bad)}button:focus-visible,input:focus-visible,select:focus-visible,textarea:focus-visible{outline:2px solid var(--accent);outline-offset:3px}svg{width:18px;height:18px;fill:none;stroke:currentColor;stroke-width:1.7;stroke-linecap:round;stroke-linejoin:round;flex:none}h1,h2,h3,p{margin:0}h1{font-size:18px;font-weight:650}h2{font-size:16px;font-weight:600}h3{font-size:13px;font-weight:600}small,.muted{color:var(--muted)}small{font-size:11px}p{color:var(--muted);margin-top:8px}input,select,textarea{background:var(--surface);border:1px solid var(--line);border-radius:8px;padding:8px 12px;min-width:0}label{display:block;font-size:12px;margin:16px 0;color:var(--muted)}label>input,label>select,label>textarea{display:block;width:100%;margin-top:8px;color:var(--text)}pre{font:12px/1.8 Consolas,"Microsoft YaHei",monospace;white-space:pre-wrap;overflow-wrap:anywhere;color:var(--text)}
 .app{height:100%;display:grid;grid-template-columns:232px minmax(0,1fr)}.sidebar{display:flex;flex-direction:column;border-right:1px solid var(--line);background:var(--nav);min-height:0}.brand{display:flex;align-items:center;gap:8px;padding:24px 20px 16px}.brand-mark{width:32px;height:32px;display:block;flex:none;object-fit:contain}.brand strong{font-size:14px}.brand small{display:block}.brain-label{padding:0 20px 16px;color:var(--muted);overflow-wrap:anywhere}.sidebar nav{display:grid;gap:8px;padding:8px 12px}.sidebar nav button{justify-content:flex-start;min-height:40px;text-align:left;border-color:transparent;background:transparent;color:var(--muted)}.sidebar nav button.active{border-color:var(--line);background:var(--surface);color:var(--text)}.count{margin-left:auto;background:var(--surface3);padding:0 6px;border-radius:4px}.system-button{margin: auto 12px 16px;justify-content:flex-start;min-height:56px;background:transparent;border-color:transparent;padding:8px}.system-button>span:nth-child(2){flex:1;text-align:left}.system-button b,.system-button small{display:block;font-size:11px}.dot{width:7px;height:7px;border-radius:50%;background:var(--faint);flex:none}.dot.up{background:var(--good)}.dot.issue{background:var(--bad)}main{min-width:0;min-height:0;display:flex;flex-direction:column}.topbar{height:72px;flex:none;display:flex;align-items:center;gap:16px;padding:0 24px;background:var(--surface);border-bottom:1px solid var(--line)}.spacer{flex:1}.topbar select{width:240px}.icon-button{padding:8px;min-width:34px}.content{position:relative;flex:1;min-height:0}.view{display:none;height:100%;overflow:auto;padding:32px}.view.active{display:block}.view.module-view{padding:0;overflow:hidden}.module-view.active{display:flex;flex-direction:column}.frame-container{position:relative;flex:1;min-width:0;min-height:0;overflow:hidden;background:var(--surface)}iframe{display:block;width:100%;height:100%;border:0;background:var(--surface)}.work-layout{display:grid;grid-template-columns:minmax(0,1fr);height:100%;min-height:0}.module-toolbar{flex:none;min-height:56px;display:flex;justify-content:space-between;align-items:center;gap:16px;padding:8px 24px;border-bottom:1px solid var(--line);background:var(--surface)}.segmented{display:flex;gap:4px}.segmented button{background:transparent;border-color:transparent;color:var(--muted)}.segmented button.active{background:var(--surface);border-color:var(--line);color:var(--text)}
 .welcome{display:flex;align-items:center;justify-content:space-between;gap:24px;margin-bottom:32px}.welcome h2{font-size:24px;margin-top:8px}.actions{display:flex;gap:8px;align-items:center}.grid2{display:grid;grid-template-columns:minmax(0,1.4fr) minmax(320px,1fr);gap:24px}.stack{display:grid;gap:24px}.panel{border:1px solid var(--line);background:var(--surface);border-radius:8px;padding:24px;min-width:0}.panel h2{margin-bottom:16px}.section-heading{display:flex;align-items:center;justify-content:space-between;gap:24px;margin-bottom:24px}.section-heading p{font-size:12px}.row{display:flex;align-items:center;gap:16px;padding:16px 0;border-bottom:1px solid var(--line)}.row:last-child{border-bottom:0}.row>div{flex:1;min-width:0}.row b{font-weight:600}.row small{display:block;margin-top:4px;overflow-wrap:anywhere}.row time{color:var(--muted);font-size:11px;flex:none}.status{font-size:11px;border:1px solid var(--line);border-radius:4px;padding:2px 8px;white-space:nowrap;color:var(--muted)}.status.up{color:var(--good)}.status.issue{color:var(--bad);background:var(--bad-soft)}.empty{padding:64px 24px;text-align:center;color:var(--muted);background:var(--surface);border-radius:8px;line-height:1.9}.empty button{display:block;margin:16px auto 0}.small-empty{padding:16px 0;text-align:left;background:transparent;font-size:12px}.hierarchy{display:grid;grid-template-columns:296px minmax(0,1fr);gap:24px}.tree h3{margin:24px 0 8px;color:var(--muted);font-size:11px}.tree button{width:100%;justify-content:flex-start;text-align:left;background:transparent;border-color:transparent;margin-top:4px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.tree button.active{background:var(--accent-soft);color:var(--accent)}.detail-path{padding:12px 16px;background:var(--surface2);border:1px solid var(--line);border-radius:8px;margin:8px 0 24px;font:12px/1.8 Consolas,"Microsoft YaHei",monospace;overflow-wrap:anywhere}.detail-label{color:var(--muted);font-size:11px}.memory-grid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:24px;margin-top:24px}.memory-card{padding:24px;border:1px solid var(--line);border-radius:8px;background:var(--surface)}.memory-card p{color:var(--text);margin:0 0 16px;white-space:pre-wrap}.memory-card .actions{margin-top:16px}.reference{display:block;text-align:left;width:100%;background:transparent;border:0;border-bottom:1px solid var(--line);border-radius:0;padding:16px 0}.reference b,.reference small{display:block;text-align:left}.reference p{font-size:12px;text-align:left}.activity-updates{flex:1;overflow:auto;padding:24px 32px}.run{margin-bottom:16px;background:var(--surface);border:1px solid var(--line);border-radius:8px}.run summary{padding:16px 24px;cursor:pointer;display:flex;align-items:center;gap:16px}.run summary strong{flex:1}.run>div{padding:0 24px 24px}.run .error{color:var(--bad)}.operation{padding:8px 0;color:var(--muted)}
 .drawer-backdrop{position:fixed;inset:0;background:rgba(10,18,25,.25);z-index:20}.drawer{position:fixed;right:0;top:0;height:100%;width:448px;background:var(--surface);border-left:1px solid var(--line);z-index:21;display:flex;flex-direction:column}.drawer>header{height:72px;display:flex;align-items:center;justify-content:space-between;padding:24px;border-bottom:1px solid var(--line)}.drawer-content{overflow:auto;flex:1;padding:24px}.drawer section{padding-bottom:24px;margin-bottom:24px;border-bottom:1px solid var(--line)}.drawer select{width:100%;margin:16px 0}.drawer .actions{flex-wrap:wrap}.drawer section:last-child{border-bottom:0}.input-with-action{display:flex;gap:8px;margin-top:8px}.input-with-action input{flex:1}.input-with-action button{flex:none}.checkbox{display:flex;align-items:center;gap:8px}.checkbox input{width:auto;margin:0}dialog{width:560px;max-width:90vw;max-height:90vh;overflow:auto;background:var(--surface);color:var(--text);border:1px solid var(--line);border-radius:12px;padding:24px}dialog::backdrop{background:rgba(10,18,25,.35)}.dialog-heading{display:flex;align-items:center;justify-content:space-between;margin-bottom:16px}.dialog-heading>button{border:0;background:transparent;font-size:20px}.dialog-actions{display:flex;justify-content:flex-end;gap:8px;margin-top:24px}.feedback{padding:12px 16px;background:var(--surface2);border:1px solid var(--line);border-radius:8px;color:var(--muted);white-space:pre-wrap}.feedback.issue{color:var(--bad)}.reference-dialog{width:880px}.reference-dialog pre{margin-top:24px;max-height:60vh;overflow:auto}.engine-dialog{width:calc(100vw - 96px);height:calc(100vh - 96px);padding:0;overflow:hidden}.engine-dialog .dialog-heading{height:64px;padding:16px 24px;border-bottom:1px solid var(--line);margin:0}.engine-dialog iframe{height:calc(100% - 64px)}.toast{position:fixed;bottom:24px;right:24px;z-index:50;background:var(--surface);padding:12px 16px;border:1px solid var(--line);border-radius:8px;max-width:480px;color:var(--text)}

package/ui/product.js

@@ -24,7 +24,7 @@
   const time = value => value ? new Date(value).toLocaleString('zh-CN', { month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit' }) : '—';
   const label = run => run.state === 'failed' && run.error?.code === 'MODEL_QUOTA_EXHAUSTED' ? '额度不足 · 待重试' : run.state === 'queued' && run.phase === 'waiting-previous' ? '等待前一条提交恢复' : ({ queued: '排队', running: '维护中', succeeded: '已更新 · 可检索', 'index-pending': '知识已更新 · 索引待修复', failed: '维护失败', cancelled: '已取消' })[run.state] || run.state;
   const badge = (text, status = '') => `<span class="status ${esc(status)}">${esc(text)}</span>`;
-  let toastTimer, refreshTimer, preflightTimer, editingMemoryId, logStream, logEpoch = 0, referenceEpoch = 0, snapshotEpoch = 0, registryEpoch = 0, registryPromise = null, resumeImport = false, unbindProjectId = '', unbinding = false;
+  let toastTimer, refreshTimer, preflightTimer, editingMemoryId, deletingMemoryId, logStream, logEpoch = 0, referenceEpoch = 0, snapshotEpoch = 0, registryEpoch = 0, registryPromise = null, resumeImport = false, unbindProjectId = '', unbinding = false;
   let captureEpoch = 0, captureBusy = false;
   let registryStream = null, registryReceipt = null, registryRefreshTimer;
   async function api(url, options = {}) {
@@ -261,7 +261,7 @@
     all('[data-memory-tab]').forEach(button => button.classList.toggle('active', button.dataset.memoryTab === state.memoryTab));
     const type = $('memoryScopeFilter').value, target = $('memoryTargetFilter').value;
     const memories = state.snapshot.memories.filter(m => m.status === state.memoryTab && (!type || (m.scopeType || 'global') === type) && (!type || type === 'global' || !target || m.scopeId === target));
-    $('memoryContent').innerHTML = !state.engineAvailable ? '<div class="empty">知识引擎暂时不可用。未读取到的记忆不会显示为已确认。</div>' : memories.length ? `<div class="memory-grid">${memories.map(m => `<article class="memory-card" data-memory-card="${esc(m.id)}"><div class="memory-meta">${badge(memoryScopeName(m))}${m.targetAvailable === false ? badge('目标已失效，不会注入', 'issue') : m.status === 'confirmed' && m.syncStatus === 'pending' ? badge('写入待恢复', 'issue') : m.status === 'confirmed' && m.indexStatus === 'failed' ? badge('索引待恢复', 'issue') : m.status === 'confirmed' && m.indexStatus === 'pending' ? badge('索引更新中') : ''}</div><p>${esc(m.text)}</p><small>${m.sourceType === 'manual' ? `来源：手动添加 · ${esc(time(m.createdAt))}` : `来源：${esc(projectName(m.evidence.projectId))} · commit ${esc(m.evidence.commitSha.slice(0, 8))}<br>${esc(m.evidence.entryId)}`}</small><div class="actions">${m.sourceType === 'manual' ? '' : `<button data-memory-action="evidence" data-memory-id="${esc(m.id)}">查看依据</button>`}${m.status === 'candidate' ? `<button class="primary" data-memory-action="confirm" data-memory-id="${esc(m.id)}">审核确认</button><button data-memory-action="ignore" data-memory-id="${esc(m.id)}">忽略</button>` : `<button data-memory-action="edit" data-memory-id="${esc(m.id)}">编辑</button>${badge(m.syncStatus === 'pending' ? '待同步' : '已确认', m.syncStatus === 'pending' ? 'issue' : 'up')}`}</div></article>`).join('')}</div>` : `<div class="empty">${type ? '此范围内没有匹配的记忆。' : state.memoryTab === 'confirmed' ? '还没有已确认的长期记忆。可以点击“添加记忆”记录约定。' : '候选箱为空。维护产物中的有据偏好会进入这里，等待你的确认。'}</div>`;
+    $('memoryContent').innerHTML = !state.engineAvailable ? '<div class="empty">知识引擎暂时不可用。未读取到的记忆不会显示为已确认。</div>' : memories.length ? `<div class="memory-grid">${memories.map(m => `<article class="memory-card" data-memory-card="${esc(m.id)}"><div class="memory-meta">${badge(memoryScopeName(m))}${m.targetAvailable === false ? badge('目标已失效，不会注入', 'issue') : m.status === 'confirmed' && m.syncStatus === 'pending' ? badge('写入待恢复', 'issue') : m.status === 'confirmed' && m.indexStatus === 'failed' ? badge('索引待恢复', 'issue') : m.status === 'confirmed' && m.indexStatus === 'pending' ? badge('索引更新中') : ''}</div><p>${esc(m.text)}</p><small>${m.sourceType === 'manual' ? `来源：手动添加 · ${esc(time(m.createdAt))}` : `来源：${esc(projectName(m.evidence.projectId))} · commit ${esc(m.evidence.commitSha.slice(0, 8))}<br>${esc(m.evidence.entryId)}`}</small><div class="actions">${m.sourceType === 'manual' ? '' : `<button data-memory-action="evidence" data-memory-id="${esc(m.id)}">查看依据</button>`}${m.status === 'candidate' ? `<button class="primary" data-memory-action="confirm" data-memory-id="${esc(m.id)}">审核确认</button><button data-memory-action="ignore" data-memory-id="${esc(m.id)}">忽略</button>` : `<button data-memory-action="edit" data-memory-id="${esc(m.id)}">编辑</button>${badge(m.syncStatus === 'pending' ? '待同步' : '已确认', m.syncStatus === 'pending' ? 'issue' : 'up')}`}<button data-memory-action="delete" data-memory-id="${esc(m.id)}">删除</button></div></article>`).join('')}</div>` : `<div class="empty">${type ? '此范围内没有匹配的记忆。' : state.memoryTab === 'confirmed' ? '还没有已确认的长期记忆。可以点击“添加记忆”记录约定。' : '候选箱为空。维护产物中的有据偏好会进入这里，等待你的确认。'}</div>`;
   }
   function memoryScopeName(memory) {
     const type = memory.scopeType || 'global';
@@ -298,6 +298,15 @@
     $('confirmMemory').textContent = memory.status === 'candidate' ? '确认并保存' : '保存修改';
     $('memoryDialog').showModal();
   }
+  function openDeleteMemory(memory) {
+    if (!state.engineAvailable) { toast('知识引擎暂时不可用，请恢复连接后重试。'); return; }
+    deletingMemoryId = memory.id;
+    $('memoryDeleteText').textContent = memory.text;
+    $('memoryDeleteScope').textContent = `适用范围：${memoryScopeName(memory)}`;
+    $('memoryDeleteFeedback').hidden = true;
+    $('confirmMemoryDelete').disabled = false;
+    $('memoryDeleteDialog').showModal();
+  }
   function openAddMemory() {
     if (!state.engineAvailable) { toast('知识引擎暂时不可用，请恢复连接后重试。'); return; }
     if (!state.root) { toast('请先在设置中配置知识根目录，再添加记忆。'); return; }
@@ -674,6 +683,7 @@
         const action = button.dataset.memoryAction;
         if (action === 'evidence') await openReference({ ...memory.evidence, readFile: false, text: memory.evidence.quote, title: '记忆来源依据（冻结原文）' });
         else if (action === 'edit' || action === 'confirm') openMemory(memory);
+        else if (action === 'delete') openDeleteMemory(memory);
         else { await api(`/api/engine/memories/${encodeURIComponent(memory.id)}`, { method: 'PATCH', body: { status: 'ignored' } }); await refreshSnapshot(); }
       }
     };
@@ -732,6 +742,22 @@
   on('domainForm', 'submit', async e => { e.preventDefault(); await api('/api/domains', { method: 'POST', body: Object.fromEntries(new FormData(e.target)) }); $('domainDialog').close(); await refreshRegistry(true); });
   on('memoryScopeFilter', 'change', updateMemoryFilter); on('memoryTargetFilter', 'change', renderMemories);
   on('addMemory', 'click', openAddMemory);
+  on('confirmMemoryDelete', 'click', async () => {
+    if (!deletingMemoryId || $('confirmMemoryDelete').disabled) return;
+    $('confirmMemoryDelete').disabled = true;
+    $('memoryDeleteFeedback').hidden = true;
+    try {
+      await api(`/api/engine/memories/${encodeURIComponent(deletingMemoryId)}`, { method: 'DELETE' });
+      $('memoryDeleteDialog').close();
+      await refreshSnapshot();
+      toast('记忆已删除，不再作为长期记忆使用。');
+    } catch (error) {
+      $('confirmMemoryDelete').disabled = false;
+      $('memoryDeleteFeedback').textContent = error.message;
+      $('memoryDeleteFeedback').hidden = false;
+    }
+  });
+  on('memoryDeleteDialog', 'close', () => { deletingMemoryId = ''; $('confirmMemoryDelete').disabled = false; });
   on('memoryScope', 'change', () => {
     const memory = state.snapshot.memories.find(m => m.id === editingMemoryId), type = $('memoryScope').value;
     const source = state.projects.find(p => p.projectId === memory?.evidence?.projectId) || activeProject();

package/vendor-manifest.json

@@ -3,11 +3,11 @@
   "modules": {
     "knowledge-engine": {
       "name": "@sanqianx/ai-coding-knowledge-engine",
-      "version": "0.2.7-rc.11",
+      "version": "0.2.7-rc.12",
       "root": "_modules/knowledge-engine",
       "files": {
-        "README.md": "27236264aa40ca3abd12a82d779120410d09507c0b0ad8d3f16896a03ae363ee",
-        "package.json": "ad46440e59ee83f43e23a985418f9b94e1f5bc91ec93c589eb22bf39e4c3201d",
+        "README.md": "5fcf21c2fb819b431df34d5da05ee7bd861c7069c9d24c1b630e8a5e4ac3455c",
+        "package.json": "a3d61ae5aeda5f820b678f464b223ab80a5d60f024dd2df9dc12533de9d86e03",
         "src/analysis-contract.js": "6d4b9fde0e05d9a80d43e96d0c27febf082ecdb19312faf0280d6c9b16ac71b1",
         "src/analysis-failures.js": "eb1e5a476b1e3e3c87dfd9955707c85151707799883595bcb5e9cc3e26a991c4",
         "src/analysis-output.js": "95a3c19dcc9ab85d1dba7fee5b9aec80f9c000dfba89da3fd0be25a81e2fb680",
@@ -20,7 +20,7 @@
         "src/headless-analyzer.js": "df570864136981cf98f3f69d047fa5729fbbfdeeaee0c6bfad26dab941dbbdae",
         "src/index-request.js": "78f26b872299005499fff4f2d1f9e8f986784f2ff36a5cf2be2b1e7b7c7d9378",
         "src/knowledge-targets.js": "aa44ec285d16d7b1c0b63bf084058a1d6f867fa9929c753b6b0cbb24f7b20ee2",
-        "src/memories.js": "7ad6701033c9a98a0d918b9745c012f9e90b8de6db6e1d870e2ebf77000a1aac",
+        "src/memories.js": "b661474b51688a7ec9bc9d79bdc628070f7e128effbf7b86be9520398ead00a5",
         "src/memory-eligibility.js": "48af31f23f81140dbc706ff83a39ba9f411314d87d01e5accfaf419c7a74e0ea",
         "src/retrieval-policy.json": "3205fb4eb114a839a74f902e6fae6a61e1460958e5a9d7e29add32b60ba4e05a",
         "src/retrieval-ranking.js": "061b64f5bffec3269851830b30ab51abc3260274e5207ea4864ae33d9cb22809",
@@ -43,13 +43,13 @@
         "src/runtime/layout.js": "e47fe54c605218493ce46f6289798d9db2a3ecec95089d288ed03d3b75cf871a",
         "src/runtime/markdown-knowledge-indexer.js": "ac094e947e52cbaeb781c0e1a9437b52b4e46bda9ae92fdd5c626ee13eb0b8be",
         "src/runtime/scanner.js": "2b5443a1b782b4b73458de907a06a34e6bb6bfa9ba45d20c443ef8272ada97e6",
-        "src/server.js": "4bb07e1538c70ee53f2238be29f8452f11c2ddf87725c4e063d7999765a8082c",
-        "src/store.js": "8fe9c415c845feefab3e2129b5850686747a880c827189026e3eb6295b158c0a",
+        "src/server.js": "1d89378d889d563082e7ca0ade198ba312332288d5d253a9379c24b542f39b75",
+        "src/store.js": "66f573a58662f0a726c2ef62ccc1697616e9d93066af9f65a87c2c1f6b16829d",
         "ui/app.css": "7ad370c269e60a7b5ec907d81a607b2d16bd07b2d7c22a81f102dab51eeb2889",
         "ui/app.js": "e9ecb0125d5f2a8bb30a58c4d278fe0737ee2540ecfb065f97f453495cfc792d",
         "ui/index.html": "ce3565cfefd4838b11d37a91a906ef26ca5a1834844fe3f7c897b56851a3c418"
       },
-      "sourceCommit": "28475eb83f794d6fa578577b4f6e80114d40a85c"
+      "sourceCommit": "949d1d7066082e5c3ddcf04af653f5624be9add6"
     }
   }
 }