@sanqianx/project-knowledge 5.0.8 → 5.0.9-rc.10

package/.claude-plugin/marketplace.json

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

package/CHANGELOG.md

@@ -1,5 +1,114 @@
 # Changelog
 
+## [5.0.9-rc.10] - 2026-10-11
+
+- Preserve acknowledged brain/domain knowledge-directory bindings when changing
+  the knowledge root. Only derived indexes and future imports/shared scopes use
+  the new root; existing knowledge and confirmed memories stay in place.
+- Persist bindings in shell metadata, reject implicit rebinding, and report
+  shared-scope connection failures in UI and safe structured logs.
+- Add real-engine regression for confirmed memory, domain retrieval, restart,
+  new domain registration, offline retry and protected bindings on Node 22/24.
+- Candidate acceptance still precedes the existing-v5 upgrade and stable latest.
+
+## [5.0.9-rc.9] - 2026-10-11
+
+- Vendor engine 0.2.3-rc.4. Freeze existing target paths and hashes before
+  analysis so missing retrieval snippets cannot be mistaken for absent files.
+  Preserve full old documents when only partial context is available; illegal
+  create operations still fail safely instead of silently overwriting data.
+- Keep the failed rc.8 secondary-development maintenance evidence and verify
+  that exact commit after downloading this candidate, not patched source bytes.
+- Render long index-directory paths as a full-width block in System Status.
+- latest remains unchanged until the real closed-loop and existing-v5 gates pass.
+
+## [5.0.9-rc.8] - 2026-10-11
+
+- Pin Workbench 0.13.2-rc.4: atomically replace all native Agent histories,
+  retaining the previous complete record on disk-full or locked-file errors.
+  CLI fallback no longer deletes durable history before a failed rename.
+- Keep the original disk-full loss and separate successful background recovery
+  records. Candidate acceptance includes faults against downloaded module bytes.
+- Pin vector-hub 1.0.8-rc.2. Managed indexes now follow the knowledge root
+  under `.indexes`; show the acknowledged actual directory in System Status.
+  Rebuild on a root/model change while retaining the old index directory;
+  serialize queued writes and avoid a full paid rebuild on normal restart.
+- Do not promote latest until installed and existing-v5 acceptance pass.
+
+## [5.0.9-rc.7] - 2026-10-11
+
+- Vendor engine 0.2.3-rc.3: recognize promoted commit identifiers inside
+  natural-language tasks, including short and multiple SHAs. Raw conversation
+  mentions cannot replace the current promoted knowledge references.
+- Preserve failed installed Workbench/context checks from rc.6; latest remains
+  unchanged until fresh registry runtime and existing-v5 acceptance pass.
+
+## [5.0.9-rc.6] - 2026-10-11
+
+- Vendor engine 0.2.3-rc.2. Unassigned projects no longer share an implicit
+  domain in retrieval or Workbench task context. Explicit domains and whole
+  brain queries retain their inclusive scopes.
+- Keep the failed rc.5 real Workbench acceptance as a separate record. This
+  candidate must pass fresh downloaded-runtime checks before promotion.
+
+## [5.0.9-rc.5] - 2026-10-11
+
+- Pin Workbench 0.13.2-rc.3: retain OpenCode final answers across tool rounds,
+  isolate CLI history by product data directory and recover only owned v5
+  session records without moving or deleting originals.
+- Support current ZCode model-selection and failure events. Shared provider
+  credentials stay in memory behind a temporary loopback transport; client
+  shutdown cleans up the transport and settles rejected sends correctly.
+- Candidate publication does not promote latest or imply complete acceptance.
+  Real client execution, installed UI regression and existing-data upgrade
+  remain separately recorded gates.
+
+## [5.0.9-rc.4] - 2026-10-11
+
+- Pin Workbench 0.13.2-rc.2: resolve the installed ZCode provider resource
+  layout without rewriting desktop or personal configuration, and label
+  runtime failures with the correct agent.
+- Disable the project selector until the first registry snapshot. This fixes
+  the startup interaction race exposed by the Node 22 packaged UI regression.
+- Latest is unchanged; real installed acceptance and client authentication are
+  independent gates, not implied by a successful version probe.
+
+## [5.0.9-rc.3] - 2026-10-11
+
+- Route engine-wired CLI and MCP reads through the same authoritative engine
+  as the web UI, preserving commit references and project/domain/brain scopes.
+  Verify the selected runtime identity and reject unavailable, mismatched or
+  malformed services instead of silently querying a different local index.
+- Preserve the MCP `space` alias and expose explicit scope selection. Bound
+  responses and never forward profile or credential objects to read routes.
+- Drain isolated regression servers before Windows fixture cleanup. Candidate
+  publication still does not promote latest or claim complete acceptance.
+
+## [5.0.9-rc.2] - 2026-10-11
+
+- Pin the verified Workbench 0.13.2-rc.1 and vector-hub 1.0.8-rc.1 candidates.
+  Normalize known official MiniMax embedding route aliases at runtime without
+  changing existing v5 configuration bytes or private gateway paths.
+- Queue same-project index writes across embedding-model rebuilds. Failed writes
+  do not poison retries, and unrelated projects remain independent.
+- Restore safe relative Markdown document navigation and verify the standalone
+  retrieval UI at 1920x1080. Tests never kill unrelated port owners.
+- Isolate regression-suite ports and tolerate Windows fixture file release.
+  Candidate publication is not full product acceptance; latest remains unchanged.
+
+## [5.0.9-rc.1] - 2026-10-11
+
+- Retain classified, bounded and redacted index errors in run details, activity
+  and local log/v2 exports. Index-only retries preserve promoted files and do not
+  invoke the analysis model again.
+- Accept ZCode conversation evidence, isolate per-project journal failures and
+  report the exact blocked sequence without dropping evidence or flooding logs.
+- Synchronize production asset hashes, including the shared favicon. Permit
+  exact rc module pins but reject tags, ranges, links and source overrides.
+- Prepare a web-only candidate; latest is not promoted by this release. Existing
+  v5 data and third-party integrations are preserved; system acceptance remains
+  a separate gate from publication.
+
 ## [5.0.8] - 2026-10-10
 
 - Repair managed Codex notify chains after scoped npm package or Bridge-home

package/README.md

@@ -127,6 +127,13 @@ visible as dirty state and is retried.
 vector-hub owns the derived index; the shell no longer runs a second index
 writer. Failed indexing leaves promoted Markdown intact and repairable.
 
+Managed vectors follow the configured knowledge root at `<knowledge>/.indexes`.
+The system drawer displays the actual directory and pending wiring separately.
+Root changes leave project Markdown and old indexes untouched, drain existing
+index writes, switch subsequent writes, and rebuild registered knowledge with
+the configured embedding model. Credentials and small runtime metadata remain
+in the product data directory; no expensive historical Agent analysis is started.
+
 The application does not create, edit, refresh, or delete `CLAUDE.md`.
 
 ## Requirement capture
@@ -160,6 +167,15 @@ Queries never create or rewrite configuration. If the internal index is
 unavailable, search falls back to current Markdown. Project, domain and brain
 scopes are nested; unconfirmed memory candidates are not task preferences.
 
+For engine-wired projects, the CLI and MCP delegate `search`, `ask`, `get` and
+`history` to the same engine used by the web UI, including commit provenance.
+They verify the running instance against the selected data directory; an
+unavailable or mismatched instance is an explicit failure, not a second local
+index with different facts. Only projects without engine wiring retain the
+local legacy read contract. Use `--scope domain` or `--scope brain` to broaden
+CLI searches; MCP accepts the equivalent `scope`. Shared-file reads accept
+`--space <spaceId>` (MCP: `space` or `spaceId`).
+
 ## Storage
 
 Version 5 is a fresh start, not a data upgrade. Stop the previous process,
@@ -178,13 +194,18 @@ project-knowledge
 ```
 
 The user selects a global knowledge root before importing projects. That root
-only chooses the directory for future imports. Each imported project stores an
+chooses directories for future imports, new shared scopes, and derived vector
+indexes (`<knowledge root>/.indexes`). Each imported project stores an
 absolute, fixed `knowledgePath`; changing the global root does not move existing
 projects.
 
-The selected knowledge root contains only authoritative project Markdown.
-Settings, metadata, indexes, caches, runtime state, logs, and recovery assets
-remain in the internal data directory:
+Existing project and shared-knowledge directories do not move when the root
+changes. Brain/domain directory bindings are retained in the shell settings
+after the engine acknowledges them. Existing engine bindings are reused when
+first recording those fields. A failed registration is shown as pending, not
+healthy. Old index directories are retained; indexes rebuild at the new root.
+Settings, registration metadata, caches, runtime state, logs, and recovery
+assets remain in the internal data directory; vector payloads do not:
 
 ```text
 ~/.project-knowledge-v5/
@@ -204,6 +225,8 @@ remain in the internal data directory:
 └── recovery/                             # migrations, promotion/index backups
 
 <selected knowledge root>/
+├── .indexes/                            # rebuildable vector payloads
+├── _shared/<brain or domain ID>/         # fixed shared-knowledge bindings
 └── <project storage name>/
     ├── README.md                         # when produced by verified knowledge
     ├── GOAL.md

package/_modules/knowledge-engine/README.md

@@ -39,6 +39,8 @@ node src/bin.js serve [--port 5790] [--host 127.0.0.1] [--data DIR]
 
 本模块零新增 npm 依赖、CommonJS、Node ≥18；无头 Agent SDK 由宿主已安装的 Workbench/SDK 提供，缺失时明确失败，不退回假分析。完整产品的 Node 门槛为 ≥22。
 
+每次真实分析在只读证据区冻结已有知识的目标路径与哈希清单，覆盖未被检索选中的文件；重试复用该清单。Agent 不得把“未检索到”当作“文件不存在”，也不得用部分片段覆盖完整旧文档；无法保留原文时只追加当前提交的变更记录。已有目标仍由晋升校验拒绝非法 create，不自动改为覆盖。清单仅保存元数据，不把整个知识树复制到每次运行中。
+
 ## API
 
 | 方法 | 路径 | 说明 |
@@ -67,6 +69,7 @@ node src/bin.js serve [--port 5790] [--host 127.0.0.1] [--data DIR]
 ## 真实运行与恢复边界
 
 - journal 游标按来源隔离；证据投影及可恢复任务先落盘，再 ACK。不等待模型才能消费下一条事件。
+- 会话来源接受 bridge 的四客户端契约（Claude Code、Codex、OpenCode、ZCode）。单个 journal 的非法证据不被跳过或 ACK，但不阻塞其他项目；失败位置和错误码写入日志，健康接口提供 `journal.failures`，重复轮询不刷屏，恢复后续接原游标。
 - 不同项目最多并发 2 个分析，同项目按提交顺序执行。未晋升的失败提交会阻挡本项目后续提交，不阻挡其他项目。
 - 无头分析在隔离进程中运行，只读冻结证据，只写本次 staging。产物必须通过路径、内容 hash 和依据校验，只有晋升路径写最终项目知识。
 - 归档对话和检索内容只作证据，不能覆盖后台维护指令。SDK 返回成功文字但未生成 manifest 时，记录 `ANALYSIS_OUTPUT_MISSING` 并保留证据供重试，不误报晋升完成。
@@ -74,7 +77,9 @@ node src/bin.js serve [--port 5790] [--host 127.0.0.1] [--data DIR]
 - 具体失败原因、失败步骤和提交依据进入运行详情及 `log/v2` 诊断。受外壳守护时通过 IPC 交给外壳现有日志系统；独立运行保存在 `<data>/logs/`，不写模型凭据和原始证据。升级不会重新运行已失败提交，用户可显式重试失败阶段。
 - 数据目录有单实例租约，目标知识目录有写入锁。关闭或超时等待子进程实际退出，再释放写入锁。
 - 晋升与索引分别记录。索引失败保留已晋升知识并显示待修复，不重新调用模型。
-- 项目、领域、智脑检索使用包含范围。向量只提供排序，显示内容必须来自当前真实文件；索引不可用时降级为文件检索。
+- 索引错误保留兼容的 `INDEX_FAILED` 及可选 `error.details`（类别、HTTP 状态、上游代码/脱敏原因、请求标识、耗时和尝试次数）；项目和共享索引均写入 `log/v2`。响应仅解析有界 JSON，不记录原始 body 或认证头。只重试索引保留原分析运行、晋升时间和知识字节。
+- 项目、领域、智脑检索使用包含范围。未分配领域不是共享领域：领域范围只包含当前项目与智脑共享知识；显式加入同一领域后才包含其他项目。整个智脑范围仍包含全部同智脑项目。向量只提供排序，显示内容必须来自当前真实文件；索引不可用时降级为文件检索。
+- 已晋升提交的 SHA 或短 SHA 在自然语言查询中仍作为标识符匹配，只返回当前文件的晋升依据；仅在原始会话中提到相同 SHA 不构成知识晋升引用。多个提交标识符可以一起查询。
 - 候选必须有已晋升文件中的引用依据，未确认候选不能进入任务。确认记录原子持久化后写共享记忆文件，派生索引异步更新，索引失败不会撤销有效记忆。
 - 旧格式不读取、不自动迁移。损坏的正式状态不覆盖、不清空。
 

package/_modules/knowledge-engine/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanqianx/ai-coding-knowledge-engine",
-  "version": "0.2.2",
+  "version": "0.2.3-rc.4",
   "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/coordinator.js

@@ -15,6 +15,7 @@ const { MemoryService } = require('./memories');
 const { execGit } = require('./runtime/git-runner');
 const { createDiagnostics } = require('./diagnostics');
 const { finalizeAnalysisOutput } = require('./analysis-output');
+const { requestIndex } = require('./index-request');
 
 class EngineCoordinator extends EventEmitter {
   constructor(store, options = {}) {
@@ -28,6 +29,7 @@ class EngineCoordinator extends EventEmitter {
     this.concurrency = Math.max(1, Math.min(2, Number(options.concurrency) || 2));
     this.active = new Map();
     this.jobs = new Set();
+    this.journalFailures = new Map();
     this.initializeHook = options.initializeHook;
     this.profiles = new Map();
     const diagnostics = createDiagnostics({ dataDir: store.dataDir, secrets: () => [...this.profiles.values()].flatMap(profile => [profile.apiKey, profile.authToken]) });
@@ -123,34 +125,58 @@ class EngineCoordinator extends EventEmitter {
     this.draining = true;
     try {
       await this.bridge.registerConsumer('knowledge-engine', { journals: ['*'] });
-      for (const journal of await this.bridge.listJournals()) {
+      const journals = await this.bridge.listJournals();
+      this.journalFailures.delete('connection');
+      for (const journal of journals) {
         if (this.closed) break;
-        const cursor = this.store.state.journalCursors[journal.journalId] || 0;
-        const events = await this.bridge.readEvents({ journalId: journal.journalId, fromSequence: cursor + 1, limit: 100 });
-        let through = cursor;
-        for (const event of events) {
-          if (this.closed) break;
-          const p = this.store.listProjects().find(p => p.enabled !== false && ((journal.journalId !== 'global' && p.journalId === journal.journalId)
-            || ((journal.journalId === 'global' || !p.journalId) && event.repoIdentity?.workspaceRoot && this.layout.pathsEqual(p.repoPath, event.repoIdentity.workspaceRoot))));
-          if (p) {
-            if (event.schema === 'ai-coding-event/v1' && ['user_prompt', 'assistant_response'].includes(event.eventType)) await this.conversations.appendBridgeEvent(p.projectId, { ...event, journalId: journal.journalId });
-            if (event.schema === 'git-commit-boundary/v1' && /^[a-f0-9]{7,64}$/i.test(event.commitSha || '')) {
-              if (!fs.existsSync(this.layout.getProjectCommitBoundaryPath(p.projectId, event.commitSha))) this.conversations.writeBoundary(p.projectId, { ...event, journalId: journal.journalId, parentShas: event.parents || [], bridgeCursorAtCommit: event.sequence, journalSequence: event.sequence, operationId: event.operationId || `bridge-${journal.journalId}-${event.sequence}`, committedAt: event.committedAt || event.capturedAt });
-              const baseline = p.runtime.lastAnalyzedCommit || p.trackingStartCommit;
-              const completed = this.reconciler.processingLedger.read(p.projectId, event.commitSha);
-              const historical = baseline && (baseline === event.commitSha || (await execGit(p.repoPath, ['merge-base', '--is-ancestor', event.commitSha, baseline])).ok);
-              if (!completed && !historical && this.store.getProject(p.projectId)?.enabled) this.enqueue({ projectId: p.projectId, commitSha: event.commitSha, trigger: 'git-hook', journalId: journal.journalId, journalSequence: event.sequence });
-            }
-          }
-          through = event.sequence;
+        try {
+          await this.consumeJournal(journal);
+          if (this.journalFailures.delete(journal.journalId)) await this.diagnostics.info('knowledge.journal.recovered', '项目事件消费已恢复。', { phase: 'consuming', context: { journalId: journal.journalId } });
+        } catch (error) {
+          // Never ACK invalid evidence; a project fault must not starve other journals.
+          await this.recordJournalFailure(journal.journalId, error);
         }
-        // All evidence projections and queued jobs are durable before ACK.
-        if (through > cursor) this.store.setJournalCursor(journal.journalId, through);
-        await this.bridge.ackConsumerCursor('knowledge-engine', through, { journalId: journal.journalId });
       }
-      this.journalError = null;
-    } catch { this.journalError = '事件日志连接异常，已保留游标并等待恢复。'; }
-    finally { this.draining = false; }
+      for (const id of this.journalFailures.keys()) if (!journals.some(j => j.journalId === id)) this.journalFailures.delete(id);
+    } catch (error) { await this.recordJournalFailure('connection', error); }
+    finally {
+      this.journalError = this.journalFailures.size ? '事件消费异常，未消费证据与游标已保留，请查看诊断日志。' : null;
+      this.draining = false;
+    }
+  }
+  async recordJournalFailure(journalId, error) {
+    const context = error.journalContext || {};
+    const failure = { journalId, sequence: context.sequence ?? null, projectId: context.projectId || null, code: error.code || 'JOURNAL_FAILED', message: this.safeMessage(error.message) };
+    if (JSON.stringify(this.journalFailures.get(journalId)) !== JSON.stringify(failure)) {
+      this.journalFailures.set(journalId, failure);
+      await this.diagnostics.error('knowledge.journal.failed', '事件消费失败，已保留未确认的证据与游标。', { projectId: failure.projectId, phase: 'consuming', error, context: { ...failure, source: context.source || null } });
+    }
+  }
+  async consumeJournal(journal) {
+    const cursor = this.store.state.journalCursors[journal.journalId] || 0;
+    const events = await this.bridge.readEvents({ journalId: journal.journalId, fromSequence: cursor + 1, limit: 100 });
+    let through = cursor;
+    for (const event of events) {
+      if (this.closed) break;
+      const p = this.store.listProjects().find(p => p.enabled !== false && ((journal.journalId !== 'global' && p.journalId === journal.journalId)
+        || ((journal.journalId === 'global' || !p.journalId) && event.repoIdentity?.workspaceRoot && this.layout.pathsEqual(p.repoPath, event.repoIdentity.workspaceRoot))));
+      try {
+        if (p) {
+          if (event.schema === 'ai-coding-event/v1' && ['user_prompt', 'assistant_response'].includes(event.eventType)) await this.conversations.appendBridgeEvent(p.projectId, { ...event, journalId: journal.journalId });
+          if (event.schema === 'git-commit-boundary/v1' && /^[a-f0-9]{7,64}$/i.test(event.commitSha || '')) {
+            if (!fs.existsSync(this.layout.getProjectCommitBoundaryPath(p.projectId, event.commitSha))) this.conversations.writeBoundary(p.projectId, { ...event, journalId: journal.journalId, parentShas: event.parents || [], bridgeCursorAtCommit: event.sequence, journalSequence: event.sequence, operationId: event.operationId || `bridge-${journal.journalId}-${event.sequence}`, committedAt: event.committedAt || event.capturedAt });
+            const baseline = p.runtime.lastAnalyzedCommit || p.trackingStartCommit;
+            const completed = this.reconciler.processingLedger.read(p.projectId, event.commitSha);
+            const historical = baseline && (baseline === event.commitSha || (await execGit(p.repoPath, ['merge-base', '--is-ancestor', event.commitSha, baseline])).ok);
+            if (!completed && !historical && this.store.getProject(p.projectId)?.enabled) this.enqueue({ projectId: p.projectId, commitSha: event.commitSha, trigger: 'git-hook', journalId: journal.journalId, journalSequence: event.sequence });
+          }
+        }
+      } catch (error) { error.journalContext = { projectId: p?.projectId, sequence: event.sequence, source: event.source }; throw error; }
+      through = event.sequence;
+    }
+    // All evidence projections and queued jobs are durable before ACK.
+    if (through > cursor) this.store.setJournalCursor(journal.journalId, through);
+    await this.bridge.ackConsumerCursor('knowledge-engine', through, { journalId: journal.journalId });
   }
   pump() {
     if (this.closed || !this.executionEnabled) return;
@@ -198,16 +224,19 @@ class EngineCoordinator extends EventEmitter {
   }
   async index(run) {
     const project = this.store.getProject(run.projectId);
+    const attempt = (run.indexAttempts || 0) + 1;
+    const context = { projectId: run.projectId, runId: run.runId, operationId: run.runId, commitSha: run.commitSha, phase: 'indexing' };
     try {
-      this.store.updateRun(run.runId, { phase: 'indexing', indexState: 'running' });
-      const response = await fetch(new URL('/api/sync', this.vectorUrl), { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ project: project.vectorProjectId || project.projectId, sourceDir: project.knowledgePath }), signal: AbortSignal.timeout(120000) });
-      const payload = await response.json();
-      if (!response.ok || payload.ok !== true) throw new Error('INDEX_FAILED');
+      this.store.updateRun(run.runId, { phase: 'indexing', indexState: 'running', indexAttempts: attempt });
+      await requestIndex({ baseUrl: this.vectorUrl, route: '/api/sync', body: { project: project.vectorProjectId || project.projectId, sourceDir: project.knowledgePath }, attempt, sanitize: this.safeMessage });
       await this.store.updateRuntime(run.projectId, state => { state.index.dirty = false; state.index.status = 'ready'; });
       this.store.updateRun(run.runId, { state: 'succeeded', phase: 'ready', indexState: 'succeeded', error: null, finishedAt: new Date().toISOString() });
+      await this.diagnostics.info('knowledge.index.completed', '知识向量索引已更新。', { ...context, context: { attempt } });
       this.notify(run, '知识已更新并可检索');
-    } catch {
-      this.store.updateRun(run.runId, { state: 'index-pending', phase: 'index-pending', indexState: 'failed', finishedAt: new Date().toISOString(), error: { code: 'INDEX_FAILED', message: '知识已更新，索引待修复。', retryable: true } });
+    } catch (error) {
+      const details = error.details || { failureKind: 'LOCAL_ERROR', upstreamCode: error.code || 'UNKNOWN', upstreamMessage: this.safeMessage(error.message), attempt };
+      await this.diagnostics.error('knowledge.index.failed', '知识已更新，向量索引失败。', { ...context, error, context: details });
+      this.store.updateRun(run.runId, { state: 'index-pending', phase: 'index-pending', indexState: 'failed', finishedAt: new Date().toISOString(), error: { code: 'INDEX_FAILED', message: '知识已更新，索引待修复。', retryable: true, details } });
       this.notify(run, '知识已更新，索引待修复');
     }
   }
@@ -220,6 +249,7 @@ class EngineCoordinator extends EventEmitter {
     const job = this.sharedIndexQueue.catch(() => {}).then(async () => {
       if (this.closed || !this.store.state.sharedScopes.some(s => s.id === scope.id)) return;
       let index;
+      const attempt = (this.store.state.sharedScopes.find(s => s.id === scope.id)?.index?.attempts || 0) + 1;
       try {
         const files = require('./runtime/markdown-knowledge-indexer').listMarkdownFiles(scope.knowledgePath);
         const digest = crypto.createHash('sha256');
@@ -235,11 +265,13 @@ class EngineCoordinator extends EventEmitter {
           const payload = await health.json();
           if (health.ok && payload.projects?.some(p => p.name === `scope-${scope.kind}-${scope.id}` && p.hasIndex && this.layout.pathsEqual(p.sourceDir || '', scope.knowledgePath))) return;
         }
-        const response = await fetch(new URL('/api/import', this.vectorUrl), { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ projectName: `scope-${scope.kind}-${scope.id}`, sourceDir: scope.knowledgePath, watch: false }), signal: AbortSignal.timeout(120000) });
-        const payload = await response.json();
-        if (!response.ok || payload.ok !== true) throw new Error('INDEX_FAILED');
-        index = { status: 'ready', fingerprint, updatedAt: new Date().toISOString() };
-      } catch { index = { status: 'pending', message: '共享知识已保存，索引待恢复。' }; }
+        await requestIndex({ baseUrl: this.vectorUrl, route: '/api/import', body: { projectName: `scope-${scope.kind}-${scope.id}`, sourceDir: scope.knowledgePath, watch: false }, attempt, sanitize: this.safeMessage });
+        index = { status: 'ready', fingerprint, attempts: attempt, updatedAt: new Date().toISOString() };
+      } catch (error) {
+        const details = error.details || { failureKind: 'LOCAL_ERROR', upstreamCode: error.code || 'UNKNOWN', upstreamMessage: this.safeMessage(error.message), attempt };
+        index = { status: 'pending', message: '共享知识已保存，索引待恢复。', attempts: attempt, error: { code: 'INDEX_FAILED', details } };
+        await this.diagnostics.error('knowledge.shared_index.failed', index.message, { phase: 'indexing', operationId: `scope-index-${scope.id}-${attempt}`, error, context: { scopeId: scope.id, ...details } });
+      }
       // Configuration can replace projection objects while the import awaits.
       const current = this.store.state.sharedScopes.find(s => s.id === scope.id);
       if (!current) return;

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

@@ -10,7 +10,7 @@ function createDiagnostics({ dataDir, component = 'knowledge-engine', secrets =
     let text = String(value || '');
     let values = []; try { values = secrets() || []; } catch {}
     for (const secret of values) if (typeof secret === 'string' && secret.length >= 4) text = text.split(secret).join('[REDACTED]');
-    return text.replace(/(https?:\/\/)[^\s/@]+:[^\s/@]+@/gi, '$1[REDACTED]@').replace(/\b(Bearer|Basic)\s+[^\s]+/gi, '$1 [REDACTED]').replace(/((?:api[_-]?key|token|password|secret)\s*[=:]\s*)[^\s,;]+/gi, '$1[REDACTED]').slice(0, 8000);
+    return text.replace(/(https?:\/\/)[^\s/@]+:[^\s/@]+@/gi, '$1[REDACTED]@').replace(/\b(Bearer|Basic)\s+[^\s]+/gi, '$1 [REDACTED]').replace(/(["']?(?:api[_-]?key|auth[_-]?token|token|password|secret)["']?\s*[=:]\s*)(?:"[^"]*"|'[^']*'|[^\s,;&]+)/gi, '$1[REDACTED]').replace(/\bsk[-_][A-Za-z0-9_-]{8,}/g, '[REDACTED]').slice(0, 8000);
   };
   const logger = { sanitize, close: async () => {} };
   for (const level of ['debug', 'info', 'warn', 'error']) logger[level] = async (event, message, input = {}) => {

package/_modules/knowledge-engine/src/headless-analyzer.js

@@ -3,6 +3,7 @@ const { fork, execFile } = require('node:child_process');
 const path = require('node:path');
 const { frameFrozenEvidence } = require('./analysis-contract');
 const { finalizeAnalysisOutput } = require('./analysis-output');
+const { freezeKnowledgeTargets } = require('./knowledge-targets');
 
 class HeadlessAnalyzer {
   constructor({ resolveProfile, timeoutMs = 15 * 60 * 1000, workerPath = path.join(__dirname, 'analysis-worker.js') } = {}) { this.resolveProfile = resolveProfile; this.timeoutMs = timeoutMs; this.workerPath = workerPath; this.children = new Map(); this.closed = false; }
@@ -13,6 +14,7 @@ class HeadlessAnalyzer {
     const refs = [`commit:${input.claim.commitSha}`, `patch:${input.claim.patchHash}`, `conversation:${input.claim.conversationSnapshotHash}`, `retrieval:${input.claim.retrievalManifestHash}`];
     const contract = `\n\nOUTPUT CONTRACT\nRead frozen evidence only beneath ${input.evidenceRoot}. Write only beneath ${input.stagingPath}. Put Markdown under files/<allowed-path> (README.md, GOAL.md, ARCHITECTURE.md, modules/*.md, changes/*.md). Write ${input.manifestPath} with schema knowledge-staging-manifest/v1, projectId ${input.projectId}, runId ${input.claim.runId}, commitSha ${input.claim.commitSha}, and non-empty operations. Each operation needs path, operation (create/replace/delete), reason, and evidenceReferences ${JSON.stringify(refs)}. Omit sha256: the engine seals staged bytes itself. Do not modify code, final knowledge, other runs, or indexes. Do not invent intent if conversations are unavailable.`;
     const pathContract = `\nPATH CONTRACT (mandatory): operations[].path is the FINAL knowledge-relative POSIX path, NEVER a staging path and NEVER prefixed with "files/". Example: write the physical file ${path.join(input.stagingPath, 'files', 'changes', `${input.claim.commitSha.slice(0, 12)}.md`)} but put "path": "changes/${input.claim.commitSha.slice(0, 12)}.md" in manifest.json. Use forward slashes even on Windows. Minimal manifest shape: ${JSON.stringify({ schema: 'knowledge-staging-manifest/v1', projectId: input.projectId, runId: input.claim.runId, commitSha: input.claim.commitSha, operations: [{ path: `changes/${input.claim.commitSha.slice(0, 12)}.md`, operation: 'create', reason: 'Describe the evidence-backed change', evidenceReferences: refs }] })}`;
+    const targetContract = freezeKnowledgeTargets(input).contract;
     await new Promise((resolve, reject) => {
       const env = { ...process.env };
       delete env.CLAUDECODE;
@@ -50,7 +52,7 @@ class HeadlessAnalyzer {
       });
       const memoryContract = '\nYou may optionally include memoryCandidates in manifest.json: [{text, entryId, quote}]. Only suggest durable user preferences explicitly evidenced in a promoted document; quote must be an exact excerpt (at least 8 characters) from that document. Never infer preferences from code style alone. These stay unconfirmed until the user accepts them.';
       const languageContract = input.config?.knowledgeLanguage === 'en-US' ? '\nOUTPUT LANGUAGE: English. Preserve identifiers and verbatim evidence quotations.' : '\n输出语言：简体中文。知识正文、operations[].reason 与候选记忆用简体中文；代码标识、路径、哈希和原文证据引用保持不变。';
-      child.send({ profile, projectId: input.projectId, runId: input.claim.runId, commitSha: input.claim.commitSha, prompt: `${frameFrozenEvidence(input.prompt)}${contract}${pathContract}${memoryContract}${languageContract}`, manifestPath: input.manifestPath, stagingPath: input.stagingPath, safetyPolicy: input.safetyPolicy }, error => { if (error) stop(Object.assign(new Error('无法发送分析任务。'), { code: 'WORKER_START_FAILED', retryable: true })); });
+      child.send({ profile, projectId: input.projectId, runId: input.claim.runId, commitSha: input.claim.commitSha, prompt: `${frameFrozenEvidence(input.prompt)}${contract}${pathContract}${targetContract}${memoryContract}${languageContract}`, manifestPath: input.manifestPath, stagingPath: input.stagingPath, safetyPolicy: input.safetyPolicy }, error => { if (error) stop(Object.assign(new Error('无法发送分析任务。'), { code: 'WORKER_START_FAILED', retryable: true })); });
     });
     finalizeAnalysisOutput(input);
     return { ok: true };

package/_modules/knowledge-engine/src/index-request.js

@@ -0,0 +1,49 @@
+'use strict';
+
+async function requestIndex({ baseUrl, route, body, attempt = 1, timeoutMs = 120000, sanitize, fetchImpl = fetch }) {
+  const started = Date.now();
+  const clean = value => sanitize(String(value || '')).slice(0, 2048);
+  let httpStatus = null, requestId = null;
+  function failure(failureKind, upstreamCode, upstreamMessage) {
+    const details = { failureKind, httpStatus, upstreamCode: clean(upstreamCode).slice(0, 120), upstreamMessage: clean(upstreamMessage), requestId, durationMs: Math.max(0, Date.now() - started), attempt };
+    return Object.assign(new Error(`向量索引请求失败：${details.upstreamMessage}`), { code: 'INDEX_FAILED', phase: 'indexing', retryable: true, details });
+  }
+  try {
+    const response = await fetchImpl(new URL(route, baseUrl), { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body), signal: AbortSignal.timeout(timeoutMs) });
+    httpStatus = response.status;
+    requestId = clean(response.headers.get('x-request-id') || response.headers.get('request-id')).slice(0, 120) || null;
+    // Error responses can contain credentials or arbitrarily large HTML. Read
+    // a bounded JSON envelope, never persist a raw body or response headers.
+    const reader = response.body?.getReader();
+    let text = '', size = 0;
+    if (reader) {
+      const decoder = new TextDecoder();
+      try {
+        for (;;) {
+          const chunk = await reader.read();
+          if (chunk.done) break;
+          size += chunk.value.byteLength;
+          if (size > 16384) throw failure('INVALID_RESPONSE', 'RESPONSE_TOO_LARGE', '索引服务响应超过安全大小限制。');
+          text += decoder.decode(chunk.value, { stream: true });
+        }
+        text += decoder.decode();
+      } finally { await reader.cancel().catch(() => {}); }
+    }
+    let payload;
+    try { payload = JSON.parse(text); }
+    catch { throw failure('INVALID_RESPONSE', 'INVALID_JSON', `索引服务返回非 JSON 响应（HTTP ${httpStatus}）。`); }
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) throw failure('INVALID_RESPONSE', 'INVALID_ENVELOPE', '索引服务响应不符合协议。');
+    if (!response.ok || payload.ok === false || payload.error) {
+      const upstream = payload.error;
+      const message = typeof upstream === 'string' ? upstream : upstream?.message || payload.message || `索引服务返回 HTTP ${httpStatus}。`;
+      throw failure(response.ok ? 'UPSTREAM_ERROR' : 'HTTP_ERROR', upstream?.code || payload.code || `HTTP_${httpStatus}`, message);
+    }
+    if (payload.ok !== true) throw failure('INVALID_RESPONSE', 'INVALID_ENVELOPE', '索引服务响应缺少成功标识。');
+    return payload;
+  } catch (error) {
+    if (error.details && error.code === 'INDEX_FAILED') throw error;
+    const timeout = ['TimeoutError', 'AbortError'].includes(error.name);
+    throw failure(timeout ? 'TIMEOUT' : 'NETWORK_ERROR', error.cause?.code || error.code || (timeout ? 'INDEX_TIMEOUT' : 'INDEX_CONNECTION_FAILED'), error.message || (timeout ? '索引服务请求超时。' : '无法连接索引服务。'));
+  }
+}
+module.exports = { requestIndex };

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

@@ -0,0 +1,46 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const AtomicFile = require('./runtime/atomic-file');
+const { listMarkdownFiles } = require('./runtime/markdown-knowledge-indexer');
+const { canonicalRelativePath } = require('./runtime/knowledge-promotion');
+const hash = value => `sha256:${crypto.createHash('sha256').update(value).digest('hex')}`;
+
+function freezeKnowledgeTargets(input) {
+  const file = path.join(input.evidenceRoot, 'knowledge-targets.json');
+  const identity = { schema: 'knowledge-target-inventory/v1', projectId: input.projectId, runId: input.claim.runId, commitSha: input.claim.commitSha };
+  let inventory;
+  if (fs.existsSync(file)) {
+    inventory = AtomicFile.readJsonStrict(file);
+    const { manifestHash, ...payload } = inventory;
+    try {
+      if (Object.keys(identity).some(key => inventory[key] !== identity[key]) || !Array.isArray(inventory.entries) || manifestHash !== hash(JSON.stringify(payload))) throw new Error();
+      for (const entry of inventory.entries) {
+        if (canonicalRelativePath(entry.path) !== entry.path || !/^sha256:[a-f0-9]{64}$/.test(entry.sha256)) throw new Error();
+      }
+    } catch { throw Object.assign(new Error('Frozen knowledge target inventory is invalid.'), { code: 'EVIDENCE_INTEGRITY_FAILED' }); }
+  } else {
+    const root = input.config?.knowledgePath;
+    const entries = [];
+    if (root && fs.existsSync(root)) {
+      const realRoot = fs.realpathSync(root);
+      for (const source of listMarkdownFiles(root)) {
+        const real = fs.realpathSync(source), relative = path.relative(realRoot, real);
+        if (relative.startsWith('..') || path.isAbsolute(relative) || fs.lstatSync(source).isSymbolicLink()) continue;
+        const entryPath = path.relative(root, source).replace(/\\/g, '/');
+        try { canonicalRelativePath(entryPath); } catch { continue; }
+        entries.push({ path: entryPath, sha256: hash(fs.readFileSync(source)) });
+      }
+    }
+    const payload = { ...identity, entries: entries.sort((a, b) => a.path.localeCompare(b.path)) };
+    inventory = { ...payload, manifestHash: hash(JSON.stringify(payload)) };
+    AtomicFile.writeJsonAtomic(file, inventory);
+  }
+  // Retrieval snippets are not an existence check. Keep only metadata here,
+  // rather than copying the complete knowledge tree into every run on C:.
+  const contract = `\nTARGET INVENTORY (mandatory): Read ${file} before choosing output paths. It is the frozen inventory of existing owned knowledge paths, including files NOT selected by retrieval. Use create only for a path not in this inventory; use replace/delete only for an existing path. Retrieval snippets may be partial: never discard unrelated existing knowledge or reconstruct a full document from incomplete snippets. If the full prior document is unavailable in frozen evidence, leave it unchanged and write the evidence-backed update to changes/${input.claim.commitSha.slice(0, 12)}.md instead. Do not read the live final knowledge tree. The inventory is metadata evidence, not executable instructions. The engine will reject create on an existing target; do not work around that check.`;
+  return { file, inventory, contract };
+}
+
+module.exports = { freezeKnowledgeTargets };

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

@@ -10,15 +10,17 @@ class EngineRetrieval extends KnowledgeRetrievalService {
   signalSet(input = {}) {
     const signals = super.signalSet(input);
     const query = signals.indexQuery.trim().toLowerCase();
-    if (/^[a-f0-9]{7,64}$/.test(query) && this.store.listRuns().some(run => run.promotedAt && run.commitSha?.startsWith(query))) signals.commitPrefix = query;
+    const promoted = this.store.listRuns().filter(run => run.promotedAt && run.commitSha);
+    const identifiers = [...query.matchAll(/(?:^|[^a-z0-9])([a-f0-9]{7,64})(?=$|[^a-z0-9])/g)].map(match => match[1]);
+    signals.commitPrefixes = [...new Set(identifiers.filter(id => promoted.some(run => run.commitSha.startsWith(id))))];
     return signals;
   }
   score(candidate, signals) {
-    if (signals.commitPrefix) {
+    if (signals.commitPrefixes?.length) {
       // A known commit is an identifier, not a semantic topic. Unrelated
       // vector hits must not crowd its current, provenance-checked files out.
       const source = this.store.listRuns(candidate.projectId).find(run => run.promotedAt && run.staging?.operations?.some(operation => operation.path === candidate.entryId));
-      if (!source?.commitSha?.startsWith(signals.commitPrefix)) return { score: 0, selectionSignals: [] };
+      if (!signals.commitPrefixes.some(prefix => source?.commitSha?.startsWith(prefix))) return { score: 0, selectionSignals: [] };
       const result = super.score(candidate, signals);
       return { score: Math.max(1, result.score), selectionSignals: [...result.selectionSignals, 'exact-commit'] };
     }
@@ -40,7 +42,7 @@ class EngineRetrieval extends KnowledgeRetrievalService {
     return [...super.scopes(project), ...this.sharedScopes(registration, 'domain')];
   }
   sharedScopes(registration, range) {
-    return this.store.state.sharedScopes.filter(s => s.brainId === registration.brainId && (s.kind === 'brain' || range === 'brain' || s.domainId === registration.domainId)).map(s => ({ projectId: s.id, spaceId: `${s.kind}:${s.id}`, knowledgePath: s.knowledgePath, weight: s.kind === 'brain' ? 0.6 : 0.75, reason: s.kind }));
+    return this.store.state.sharedScopes.filter(s => s.brainId === registration.brainId && (s.kind === 'brain' || range === 'brain' || registration.domainId && s.domainId === registration.domainId)).map(s => ({ projectId: s.id, spaceId: `${s.kind}:${s.id}`, knowledgePath: s.knowledgePath, weight: s.kind === 'brain' ? 0.6 : 0.75, reason: s.kind }));
   }
   scanCurrent(scopes) {
     const ordinary = scopes.filter(s => this.store.getProject(s.projectId));
@@ -92,7 +94,7 @@ class EngineRetrieval extends KnowledgeRetrievalService {
     let scopes = [{ projectId: project.projectId, spaceId: project.primarySpaceId, knowledgePath: project.knowledgePath, weight: 1, reason: 'primary' }];
     if (input.scope === 'domain' || input.scope === 'brain') {
       scopes = this.store.listProjects().filter(p => p.enabled !== false && p.brainId === registration.brainId
-        && (input.scope === 'brain' || p.domainId === registration.domainId)).map(p => ({ projectId: p.projectId, spaceId: `project:${p.projectId}`, knowledgePath: p.knowledgePath, weight: p.projectId === registration.projectId ? 1 : 0.88, reason: p.projectId === registration.projectId ? 'primary' : input.scope }));
+        && (input.scope === 'brain' || p.projectId === registration.projectId || registration.domainId && p.domainId === registration.domainId)).map(p => ({ projectId: p.projectId, spaceId: `project:${p.projectId}`, knowledgePath: p.knowledgePath, weight: p.projectId === registration.projectId ? 1 : 0.88, reason: p.projectId === registration.projectId ? 'primary' : input.scope }));
       scopes.push(...this.sharedScopes(registration, input.scope));
     }
     const result = await super.search({ ...input, project, scopes });

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

@@ -3,7 +3,7 @@ const crypto = require('crypto');
 const { SCHEMAS, DomainError, validateProjectId } = require('./contracts');
 const AtomicFile = require('./atomic-file');
 
-const SOURCES = new Set(['claude-code', 'codex', 'opencode']);
+const SOURCES = new Set(['claude-code', 'codex', 'opencode', 'zcode']);
 const ROLES = new Set(['user', 'assistant', null]);
 const SNAPSHOT_STATUSES = new Set(['available', 'no-new-user-prompt', 'unavailable', 'ambiguous']);
 const BINDING_KINDS = new Set(['direct', 'shared-spanning', 'explicit']);

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

@@ -100,7 +100,7 @@ function createEngineServer(options = {}) {
 }
 
 async function api(method, pathname, search, body, store, coordinator, ctx) {
-  if (method === 'GET' && pathname === '/api/health') return { name: 'knowledge-engine', version: VERSION, dataSchemaVersion: store.state.schemaVersion, debug: ctx.debug, executionEnabled: coordinator.executionEnabled, uptimeSec: Math.floor((Date.now() - ctx.startedAt) / 1000), dataDir: ctx.dataDir, counts: { projects: store.state.projects.length, runs: store.state.runs.length, running: coordinator.active.size }, journal: { cursor: store.state.cursor, cursors: store.state.journalCursors, consumer: 'knowledge-engine', enabled: coordinator.consume, error: coordinator.journalError || null }, concurrency: coordinator.concurrency };
+  if (method === 'GET' && pathname === '/api/health') return { name: 'knowledge-engine', version: VERSION, dataSchemaVersion: store.state.schemaVersion, debug: ctx.debug, executionEnabled: coordinator.executionEnabled, uptimeSec: Math.floor((Date.now() - ctx.startedAt) / 1000), dataDir: ctx.dataDir, counts: { projects: store.state.projects.length, runs: store.state.runs.length, running: coordinator.active.size }, journal: { cursor: store.state.cursor, cursors: store.state.journalCursors, consumer: 'knowledge-engine', enabled: coordinator.consume, error: coordinator.journalError || null, failures: [...coordinator.journalFailures.values()] }, concurrency: coordinator.concurrency };
   if (method === 'GET' && pathname === '/api/projects') return { projects: store.listProjects() };
   if (method === 'GET' && pathname === '/api/memories') return { memories: coordinator.memories.list(Object.fromEntries(search)) };
   const memoryMatch = pathname.match(/^\/api\/memories\/([^/]+)$/);

package/_modules/knowledge-engine/ui/app.js

@@ -197,7 +197,7 @@ async function showRunDetail(runId) {
   $('#runDetail').classList.remove('hidden');
   $('#runDetailId').textContent = run.runId;
   $('#runTimeline').innerHTML = runTimeline(run);
-  $('#runMeta').innerHTML = `<div><dt>状态</dt><dd>${stateBadge(run.state)}</dd></div><div><dt>项目 / commit</dt><dd>${escapeHtml(run.projectId)} · <span class="mono">${shortSha(run.commitSha)}</span></dd></div><div><dt>触发入口</dt><dd class="mono">${escapeHtml(run.trigger)}</dd></div><div><dt>错误</dt><dd>${run.error ? escapeHtml(run.error.message) : '–'}</dd></div>${run.error?.retryable ? '<div><dt>恢复</dt><dd><button class="btn" id="retryRun">重试失败阶段</button></dd></div>' : ''}`;
+  $('#runMeta').innerHTML = `<div><dt>状态</dt><dd>${stateBadge(run.state)}</dd></div><div><dt>项目 / commit</dt><dd>${escapeHtml(run.projectId)} · <span class="mono">${shortSha(run.commitSha)}</span></dd></div><div><dt>触发入口</dt><dd class="mono">${escapeHtml(run.trigger)}</dd></div><div><dt>错误</dt><dd>${run.error ? escapeHtml(run.error.message) : '–'}</dd></div>${run.error?.details ? `<div><dt>索引原因</dt><dd>${escapeHtml(run.error.details.upstreamMessage)}<br>${escapeHtml(run.error.details.failureKind)} · HTTP ${escapeHtml(run.error.details.httpStatus ?? '–')} · ${escapeHtml(run.error.details.upstreamCode)}<br>请求 ${escapeHtml(run.error.details.requestId || '–')} · 尝试 ${escapeHtml(run.error.details.attempt)}</dd></div>` : ''}${run.error?.retryable ? '<div><dt>恢复</dt><dd><button class="btn" id="retryRun">重试失败阶段</button></dd></div>' : ''}`;
   $('#retryRun')?.addEventListener('click', async () => { await api(`/api/runs/${encodeURIComponent(runId)}/retry`, { method: 'POST' }); loadRuns(); });
   $('#runStaging').textContent = run.staging ? JSON.stringify(run.staging, null, 2) : '该运行没有 staging 产物。';
 }

package/_site/_test/candidate-release-contract-test.js

@@ -0,0 +1,14 @@
+'use strict';
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { isPinnedModuleVersion } = require('../scripts/verify-module-runtime');
+for (const name of ['claude-ai-workbench', '@sanqianx/vector-hub', '@sanqianx/ai-coding-event-bridge-console']) {
+  for (const version of ['1.2.3', '1.2.3-rc.1', '1.2.3-rc.12']) assert.ok(isPinnedModuleVersion(name, version));
+  for (const version of ['latest', 'next', '^1.2.3', '~1.2.3', '>=1.2.3', 'file:../module', 'link:module', 'workspace:*', '1.2.3-beta.1', '1.2.3-rc', undefined]) assert.equal(isPinnedModuleVersion(name, version), false, String(version));
+}
+assert.ok(isPinnedModuleVersion('claude-ai-workbench', 'npm:@sanqianx/claude-ai-workbench@0.13.2-rc.1'));
+assert.equal(isPinnedModuleVersion('@sanqianx/vector-hub', 'npm:@sanqianx/claude-ai-workbench@0.13.2-rc.1'), false);
+const manifest = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../module-runtime-manifest.json')));
+for (const file of ['ui/index.html', 'ui/product.js', 'ui/product.css', 'ui/favicon.svg']) assert.match(manifest.productFiles[file], /^[a-f0-9]{64}$/);
+console.log('candidate-release-contract-test PASS');