@sanqianx/project-knowledge 5.0.23 → 5.0.25

package/_site/_test/helpers/parallel-logging-integration-5025-env.js

@@ -0,0 +1,432 @@
+'use strict';
+// _site/_test/helpers/parallel-logging-integration-5025-env.js
+//
+// Canonical, tracked isolation environment for the logging acceptance and
+// logging-safety regression entries (lane P-QA-LOG-INTEGRATION-5025, extended
+// by lane P-LOGGING-ISOLATION-R2).
+//
+// Why this helper exists
+// ----------------------
+// The logging entries used to hardcode one developer's temp root
+// ('D:/SanQian.Xu/.project-knowledge-test-temp'). That path cannot be entered
+// into a cross-platform canonical `npm test`, and it also left the entries
+// running with the developer's real HOME/APPDATA/LOCALAPPDATA, so a child
+// process could still reach real user configuration.
+//
+// P-LOGGING-ISOLATION-R2 closed the remaining gap: redirecting a few
+// directories is not isolation. The ambient environment still reached the
+// driver itself and, through it, every child process - provider keys and
+// tokens, credential-bearing proxies, NODE_OPTIONS, module URLs/ports and
+// other CLI-injected configuration were inherited verbatim. The helper now
+// sanitizes the driver's own environment BEFORE any product module loads.
+//
+// Contract implemented here
+// -------------------------
+//   * browser capture first: the real Chrome executable is resolved BEFORE
+//     HOME/LOCALAPPDATA move. A per-user Chrome lives under LOCALAPPDATA, so
+//     redirecting it first would make findChrome() fall back to the
+//     developer's real browser profile. The captured path is re-exported as
+//     KB_CHROME_PATH, which find-chrome consults first.
+//   * environment whitelist: only the system baseline and this tool's own
+//     knobs survive. Everything else - provider keys/tokens, proxies,
+//     NODE_OPTIONS, module URLs/ports, CLI-injected configuration - is
+//     removed from the driver, so every child inherits the clean base.
+//   * temp root: PK_TEST_TEMP_ROOT when set (must be absolute), otherwise
+//     os.tmpdir(). The resolved root must live OUTSIDE the source repository
+//     - a temp root inside the checkout would put test data into the tree
+//     that CI packs and publishes. Violations throw; they never degrade into
+//     a "test passed" state.
+//   * every entry installs, BEFORE any other module is loaded, its own
+//     HOME / USERPROFILE / CODEX_HOME / CLAUDE_CONFIG_DIR / APPDATA /
+//     LOCALAPPDATA / TEMP / TMP / TMPDIR, its own dual product data root
+//     (KB_DATA_DIR + KB_KNOWLEDGE_DATA_DIR), its own Bridge journal home and
+//     its own Workbench / agent-terminal data root. The developer's real
+//     configuration is never read or overwritten by a test.
+//   * PSModuleAnalysisCachePath points at a FILE inside the lane tree whose
+//     parent directory exists, so PowerShell (used by the browser cleanup
+//     helper) cannot write its module analysis cache into the developer's
+//     real profile.
+//   * module endpoints are explicit and dead: the module URL keys point at
+//     the loopback dead address, the module flags are '0' (the product tests
+//     `=== '0'`) and the module command keys are empty strings (the product
+//     tests truthiness, so '0' would be read as a configured command).
+//     KB_MODULES_AUTOSTART=0 / KB_MODULES_REGISTER=0 keep the product from
+//     registering or starting real modules.
+//   * Chrome >= 136 refuses --remote-debugging-port unless the default user
+//     data directory resolves. With HOME/APPDATA/LOCALAPPDATA redirected, the
+//     platform default directory is scaffolded empty so the real browser
+//     still launches. The browser itself stays real: no stub, no fake PASS.
+//   * evidence: PK_TEST_EVIDENCE_ROOT overrides the per-case evidence
+//     directory (the default stays in the repository's gitignored
+//     qa-autopilot/artifacts tree).
+//   * explicit lane endpoints / stand-ins (extraEnv) are applied AFTER the
+//     sanitization and are never removed afterwards.
+//
+// The helper is dependency-free on purpose: it must be requirable before the
+// product modules so the environment is already isolated when they load.
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..', '..');
+
+// The system variables a test process may inherit. Everything that is not
+// listed here is ambient state and is removed before the product loads.
+const SYSTEM_ENV_ALLOWLIST = [
+  'PATH',
+  'PATHEXT',
+  'SystemRoot',
+  'WINDIR',
+  'ComSpec',
+  'SystemDrive',
+  'NUMBER_OF_PROCESSORS',
+  'PROCESSOR_ARCHITECTURE',
+  'PROCESSOR_ARCHITEW6432',
+  'PROCESSOR_IDENTIFIER',
+  'PROCESSOR_LEVEL',
+  'PROCESSOR_REVISION',
+  'OS',
+  'ProgramData',
+  'ProgramFiles',
+  'ProgramFiles(x86)',
+  'CommonProgramFiles',
+  'CommonProgramFiles(x86)',
+  'CommonProgramW6432',
+  'ALLUSERSPROFILE',
+  'PUBLIC',
+  'USERNAME',
+  'USERDOMAIN',
+  'COMPUTERNAME',
+  'LOGONSERVER',
+  'SESSIONNAME',
+  'LANG',
+  'LANGUAGE',
+  'LC_ALL',
+  'LC_CTYPE',
+  'TZ',
+  'TERM',
+  'SHELL',
+  'DISPLAY',
+  'WAYLAND_DISPLAY',
+  'XAUTHORITY',
+  'CI',
+];
+
+// The knobs this tool (and its runner) controls. They are kept across the
+// sanitization so the caller can still select the temp root, the evidence
+// root and the gate mode.
+const TOOL_ENV_KEYS = [
+  'PK_TEST_TEMP_ROOT',
+  'PK_TEST_EVIDENCE_ROOT',
+  'PK_LOGGING_GATE_STRICT_TRACKED',
+  'PK_TEST_TIMEOUT_MS',
+];
+
+// The module endpoints / switches the product understands. Reset semantics
+// follow qa-autopilot/lib/isolation.cjs: URLs need a legal port (1..65535,
+// the product rejects port 0 as INVALID_MODULE_URL), flags are '0' and
+// commands are empty strings.
+const MODULE_URL_KEYS = [
+  'KB_KNOWLEDGE_ENGINE_URL',
+  'KB_EVENTBRIDGE_URL',
+  'KB_EVENT_BRIDGE_URL',
+  'KB_TERMINAL_URL',
+  'KB_VECTORHUB_URL',
+];
+const MODULE_FLAG_KEYS = ['KB_MODULES_REGISTER', 'KB_MODULES_AUTOSTART'];
+const MODULE_COMMAND_KEYS = [
+  'KB_KNOWLEDGE_ENGINE_COMMAND',
+  'KB_EVENTBRIDGE_COMMAND',
+  'KB_TERMINAL_COMMAND',
+  'KB_VECTORHUB_COMMAND',
+  'AI_CODING_EVENT_BRIDGE_MODULE',
+  'KB_WORKBENCH_RUNTIME_TOKEN',
+];
+const DEAD_MODULE_URL = 'http://127.0.0.1:1';
+
+// Hard deny: even if a future allowlist entry would keep a key, nothing
+// credential-, proxy-, token- or injection-shaped may survive. The lane
+// variables are assigned after this check, so they are never affected.
+const DENY_KEY_PATTERNS = [
+  /(^|_)(API_?KEY|KEYS|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIALS?)$/i,
+  /^AWS_/i,
+  /^AZURE_/i,
+  /^GOOGLE_API/i,
+  /^GOOGLE_APPLICATION_CREDENTIALS$/i,
+  /^(HTTP|HTTPS|ALL|NO)_PROXY$/i,
+  /^PROXY$/i,
+  /^NODE_OPTIONS$/i,
+  /^NODE_EXTRA_CA_CERTS$/i,
+  /^NODE_PATH$/i,
+  /^ANTHROPIC_/i,
+  /^CLAUDE_/i,
+  /^CODEX_/i,
+  /^MINIMAX_/i,
+  /^OPENAI_/i,
+  /^GEMINI_/i,
+  /^GIT_/i,
+  /^NPM_/i,
+  /^SSH_AUTH_SOCK$/i,
+  /^DOCKER_CONFIG$/i,
+  /^KUBECONFIG$/i,
+  /^AI_CODING_EVENT_BRIDGE_/i,
+  /^KB_(KNOWLEDGE_ENGINE|EVENTBRIDGE|EVENT_BRIDGE|TERMINAL|VECTORHUB)_/i,
+];
+
+// The environment keys this helper owns. Every one of them is redirected to
+// a directory owned by the current run.
+const ISOLATED_ENV_KEYS = [
+  'HOME',
+  'USERPROFILE',
+  'HOMEDRIVE',
+  'HOMEPATH',
+  'APPDATA',
+  'LOCALAPPDATA',
+  'TEMP',
+  'TMP',
+  'TMPDIR',
+  'PSModuleAnalysisCachePath',
+  'CODEX_HOME',
+  'CLAUDE_CONFIG_DIR',
+  'KB_DATA_DIR',
+  'KB_KNOWLEDGE_DATA_DIR',
+  'AI_CODING_EVENT_BRIDGE_HOME',
+  'AGENT_TERMINAL_DATA_DIR',
+  'CLAUDE_AI_WORKBENCH_DATA_DIR',
+];
+
+// Windows environment variables are case-insensitive; POSIX ones are not.
+const normalizeKey = key => (process.platform === 'win32' ? String(key).toUpperCase() : String(key));
+
+function isInsideRepo(candidate, repoRoot = REPO_ROOT) {
+  const relative = path.relative(repoRoot, candidate);
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+// Resolves the absolute temp root for a test run. PK_TEST_TEMP_ROOT wins when
+// it is set; CI points it at the runner temp, which lives outside the
+// checkout. os.tmpdir() is the portable fallback.
+function resolveTempRoot(env = process.env) {
+  const configured = env.PK_TEST_TEMP_ROOT;
+  if (configured && !path.isAbsolute(configured)) {
+    throw new Error(`PK_TEST_TEMP_ROOT must be an absolute path (got: ${configured})`);
+  }
+  // os.tmpdir() is used verbatim (no realpath): on Windows the runner temp
+  // can be an 8.3 short path, and expanding it would change the path the
+  // caller configured.
+  const root = configured ? path.resolve(configured) : path.resolve(os.tmpdir());
+  if (!path.isAbsolute(root)) throw new Error(`test temp root must be absolute (got: ${root})`);
+  if (isInsideRepo(root)) {
+    throw new Error(`test temp root must live outside the source repository (got: ${root}; repo: ${REPO_ROOT})`);
+  }
+  fs.mkdirSync(root, { recursive: true });
+  return root;
+}
+
+// The evidence directory for one case. PK_TEST_EVIDENCE_ROOT overrides the
+// root and keeps the per-case subdirectory name of the default location.
+function resolveEvidenceDir(defaultDir, env = process.env) {
+  const configured = env.PK_TEST_EVIDENCE_ROOT;
+  if (!configured) return defaultDir;
+  if (!path.isAbsolute(configured)) {
+    throw new Error(`PK_TEST_EVIDENCE_ROOT must be an absolute path (got: ${configured})`);
+  }
+  fs.mkdirSync(configured, { recursive: true });
+  return path.join(configured, path.basename(defaultDir));
+}
+
+// The real browser executable, captured BEFORE any path moves. A per-user
+// Chrome lives under LOCALAPPDATA; once LOCALAPPDATA points into the lane
+// tree the developer's install is no longer discoverable, so the path has to
+// be captured first and re-exported as KB_CHROME_PATH (find-chrome consults
+// that key first).
+function captureChrome() {
+  try {
+    // Required lazily: the helper must stay loadable before the product.
+    const { findChromeDetailed } = require('./find-chrome');
+    const found = findChromeDetailed();
+    return { path: found.path, source: found.source };
+  } catch {
+    return null;
+  }
+}
+
+// Removes the ambient environment from the driver itself, so every child
+// process inherits the same clean base. Returns what was removed, for the
+// gate's evidence.
+function sanitizeEnv(env = process.env, options = {}) {
+  const allowed = new Set(
+    (options.allowedKeys || [...SYSTEM_ENV_ALLOWLIST, ...TOOL_ENV_KEYS]).map(normalizeKey),
+  );
+  const removed = [];
+  for (const key of Object.keys(env)) {
+    if (!allowed.has(normalizeKey(key))) removed.push(key);
+  }
+  for (const key of removed) delete env[key];
+
+  const denied = [];
+  for (const key of Object.keys(env)) {
+    if (DENY_KEY_PATTERNS.some(pattern => pattern.test(key))) denied.push(key);
+  }
+  for (const key of denied) delete env[key];
+
+  return { removed, denied };
+}
+
+// Empty default user-data directories for the platform's Chrome profile
+// location. Chrome >= 136 checks the default directory even when
+// --user-data-dir points elsewhere; with HOME/APPDATA/LOCALAPPDATA redirected
+// that directory must exist inside the isolated tree.
+//
+// On Windows the probe does not only follow LOCALAPPDATA: Chrome also derives
+// <USERPROFILE>\AppData\Local\Google\Chrome\User Data on its own. USERPROFILE
+// points at the lane home here, so that derived location is scaffolded empty
+// under the owned home as well - never the developer's real default profile.
+function chromeDefaultProfileDirs(dirs) {
+  const created = [];
+  const add = dir => {
+    fs.mkdirSync(dir, { recursive: true });
+    created.push(dir);
+  };
+  if (process.platform === 'win32') {
+    add(path.join(dirs.localAppData, 'Google', 'Chrome', 'User Data'));
+    add(path.join(dirs.appData, 'Google', 'Chrome', 'User Data'));
+    add(path.join(dirs.home, 'AppData', 'Local', 'Google', 'Chrome', 'User Data'));
+  } else if (process.platform === 'darwin') {
+    add(path.join(dirs.home, 'Library', 'Application Support', 'Google', 'Chrome'));
+  } else {
+    add(path.join(dirs.home, '.config', 'google-chrome'));
+    add(path.join(dirs.home, '.config', 'chromium'));
+  }
+  return created;
+}
+
+// Installs the isolated environment for one entry and returns the handles the
+// entry needs. Call this before requiring any product or helper module.
+//
+// Phase order matters:
+//   1. capture the real browser executable (before LOCALAPPDATA moves)
+//   2. resolve the temp root (os.tmpdir() reads TEMP/TMP)
+//   3. sanitize the ambient environment (driver level)
+//   4. create the lane tree
+//   5. assign the lane variables (never removed afterwards)
+//   6. apply the entry's explicit lane endpoints / stand-ins
+function installLoggingTestEnv({ caseId, prefix, env = process.env, extraEnv = {} } = {}) {
+  const label = prefix || caseId || 'logging';
+
+  // Phase 1: the browser executable is captured from the untouched
+  // environment. Losing it would make findChrome() fall back to the
+  // developer's real browser profile once LOCALAPPDATA is redirected.
+  const chrome = captureChrome();
+
+  // Phase 2: the temp root is resolved before the cleanup, because
+  // os.tmpdir() reads TEMP/TMP and those are part of what gets cleaned.
+  const tempRoot = resolveTempRoot(env);
+
+  // Phase 3: the ambient environment is removed from the driver itself.
+  const sanitized = sanitizeEnv(env);
+
+  // Phase 4: the lane tree.
+  const laneTmp = fs.mkdtempSync(path.join(tempRoot, `${label}-`));
+  const dirs = {
+    home: path.join(laneTmp, 'home'),
+    appData: path.join(laneTmp, 'appdata-roaming'),
+    localAppData: path.join(laneTmp, 'appdata-local'),
+    temp: path.join(laneTmp, 'temp'),
+    claudeConfig: path.join(laneTmp, 'claude-config'),
+    codexHome: path.join(laneTmp, 'codex-home'),
+    bridgeHome: path.join(laneTmp, 'bridge-home'),
+    dataHome: path.join(laneTmp, 'kb-data'),
+    knowledgeHome: path.join(laneTmp, 'kb-knowledge-data'),
+    agentTerminalData: path.join(laneTmp, 'agent-terminal-data'),
+    workbenchData: path.join(laneTmp, 'workbench-data'),
+    // The PARENT directory of the PowerShell module analysis cache. The
+    // environment variable must carry a FILE path whose parent exists, so
+    // only the parent is created here (PowerShell writes the cache file).
+    psModuleCache: path.join(laneTmp, 'ps-module-cache'),
+  };
+  for (const dir of Object.values(dirs)) fs.mkdirSync(dir, { recursive: true });
+
+  // Phase 5: the lane variables. They are assigned after the sanitization, so
+  // nothing here can be removed by the ambient cleanup.
+  if (chrome) env.KB_CHROME_PATH = chrome.path;
+  env.HOME = dirs.home;
+  env.USERPROFILE = dirs.home;
+  const homeRoot = path.parse(dirs.home).root;
+  env.HOMEDRIVE = homeRoot;
+  env.HOMEPATH = path.relative(homeRoot, dirs.home) || '\\';
+  env.APPDATA = dirs.appData;
+  env.LOCALAPPDATA = dirs.localAppData;
+  env.TEMP = dirs.temp;
+  env.TMP = dirs.temp;
+  env.TMPDIR = dirs.temp;
+  // PowerShell reads PSModuleAnalysisCachePath as the FILE that holds the
+  // module analysis cache; pointing it at a directory is wrong. The parent
+  // directory exists (created above), the cache file is PowerShell's to write.
+  env.PSModuleAnalysisCachePath = path.join(dirs.psModuleCache, 'ModuleAnalysisCache');
+  env.CODEX_HOME = dirs.codexHome;
+  env.CLAUDE_CONFIG_DIR = dirs.claudeConfig;
+  env.KB_DATA_DIR = dirs.dataHome;
+  env.KB_KNOWLEDGE_DATA_DIR = dirs.knowledgeHome;
+  env.AI_CODING_EVENT_BRIDGE_HOME = dirs.bridgeHome;
+  env.AGENT_TERMINAL_DATA_DIR = dirs.agentTerminalData;
+  env.CLAUDE_AI_WORKBENCH_DATA_DIR = dirs.workbenchData;
+  // Explicit, dead module endpoints: the product must never be able to reach
+  // a developer's live module through an inherited URL.
+  for (const key of MODULE_URL_KEYS) env[key] = DEAD_MODULE_URL;
+  for (const key of MODULE_FLAG_KEYS) env[key] = '0';
+  for (const key of MODULE_COMMAND_KEYS) env[key] = '';
+  if (process.platform !== 'win32') {
+    // Keep Chrome's XDG lookups inside the isolated home as well.
+    env.XDG_CONFIG_HOME = path.join(dirs.home, '.config');
+    env.XDG_CACHE_HOME = path.join(dirs.home, '.cache');
+    fs.mkdirSync(env.XDG_CONFIG_HOME, { recursive: true });
+    fs.mkdirSync(env.XDG_CACHE_HOME, { recursive: true });
+  }
+
+  const chromeProfileDirs = chromeDefaultProfileDirs(dirs);
+
+  // Phase 6: the entry's explicit lane endpoints / stand-ins. They are
+  // applied last and are never sanitized away.
+  const appliedOverrides = [];
+  for (const [key, value] of Object.entries(extraEnv || {})) {
+    env[key] = String(value);
+    appliedOverrides.push(key);
+  }
+
+  return {
+    caseId: caseId || label,
+    prefix: label,
+    tempRoot,
+    laneTmp,
+    dirs,
+    chrome,
+    chromePath: chrome ? chrome.path : null,
+    chromeProfileDirs,
+    isolatedEnvKeys: ISOLATED_ENV_KEYS.slice(),
+    sanitized,
+    appliedOverrides,
+    cleanup() {
+      try { fs.rmSync(laneTmp, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 }); } catch {}
+    },
+  };
+}
+
+module.exports = {
+  REPO_ROOT,
+  ISOLATED_ENV_KEYS,
+  SYSTEM_ENV_ALLOWLIST,
+  TOOL_ENV_KEYS,
+  DENY_KEY_PATTERNS,
+  MODULE_URL_KEYS,
+  MODULE_FLAG_KEYS,
+  MODULE_COMMAND_KEYS,
+  DEAD_MODULE_URL,
+  isInsideRepo,
+  resolveTempRoot,
+  resolveEvidenceDir,
+  captureChrome,
+  sanitizeEnv,
+  installLoggingTestEnv,
+};

package/_site/_test/helpers/parallel-memory-analyzer.js

@@ -0,0 +1,81 @@
+'use strict';
+// Lane-owned stand-in analyzer for the P-MEMORY-01 memory lane.
+//
+// HONEST SCOPE LABEL: this analyzer replaces the model-driven analysis step
+// of the knowledge engine. It writes a real staged Markdown file and a real
+// knowledge-staging-manifest through the engine's REAL promotion path, and it
+// can declare memory candidates, but it proves nothing about model quality,
+// prompt adherence or the headless Agent SDK worker. Every case that relies on
+// it is evidence about the engine's memory admission, scope and injection
+// machinery, never about the model.
+//
+// The manifest it writes is the engine's own schema. The engine's own
+// KnowledgePromotionService validates it, promotes the staged file into the
+// project knowledge directory and hands the run's staging to the real
+// MemoryService.capture(), which applies the real provenance gate.
+//
+// The candidates it declares come from the test's plan. The test owns them
+// because the engine's own gate requires them to quote a real human
+// conversation event, and only the test knows that event's id and hash.
+
+const path = require('node:path');
+const crypto = require('node:crypto');
+const AtomicFile = require('../../../_modules/knowledge-engine/src/runtime/atomic-file.js');
+
+/**
+ * A long enough sentence that the engine's own capture gate accepts it as a
+ * quote (the gate requires at least eight characters) and that the promoted
+ * Markdown always contains, so the promoted file can be checked against the
+ * candidate's quote on disk.
+ */
+const EVIDENCE_QUOTE = '候选记忆依据：以下文字来自冻结的提交与人工对话，可用于验证记忆候选的来源可追溯性。';
+
+function hashBuffer(value) {
+  return `sha256:${crypto.createHash('sha256').update(value).digest('hex')}`;
+}
+
+/**
+ * @param {object} options
+ * @param {object} options.plan  Mutable plan the test owns. `plan.document` is
+ *   the staged Markdown, `plan.memoryCandidates` are the candidates the
+ *   stand-in proposes to the real capture path.
+ */
+function createMemoryStandinAnalyzer({ plan = {} } = {}) {
+  return {
+    sourceReadMode: 'isolated-frozen-evidence',
+    async runClaim(input) {
+      const relative = `changes/${input.claim.commitSha.slice(0, 12)}.md`;
+      const base = plan.document
+        || `# 维护产物 ${input.projectId}\n\nCommit ${input.claim.commitSha} 的冻结提交证据。\n`;
+      const document = base.includes(EVIDENCE_QUOTE) ? base : `${base}\n${EVIDENCE_QUOTE}\n`;
+      AtomicFile.writeFileAtomic(path.join(input.stagingPath, 'files', relative), document);
+      const evidenceReferences = [
+        `commit:${input.claim.commitSha}`,
+        input.claim.patchHash && `patch:${input.claim.patchHash}`,
+        input.claim.conversationSnapshotHash && `conversation:${input.claim.conversationSnapshotHash}`,
+        input.claim.retrievalManifestHash && `retrieval:${input.claim.retrievalManifestHash}`,
+      ].filter(Boolean);
+      const memoryCandidates = (plan.memoryCandidates || []).map(candidate => ({
+        ...candidate,
+        entryId: candidate.entryId || relative,
+      }));
+      AtomicFile.writeJsonAtomic(input.manifestPath, {
+        schema: 'knowledge-staging-manifest/v1',
+        projectId: input.projectId,
+        runId: input.claim.runId,
+        commitSha: input.claim.commitSha,
+        operations: [{
+          path: relative,
+          operation: 'create',
+          sha256: hashBuffer(document),
+          reason: 'Frozen Git evidence from the fixture commit (stand-in analyzer, no real model output)',
+          evidenceReferences,
+        }],
+        memoryCandidates,
+      });
+      return { ok: true };
+    },
+  };
+}
+
+module.exports = { createMemoryStandinAnalyzer, EVIDENCE_QUOTE };

package/_site/_test/helpers/parallel-memory-event-bridge.js

@@ -0,0 +1,128 @@
+'use strict';
+// _site/_test/helpers/parallel-memory-event-bridge.js
+//
+// Lane-owned stand-in for the event-bridge console.
+//
+// WHY THIS EXISTS (and why the shared module fixture cannot be used here):
+// the product's module bridge sends the event-bridge project id to the
+// knowledge engine as a `conversationBaselineCursors` key. The engine accepts
+// only 'global' or `sha256:<64 hex>` as such a key. The real event-bridge
+// console derives its project id from the Git workspace identity, which is
+// exactly that `sha256:` form. The shared test fixture instead answers with
+// `bridge-1`, which the engine rejects with 400 "会话跟踪基线无效。" and the
+// project is never registered with the engine — so no memory run can happen.
+//
+// The shared helper is read-only for this lane, so this stand-in reproduces
+// the real console's id derivation instead of inventing one: it calls the
+// installed bridge package's own `resolveRepoContext`, the same function the
+// product's bridge adapter calls.
+//
+// HONEST SCOPE LABEL: this is a stand-in for the event-bridge console. It
+// serves the project registry and the journal high-watermark endpoints that
+// the product's module bridge calls. It stores no conversation and writes no
+// journal; the memory lane drives the engine's own conversation store
+// directly, and it says so in its own report.
+
+const http = require('node:http');
+const path = require('node:path');
+const { resolveRepoContext } = require('@sanqianx/ai-coding-event-bridge-console/src/bridge/core/repo-context');
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on('data', chunk => chunks.push(chunk));
+    req.on('end', () => resolve(Buffer.concat(chunks)));
+    req.on('error', reject);
+  });
+}
+
+function sendJson(res, status, payload) {
+  const body = JSON.stringify(payload);
+  res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8', 'Content-Length': Buffer.byteLength(body) });
+  res.end(body);
+}
+
+async function createEventBridgeStandin({ tag = 'event-bridge' } = {}) {
+  const state = { projects: [], requests: [] };
+
+  const server = http.createServer(async (req, res) => {
+    const url = new URL(req.url, 'http://127.0.0.1');
+    const raw = await readBody(req);
+    let body = null;
+    if (raw.length) { try { body = JSON.parse(raw.toString('utf8')); } catch { body = null; } }
+    state.requests.push({ method: req.method, path: url.pathname + url.search, body, at: Date.now() });
+
+    if (req.method === 'GET' && url.pathname === '/api/projects') {
+      sendJson(res, 200, { projects: state.projects });
+      return;
+    }
+    if (req.method === 'POST' && url.pathname === '/api/projects') {
+      const projectPath = String(body?.path || '');
+      if (!projectPath) {
+        sendJson(res, 400, { error: { code: 'PROJECT_PATH_REQUIRED', message: 'project path required' } });
+        return;
+      }
+      if (state.projects.some(project => String(project.path).toLowerCase() === projectPath.toLowerCase())) {
+        sendJson(res, 409, { error: { code: 'PROJECT_DUPLICATE', message: 'project path already imported' } });
+        return;
+      }
+      let identity = null;
+      let resolvedPath = projectPath;
+      try {
+        const context = await resolveRepoContext(projectPath);
+        identity = context.repoIdentity;
+        resolvedPath = context.projectPath || projectPath;
+      } catch (error) {
+        sendJson(res, 422, { error: { code: 'PROJECT_NOT_GIT', message: `not a Git work tree: ${projectPath}` } });
+        return;
+      }
+      const project = {
+        id: identity.workspaceId,
+        name: path.basename(resolvedPath),
+        path: projectPath,
+        store: String(body?.store || ''),
+        remote: identity.remote || null,
+        auto: false,
+        createdAt: new Date().toISOString(),
+      };
+      state.projects.push(project);
+      sendJson(res, 201, { project });
+      return;
+    }
+    if (req.method === 'DELETE' && url.pathname === '/api/projects') {
+      const id = url.searchParams.get('id');
+      state.projects = state.projects.filter(project => project.id !== id);
+      sendJson(res, 200, { ok: true });
+      return;
+    }
+    if (req.method === 'GET' && url.pathname === '/api/journal/high-watermark') {
+      const journalId = url.searchParams.get('journalId') || 'global';
+      // The lane writes no journal: the high watermark is always 0.
+      sendJson(res, 200, { journalId, sequence: 0 });
+      return;
+    }
+    sendJson(res, 404, { ok: false, error: { code: 'NOT_FOUND', message: '未实现的模块接口' } });
+  });
+
+  return {
+    kind: 'eventBridge',
+    tag,
+    state,
+    requests: state.requests,
+    url: null,
+    async start() {
+      await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+      this.url = `http://127.0.0.1:${server.address().port}`;
+      return this.url;
+    },
+    countRequests(method, pathPrefix) {
+      return state.requests.filter(entry => entry.method === method && (!pathPrefix || entry.path.startsWith(pathPrefix))).length;
+    },
+    async close() {
+      server.closeAllConnections();
+      await new Promise(resolve => server.close(resolve));
+    },
+  };
+}
+
+module.exports = { createEventBridgeStandin };