@sanqianx/project-knowledge 5.0.24 → 5.0.25

package/_site/_test/parallel-memory-scope-test.js

@@ -0,0 +1,228 @@
+'use strict';
+// _site/_test/parallel-memory-scope-test.js
+//
+// MEM-004 确认目标（适用范围）.
+//
+// Real isolated product instance, real browser, real HTTP and real disk. Three
+// real projects are imported into one real brain: two of them belong to a real
+// domain, the third belongs to none. Three real memories are added through the
+// real UI: one global, one bound to the domain, one bound to a single project.
+//
+// MEM-004 expected:
+//   * scopeId与scopeType匹配。 -> the stored memory carries the scope id that
+//                                 belongs to its scope type, the UI only offers
+//                                 targets of that type, and the engine refuses
+//                                 a scope id that does not belong to the
+//                                 declared scope type;
+//   * 只影响指定范围。           -> a global memory reaches every project, a
+//                                 domain memory only reaches the projects of
+//                                 that domain, a project memory only reaches
+//                                 that project.
+
+const fs = require('node:fs');
+const path = require('node:path');
+const assert = require('node:assert/strict');
+
+const { startHarness, makeRepo } = require('./helpers/parallel-memory-shell');
+
+const EVIDENCE = process.env.PK_TEST_EVIDENCE_DIR ? path.resolve(process.env.PK_TEST_EVIDENCE_DIR) : null;
+const GLOBAL_TEXT = '全局约定：所有对外错误信息使用中文表述。';
+const DOMAIN_TEXT = '平台领域约定：发布流程必须先跑完整回归。';
+const PROJECT_TEXT = '项目约定：数据库迁移脚本一律放在 db/migrations。';
+
+async function openMemoryView(harness) {
+  await harness.nativeClick('nav [data-view="memory"]');
+  await harness.waitFor(
+    () => harness.run("document.getElementById('view-memory').classList.contains('active')"),
+    'the memory view is open',
+    10000,
+  );
+}
+
+/** Add one memory through the real UI and return what the engine answered. */
+async function addMemoryViaUi(harness, { text, scopeType, scopeId }) {
+  await harness.nativeClick('#addMemory');
+  await harness.waitFor(
+    () => harness.run("document.getElementById('memoryDialog').open === true"),
+    'the add dialog is open',
+    10000,
+  );
+  await harness.typeText(text);
+  await harness.selectOption('#memoryScope', scopeType);
+  if (scopeType !== 'global') {
+    const options = await harness.run("Array.from(document.getElementById('memoryTarget').options).map(o => o.value)");
+    assert.ok(options.includes(scopeId), `the ${scopeType} scope offers ${scopeId}: ${JSON.stringify(options)}`);
+    await harness.selectOption('#memoryTarget', scopeId);
+  }
+  const postsBefore = harness.network.find(entry => entry.method === 'POST' && entry.url.includes('/api/engine/memories')).length;
+  await harness.nativeClick('#confirmMemory');
+  await harness.waitFor(
+    () => harness.run("document.getElementById('memoryDialog').open === false"),
+    'the dialog closes after the save',
+    15000,
+  );
+  const post = harness.network.find(entry => entry.method === 'POST' && entry.url.includes('/api/engine/memories'))[postsBefore];
+  assert.ok(post, 'the shell really posted the memory');
+  assert.equal(post.status, 200, `the real POST answers 200: ${JSON.stringify(post.body)}`);
+  const body = await harness.network.body(post);
+  assert.ok(body && body.memory, `the real POST answers with the memory: ${JSON.stringify(body)}`);
+  assert.equal(body.memory.text, text, 'the saved text is the text that was typed');
+  assert.equal(body.memory.scopeType, scopeType, 'the saved scope type is the chosen one');
+  assert.equal(body.memory.scopeId, scopeId || body.memory.brainId, 'the saved scope id belongs to the scope type');
+  assert.equal(body.memory.status, 'confirmed', 'the memory is saved as confirmed');
+  return { memory: body.memory, request: post.body, url: post.url.replace(harness.base, '') };
+}
+
+async function main() {
+  const harness = await startHarness({ tag: 'memscope', evidenceDir: EVIDENCE || undefined });
+  const evidence = [];
+  try {
+    const domain = await harness.addDomain('平台领域');
+    assert.ok(domain.id, 'the real domain has an id');
+
+    const repoA = makeRepo(harness.fixture, 'memscope-a', { 'README.md': '# 甲\n' });
+    const repoB = makeRepo(harness.fixture, 'memscope-b', { 'README.md': '# 乙\n' });
+    const repoC = makeRepo(harness.fixture, 'memscope-c', { 'README.md': '# 丙\n' });
+    const a = await harness.importProject(repoA, '范围甲', { domainId: domain.id });
+    const b = await harness.importProject(repoB, '范围乙', { domainId: domain.id });
+    const c = await harness.importProject(repoC, '范围丙');
+
+    await harness.requestRegistryRefresh();
+    await harness.waitFor(
+      () => harness.run("document.getElementById('homeContent').textContent.includes('范围丙')"),
+      'the imported projects are listed',
+      20000,
+    );
+
+    // The engine really knows the domain binding of every project.
+    const engineProjects = (await harness.engineApi('GET', '/api/projects')).body.projects;
+    assert.equal(engineProjects.find(p => p.projectId === a.projectId).domainId, domain.id, 'the engine knows the domain of 甲');
+    assert.equal(engineProjects.find(p => p.projectId === b.projectId).domainId, domain.id, 'the engine knows the domain of 乙');
+    assert.equal(engineProjects.find(p => p.projectId === c.projectId).domainId || null, null, 'the engine knows 丙 has no domain');
+
+    // The UI works on project 甲, the one inside the domain.
+    await harness.selectOption('#projectSelect', a.projectId);
+    await harness.waitFor(
+      () => harness.run("document.getElementById('projectSelect').value === " + JSON.stringify(a.projectId)),
+      'the active project is 甲',
+      10000,
+    );
+    await openMemoryView(harness);
+    await harness.waitFor(
+      () => harness.run("!document.getElementById('addMemory').disabled"),
+      'the engine is reachable and the add button is live',
+      20000,
+    );
+
+    // ---------------------------------------------------------------- MEM-004
+    const globalMemory = await addMemoryViaUi(harness, { text: GLOBAL_TEXT, scopeType: 'global' });
+    const domainMemory = await addMemoryViaUi(harness, { text: DOMAIN_TEXT, scopeType: 'domain', scopeId: domain.id });
+    const projectMemory = await addMemoryViaUi(harness, { text: PROJECT_TEXT, scopeType: 'project', scopeId: a.projectId });
+
+    assert.equal(globalMemory.memory.scopeId, globalMemory.memory.brainId, 'a global memory targets the brain itself');
+    assert.equal(domainMemory.memory.scopeId, domain.id, 'a domain memory targets the domain');
+    assert.equal(projectMemory.memory.scopeId, a.projectId, 'a project memory targets the project');
+
+    // The scope id has to belong to the scope type: the engine refuses the
+    // mismatched combinations instead of silently storing them.
+    const mismatches = [
+      { scopeType: 'domain', scopeId: a.projectId, why: 'a project id is not a domain' },
+      { scopeType: 'project', scopeId: domain.id, why: 'a domain id is not a project' },
+      { scopeType: 'global', scopeId: a.projectId, why: 'a global memory always targets the brain' },
+    ];
+    for (const mismatch of mismatches) {
+      const refused = await harness.productApi('POST', '/api/engine/memories', { text: `范围不匹配的记忆：${mismatch.why}`, scopeType: mismatch.scopeType, scopeId: mismatch.scopeId });
+      assert.equal(refused.status, 400, `the engine refuses ${mismatch.why}: ${JSON.stringify(refused.body)}`);
+      assert.equal(refused.body.error, 'INVALID_ARGUMENT', 'the engine reports an invalid argument');
+      assert.match(String(refused.body.message), /所选记忆目标不存在或不属于当前智脑。/, 'the engine names the missing target');
+    }
+    const noMismatch = await harness.productMemories();
+    assert.ok(!noMismatch.some(memory => memory.text.startsWith('范围不匹配的记忆')), 'no mismatched memory was stored');
+
+    // 只影响指定范围: the injection matrix.
+    const injectedA = await harness.injectedMemories(a.projectId);
+    const injectedB = await harness.injectedMemories(b.projectId);
+    const injectedC = await harness.injectedMemories(c.projectId);
+    const ids = injected => injected.map(entry => entry.memoryId);
+    assert.ok(ids(injectedA).includes(globalMemory.memory.id), 'the global memory reaches 甲');
+    assert.ok(ids(injectedB).includes(globalMemory.memory.id), 'the global memory reaches 乙');
+    assert.ok(ids(injectedC).includes(globalMemory.memory.id), 'the global memory reaches 丙');
+    assert.ok(ids(injectedA).includes(domainMemory.memory.id), 'the domain memory reaches 甲');
+    assert.ok(ids(injectedB).includes(domainMemory.memory.id), 'the domain memory reaches 乙');
+    assert.ok(!ids(injectedC).includes(domainMemory.memory.id), `the domain memory does not reach 丙: ${JSON.stringify(injectedC)}`);
+    assert.ok(ids(injectedA).includes(projectMemory.memory.id), 'the project memory reaches 甲');
+    assert.ok(!ids(injectedB).includes(projectMemory.memory.id), `the project memory does not reach 乙: ${JSON.stringify(injectedB)}`);
+    assert.ok(!ids(injectedC).includes(projectMemory.memory.id), `the project memory does not reach 丙: ${JSON.stringify(injectedC)}`);
+
+    // The real UI names the scope of every memory.
+    await harness.reload();
+    await openMemoryView(harness);
+    await harness.nativeClick('[data-memory-tab="confirmed"]');
+    await harness.waitFor(
+      () => harness.run(`document.getElementById('memoryContent').textContent.includes(${JSON.stringify(GLOBAL_TEXT)})`),
+      'the confirmed memories are listed',
+      15000,
+    );
+    const scopeLabels = await harness.run("Array.from(document.querySelectorAll('[data-memory-card]')).map(el => el.textContent)");
+    const globalCard = scopeLabels.find(text => text.includes(GLOBAL_TEXT));
+    const domainCard = scopeLabels.find(text => text.includes(DOMAIN_TEXT));
+    const projectCard = scopeLabels.find(text => text.includes(PROJECT_TEXT));
+    assert.match(globalCard, /全局/, 'the UI names the global scope');
+    assert.match(domainCard, /领域/, 'the UI names the domain scope');
+    assert.match(domainCard, new RegExp(domain.name), 'the UI names the domain');
+    assert.match(projectCard, /项目/, 'the UI names the project scope');
+    assert.match(projectCard, new RegExp('范围甲'), 'the UI names the project');
+    if (harness.evidence) await harness.browser.screenshot(path.join(harness.evidence, 'mem004-scopes.png'));
+
+    // The memory files really live in the scope they claim. The engine
+    // materializes every scope's memory file in the brain's shared directory:
+    // the domain scope directory itself holds no memory file.
+    const brainScope = harness.brainScopePath();
+    const domainScope = harness.domainScopePath(domain.id);
+    assert.ok(fs.existsSync(path.join(brainScope, 'memories', 'confirmed.md')), 'the global memory file exists');
+    assert.ok(fs.existsSync(path.join(brainScope, 'memories', 'domains', `${domain.id}.md`)), 'the domain memory file exists');
+    assert.ok(fs.existsSync(path.join(brainScope, 'memories', 'projects', `${a.projectId}.md`)), 'the project memory file exists');
+    assert.ok(!fs.existsSync(path.join(domainScope, 'memories')), 'the domain scope directory holds no memory file of its own');
+    const globalFile = fs.readFileSync(path.join(brainScope, 'memories', 'confirmed.md'), 'utf8');
+    assert.ok(globalFile.includes(globalMemory.memory.id), 'the global file holds the global memory');
+    assert.ok(!globalFile.includes(domainMemory.memory.id), 'the global file does not hold the domain memory');
+    const domainFile = fs.readFileSync(path.join(brainScope, 'memories', 'domains', `${domain.id}.md`), 'utf8');
+    assert.ok(domainFile.includes(domainMemory.memory.id), 'the domain file holds the domain memory');
+    const projectFile = fs.readFileSync(path.join(brainScope, 'memories', 'projects', `${a.projectId}.md`), 'utf8');
+    assert.ok(projectFile.includes(projectMemory.memory.id), 'the project file holds the project memory');
+    assert.ok(!projectFile.includes(globalMemory.memory.id), 'the project file does not hold the global memory');
+
+    evidence.push({
+      case: 'MEM-004',
+      domain: { id: domain.id, name: domain.name },
+      projects: { a: a.projectId, b: b.projectId, c: c.projectId },
+      memories: {
+        global: { id: globalMemory.memory.id, scopeType: globalMemory.memory.scopeType, scopeId: globalMemory.memory.scopeId },
+        domain: { id: domainMemory.memory.id, scopeType: domainMemory.memory.scopeType, scopeId: domainMemory.memory.scopeId },
+        project: { id: projectMemory.memory.id, scopeType: projectMemory.memory.scopeType, scopeId: projectMemory.memory.scopeId },
+      },
+      mismatchedScopes: mismatches.map(mismatch => mismatch.scopeType),
+      injected: { a: ids(injectedA), b: ids(injectedB), c: ids(injectedC) },
+      files: {
+        brainScope,
+        domainScope,
+        global: path.join(brainScope, 'memories', 'confirmed.md'),
+        domain: path.join(brainScope, 'memories', 'domains', `${domain.id}.md`),
+        project: path.join(brainScope, 'memories', 'projects', `${a.projectId}.md`),
+      },
+    });
+
+    assert.equal(harness.browser.exceptions.length, 0, `no uncaught product JavaScript exceptions: ${JSON.stringify(harness.browser.exceptions)}`);
+
+    if (harness.evidence) {
+      fs.mkdirSync(harness.evidence, { recursive: true });
+      fs.writeFileSync(path.join(harness.evidence, 'mem004-scope.json'), `${JSON.stringify(evidence, null, 2)}\n`, 'utf8');
+    }
+
+    console.log('parallel-memory-scope-test PASS (MEM-004 scope id matches scope type; global, domain and project scopes only reach their own range)');
+  } finally {
+    await harness.cleanup();
+  }
+}
+
+main().catch(error => { console.error(error.stack || error.message); process.exitCode = 1; });

package/_site/_test/parallel-memory-source-test.js

@@ -0,0 +1,227 @@
+'use strict';
+// _site/_test/parallel-memory-source-test.js
+//
+// MEM-008 来源边界（维护 / 委派不自动成为人类偏好）.
+//
+// Real isolated product instance, real browser, real HTTP and real disk.
+//
+// Every case runs the REAL pipeline: a real follow-up commit, a real frozen
+// conversation event with a real inputOrigin, the real promotion of a staged
+// Markdown file and the engine's own MemoryService.capture() with its own
+// provenance gate (MemoryEligibility). The stand-in analyzer plays the role of
+// the model: it proposes a candidate that reads exactly like an owner
+// preference, and the engine's own gate has to refuse it.
+//
+// HONEST SCOPE LABEL: the analysis step is this lane's declared stand-in
+// analyzer. These cases prove the engine's admission gate, never the model's
+// judgement about what is worth remembering.
+//
+// MEM-008 expected:
+//   * 不自动成为人类偏好。 -> a delegated task order, an unverifiable source and
+//                            a candidate without a user event are all refused
+//                            by the engine's own gate; no memory is stored, the
+//                            real candidate box stays empty and nothing is
+//                            injected;
+//   * C01未解决项明确阻断。  -> the human side cannot be proven in this batch:
+//                            a real Workbench conversation is needed and MEM-007
+//                            is deferred to the real-Workbench batch, so this
+//                            case is reported as BLOCKED, not as a pass.
+
+const fs = require('node:fs');
+const path = require('node:path');
+const assert = require('node:assert/strict');
+
+const { startHarness, makeRepo, commitFile } = require('./helpers/parallel-memory-shell');
+
+const EVIDENCE = process.env.PK_TEST_EVIDENCE_DIR ? path.resolve(process.env.PK_TEST_EVIDENCE_DIR) : null;
+const DELEGATED_TEXT = '委派指令：请在所有项目中统一使用中文错误提示。';
+const UNKNOWN_TEXT = '来源不明的要求：所有提交信息必须使用祈使句。';
+const UNSOURCED_TEXT = '维护产物自述：团队偏好所有注释使用中文。';
+const MISSING_EVENT_TEXT = '引用不存在的事件：所有文档必须标注版本号。';
+
+async function main() {
+  const harness = await startHarness({ tag: 'memsource', evidenceDir: EVIDENCE || undefined });
+  const evidence = [];
+  try {
+    const repo = makeRepo(harness.fixture, 'memsource-repo', { 'README.md': '# 来源甲\n' });
+    const { projectId } = await harness.importProject(repo, '来源甲');
+    await harness.requestRegistryRefresh();
+    await harness.waitFor(
+      () => harness.run("document.getElementById('homeContent').textContent.includes('来源甲')"),
+      'the imported project is listed',
+      20000,
+    );
+
+    /** Run one real maintenance round that proposes one candidate. */
+    const attempt = async ({ file, content, document, candidate, inputOrigin = 'human', eventContent }) => {
+      const head = commitFile(repo, file, content, 'source boundary commit');
+      let event = null;
+      if (eventContent !== null) {
+        event = await harness.ingestUserEvent({ projectId, commitSha: head, content: eventContent, inputOrigin });
+      }
+      harness.plan.document = document;
+      harness.plan.memoryCandidates = [candidate(event)];
+      const run = await harness.triggerRun(projectId, head);
+      return { run, commitSha: head, event, capture: run.memoryCapture };
+    };
+
+    // ------------------------------------------------------- delegated order
+    const delegated = await attempt({
+      file: 'src/delegated.js',
+      content: `// ${DELEGATED_TEXT}\n`,
+      document: `# 冻结证据\n\n${DELEGATED_TEXT}\n`,
+      inputOrigin: 'agent-delegation',
+      eventContent: `委派任务：${DELEGATED_TEXT}`,
+      candidate: event => harness.memoryCandidate({ text: DELEGATED_TEXT, event, scopeType: 'global' }),
+    });
+    assert.equal(delegated.capture.accepted, 0, 'a delegated task order is not admitted');
+    assert.deepEqual(delegated.capture.rejected.map(entry => entry.code), ['SOURCE_NOT_HUMAN'], 'the gate names the non-human source');
+
+    // ------------------------------------------------------- unknown origin
+    const unknown = await attempt({
+      file: 'src/unknown.js',
+      content: `// ${UNKNOWN_TEXT}\n`,
+      document: `# 冻结证据\n\n${UNKNOWN_TEXT}\n`,
+      inputOrigin: 'unknown',
+      eventContent: `无法确认来源的输入：${UNKNOWN_TEXT}`,
+      candidate: event => harness.memoryCandidate({ text: UNKNOWN_TEXT, event, scopeType: 'global' }),
+    });
+    assert.equal(unknown.capture.accepted, 0, 'an unverifiable source is not admitted');
+    assert.deepEqual(unknown.capture.rejected.map(entry => entry.code), ['SOURCE_NOT_HUMAN'], 'the gate names the non-human source');
+
+    // ------------------------------------- candidate without any user event
+    const unsourced = await attempt({
+      file: 'src/unsourced.js',
+      content: `// ${UNSOURCED_TEXT}\n`,
+      document: `# 冻结证据\n\n${UNSOURCED_TEXT}\n`,
+      eventContent: `人工要求：${UNSOURCED_TEXT}`,
+      candidate: () => ({
+        text: UNSOURCED_TEXT,
+        quote: UNSOURCED_TEXT,
+        scopeType: 'global',
+        eligibility: { durable: true, crossProject: true, reason: '人工明确表达的长期偏好', scopeReason: '适用于所有领域与项目' },
+      }),
+    });
+    assert.equal(unsourced.capture.accepted, 0, 'a candidate without a user event is not admitted');
+    assert.deepEqual(unsourced.capture.rejected.map(entry => entry.code), ['SOURCE_EVENT_MISSING'], 'the gate names the missing source event');
+
+    // ------------------------------------------ candidate with a wrong event
+    const missingEvent = await attempt({
+      file: 'src/missing-event.js',
+      content: `// ${MISSING_EVENT_TEXT}\n`,
+      document: `# 冻结证据\n\n${MISSING_EVENT_TEXT}\n`,
+      eventContent: `人工要求：${MISSING_EVENT_TEXT}`,
+      candidate: () => ({
+        text: MISSING_EVENT_TEXT,
+        quote: MISSING_EVENT_TEXT,
+        scopeType: 'global',
+        sourceEventId: 'event-does-not-exist',
+        sourceHash: 'sha256:0000000000000000000000000000000000000000000000000000000000000000',
+        eligibility: { durable: true, crossProject: true, reason: '人工明确表达的长期偏好', scopeReason: '适用于所有领域与项目' },
+      }),
+    });
+    assert.equal(missingEvent.capture.accepted, 0, 'a candidate citing an unknown event is not admitted');
+    assert.deepEqual(missingEvent.capture.rejected.map(entry => entry.code), ['SOURCE_EVENT_NOT_FOUND'], 'the gate names the unknown source event');
+
+    // Nothing became a memory anywhere.
+    const stored = await harness.productMemories();
+    assert.deepEqual(stored, [], `no memory was stored: ${JSON.stringify(stored)}`);
+    const injected = await harness.injectedMemories(projectId);
+    assert.deepEqual(injected, [], `nothing is injected: ${JSON.stringify(injected)}`);
+
+    // The real UI shows an empty candidate box and says the shell does not
+    // turn project behaviour into the owner's preferences.
+    //
+    // Failure-path visibility (CI 40062048045 kept only a bare timeout): on a
+    // navigation failure, capture the page's real readiness state, the reload
+    // gate log, the product's uncaught exceptions and a screenshot (small
+    // metadata; the CI console is the only artifact the runner keeps).
+    const debugNavigationFailure = async stage => {
+      try {
+        const state = await harness.navigationState();
+        const exceptions = harness.browser.exceptions
+          .map(entry => String((entry.exceptionDetails && (entry.exceptionDetails.exception && entry.exceptionDetails.exception.description || entry.exceptionDetails.text)) || ''))
+          .filter(Boolean).slice(0, 3);
+        console.error(`MEM-008 navigation failure at ${stage}: ${JSON.stringify(state)} reloadGate=${JSON.stringify(harness.reloadLog)} exceptions=${JSON.stringify(exceptions)}`);
+        if (harness.evidence) await harness.browser.screenshot(path.join(harness.evidence, `mem008-failure-${stage}.png`));
+      } catch {}
+    };
+    await harness.reload();
+    await harness.nativeClick('nav [data-view="memory"]');
+    try {
+      await harness.waitFor(
+        () => harness.run("document.getElementById('view-memory').classList.contains('active')"),
+        'the memory view is open',
+        10000,
+      );
+    } catch (error) {
+      await debugNavigationFailure('memory-view-open');
+      throw error;
+    }
+    await harness.nativeClick('[data-memory-tab="candidate"]');
+    try {
+      await harness.waitFor(
+        () => harness.run("document.getElementById('memoryContent').textContent.includes('候选箱为空。')"),
+        'the candidate box is really empty once the engine answered again',
+        20000,
+      );
+    } catch (error) {
+      await debugNavigationFailure('candidate-box-empty');
+      throw error;
+    }
+    const candidateBox = await harness.run("document.getElementById('memoryContent').textContent");
+    assert.match(candidateBox, /候选箱为空。/, `the candidate box is really empty: ${candidateBox}`);
+    assert.ok(!candidateBox.includes(DELEGATED_TEXT), 'the delegated order is not listed');
+    assert.ok(!candidateBox.includes(UNSOURCED_TEXT), 'the unsourced preference is not listed');
+    if (harness.evidence) await harness.browser.screenshot(path.join(harness.evidence, 'mem008-candidate-empty.png'));
+
+    await harness.nativeClick('nav [data-view="home"]');
+    try {
+      await harness.waitFor(
+        () => harness.run("document.getElementById('view-home').classList.contains('active')"),
+        'the home view is open',
+        10000,
+      );
+    } catch (error) {
+      await debugNavigationFailure('home-view-open');
+      throw error;
+    }
+    const home = await harness.run("document.getElementById('homeContent').textContent");
+    assert.match(home, /没有待确认记忆。智脑不会自动把项目行为当作你的偏好。/, `the home view states the boundary: ${home}`);
+    if (harness.evidence) await harness.browser.screenshot(path.join(harness.evidence, 'mem008-home.png'));
+
+    evidence.push({
+      case: 'MEM-008',
+      attempts: [
+        { kind: 'agent-delegation', commitSha: delegated.commitSha, accepted: delegated.capture.accepted, rejected: delegated.capture.rejected },
+        { kind: 'unknown', commitSha: unknown.commitSha, accepted: unknown.capture.accepted, rejected: unknown.capture.rejected },
+        { kind: 'no-user-event', commitSha: unsourced.commitSha, accepted: unsourced.capture.accepted, rejected: unsourced.capture.rejected },
+        { kind: 'unknown-event-id', commitSha: missingEvent.commitSha, accepted: missingEvent.capture.accepted, rejected: missingEvent.capture.rejected },
+      ],
+      storedMemories: stored,
+      injected,
+      ui: { candidateBox, home },
+      blocked: [{
+        id: 'C01',
+        expectation: 'C01未解决项明确阻断。',
+        status: 'BLOCKED',
+        reason: 'The human side of the boundary needs a real Workbench conversation: whether a Workbench user event is the owner speaking depends on the unresolved C01 boundary-record chain. This batch has no real Workbench session (MEM-007 is deferred to the real-Workbench batch), so only the engine-side refusal of delegated / unverifiable / unsourced candidates is proven here.',
+        evidenceInThisBatch: 'The engine conversation store was fed a real event with inputOrigin=human through the engine\'s own store, so the human path of the gate is exercised at the store level only.',
+      }],
+      scopeLabel: 'honest: the analysis step is the lane stand-in analyzer, not a model',
+    });
+
+    assert.equal(harness.browser.exceptions.length, 0, `no uncaught product JavaScript exceptions: ${JSON.stringify(harness.browser.exceptions)}`);
+
+    if (harness.evidence) {
+      fs.mkdirSync(harness.evidence, { recursive: true });
+      fs.writeFileSync(path.join(harness.evidence, 'mem008-source-boundary.json'), `${JSON.stringify(evidence, null, 2)}\n`, 'utf8');
+    }
+
+    console.log('parallel-memory-source-test PASS (MEM-008 delegated / unverifiable / unsourced candidates are all refused by the real gate; C01 human-source determination is BLOCKED in this batch)');
+  } finally {
+    await harness.cleanup();
+  }
+}
+
+main().catch(error => { console.error(error.stack || error.message); process.exitCode = 1; });