@sanqianx/project-knowledge 5.0.24 → 5.0.25

package/_site/_test/parallel-workbench-offline-test.js

@@ -0,0 +1,169 @@
+'use strict';
+// WB-002/WB-001 offline regression — the portable, zero-network slice.
+//
+// Collected by run-all-tests.js (suffix -test.js). Everything here must hold
+// on a bare CI runner:
+//   * the hosted module is the REPOSITORY PIN (node_modules/claude-ai-workbench)
+//     — never the machine-local installed product and never a D:-only path;
+//   * no account, no real profile, no credential: the standalone host runs on
+//     its own empty isolated store and the integration host talks only to this
+//     test's controlled localhost fixture;
+//   * no paid model turn — the real subscription conversations live in
+//     parallel-workbench-standalone-turn.js and parallel-workbench-model-probe.js,
+//     which are explicitly invoked and NEVER collected by the runner;
+//   * budget: the whole file must finish well under 90s.
+//
+// When the claude CLI is absent (CI), the session-creation sub-checks degrade
+// to an explicit SKIPPED_NO_CLI record instead of a false failure; hosting,
+// health, agents, isolated profile store and the integration contract are
+// asserted unconditionally.
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const fixture = require('./helpers/parallel-workbench-fixture');
+const sourceMap = require('./helpers/parallel-workbench-source-map');
+
+const BUDGET_MS = 90000;
+const startedAt = Date.now();
+const results = [];
+function record(caseId, status, detail) {
+  results.push({ caseId, status, detail });
+  console.log(`CASE ${caseId} ${status} ${JSON.stringify(detail)}`);
+}
+
+async function getJson(url, options) {
+  const response = await fetch(url, { ...options, signal: AbortSignal.timeout(20000) });
+  const body = await response.json().catch(() => null);
+  return { status: response.status, ok: response.ok, body };
+}
+
+async function startHost(layout, moduleRoot, port, mode, extraEnv = {}) {
+  return fixture.spawnNode([path.join(__dirname, 'helpers', 'parallel-workbench-host.js')], fixture.hostEnv(layout, {
+    PK_WB_MODULE_ROOT: moduleRoot,
+    PK_WB_HOST_PORT: String(port),
+    PK_WB_HOST_DATA_DIR: layout.dataDir,
+    PK_WB_HOST_WORKSPACE: layout.workspace,
+    PK_WB_HOST_MODE: mode,
+    ...extraEnv,
+  }));
+}
+
+(async () => {
+  // The repository pin only — the machine-local installed product is
+  // deliberately NOT consulted, so the test stays portable.
+  const moduleRoot = sourceMap.resolveRepoTargetPackage();
+  assert.ok(moduleRoot, 'the repository pin node_modules/claude-ai-workbench was not found — run npm install');
+  const pinVersion = JSON.parse(fs.readFileSync(path.join(moduleRoot, 'packages', 'server', 'package.json'), 'utf8')).version;
+  const manifest = sourceMap.loadManifest();
+  record('WB-OFF.a-pin-identity', manifest.terminal.version === pinVersion ? 'PASS' : 'FAIL', {
+    moduleRoot,
+    pinVersion,
+    manifestVersion: manifest.terminal.version,
+  });
+  assert.equal(manifest.terminal.version, pinVersion, 'the repository pin and the runtime manifest disagree');
+
+  // ---------- standalone host: no engine, no profiles, no account ----------
+  const layoutA = fixture.createIsolationLayout('parallel-wb-off');
+  const portA = await fixture.freePort();
+  const baseA = `http://127.0.0.1:${portA}`;
+  const standalone = await startHost(layoutA, moduleRoot, portA, 'standalone');
+  let cliAvailable = null;
+  try {
+    await fixture.waitForHttp(`${baseA}/api/claude-workbench/v1/health`, 30000);
+    const health = await getJson(`${baseA}/api/claude-workbench/v1/health`);
+    record('WB-OFF.b-standalone-health', health.ok && health.body && health.body.status === 'ok' && health.body.version === pinVersion ? 'PASS' : 'FAIL', {
+      status: health.body && health.body.status,
+      version: health.body && health.body.version,
+      expectVersion: pinVersion,
+    });
+    assert.equal(health.body.status, 'ok');
+    assert.equal(health.body.version, pinVersion);
+
+    const runtime = await getJson(`${baseA}/api/claude-workbench/v1/runtime`);
+    cliAvailable = Boolean(runtime.body && runtime.body.available);
+    record('WB-OFF.c-standalone-runtime', runtime.ok && runtime.body && runtime.body.runtime === 'claude-code' ? 'PASS' : 'FAIL', {
+      runtime: runtime.body && runtime.body.runtime,
+      transport: runtime.body && runtime.body.transport,
+      cliAvailable,
+      note: 'cliAvailable may be false on a bare CI runner; only the runtime name is asserted',
+    });
+    assert.equal(runtime.body.runtime, 'claude-code');
+
+    const agents = await getJson(`${baseA}/api/claude-workbench/v1/agents`);
+    const agentIds = agents.body && Array.isArray(agents.body.agents) ? agents.body.agents.map(agent => agent.id) : [];
+    record('WB-OFF.d-standalone-agents', agents.ok && agentIds.includes('claude-code') ? 'PASS' : 'FAIL', { agentIds });
+    assert.ok(agentIds.includes('claude-code'));
+
+    const profiles = await getJson(`${baseA}/api/claude-workbench/v1/profiles`);
+    const profileCount = Array.isArray(profiles.body && profiles.body.profiles) ? profiles.body.profiles.length : -1;
+    record('WB-OFF.e-standalone-profiles-empty', profiles.ok && profileCount === 0 ? 'PASS' : 'FAIL', { profileCount });
+    assert.equal(profileCount, 0, 'the isolated profile store must start empty');
+
+    if (cliAvailable) {
+      const session = await getJson(`${baseA}/api/claude-workbench/v1/sessions`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ context: { contextId: 'wb-off-standalone', workspaceRef: 'wb-fixture' } }),
+      });
+      const created = session.body && session.body.session;
+      record('WB-OFF.f-standalone-session', session.status === 201 && created && created.sessionId ? 'PASS' : 'FAIL', {
+        httpStatus: session.status,
+        sessionId: created && created.sessionId,
+      });
+      assert.equal(session.status, 201);
+      const knowledge = await getJson(`${baseA}/api/claude-workbench/v1/sessions/${encodeURIComponent(created.sessionId)}/knowledge`);
+      record('WB-OFF.g-standalone-knowledge-none', knowledge.ok && knowledge.body && ['disabled', 'not-retrieved'].includes(knowledge.body.status) ? 'PASS' : 'FAIL', {
+        knowledgeStatus: knowledge.body && knowledge.body.status,
+      });
+      assert.ok(['disabled', 'not-retrieved'].includes(knowledge.body.status));
+    } else {
+      record('WB-OFF.f-standalone-session', 'SKIPPED_NO_CLI', { cliAvailable, reason: 'the claude CLI is not available in this environment; session creation is not asserted offline' });
+      record('WB-OFF.g-standalone-knowledge-none', 'SKIPPED_NO_CLI', { cliAvailable });
+    }
+  } finally {
+    standalone.child.kill();
+    await standalone.exited;
+  }
+
+  // ---------- integration host + controlled fixture (localhost only) -------
+  const layoutB = fixture.createIsolationLayout('parallel-wb-offint');
+  const integrationFixture = await fixture.startIntegrationFixture();
+  const portB = await fixture.freePort();
+  const baseB = `http://127.0.0.1:${portB}`;
+  const integration = await startHost(layoutB, moduleRoot, portB, 'integration', { PK_WB_ENGINE_URL: integrationFixture.url });
+  try {
+    await fixture.waitForHttp(`${baseB}/api/claude-workbench/v1/health`, 30000);
+    const { KnowledgeContext } = require(path.join(moduleRoot, 'packages', 'server', 'lib', 'knowledge-context.js'));
+    const context = new KnowledgeContext({ engineUrl: integrationFixture.url });
+    const retrieved = await context.retrieve(layoutB.workspace, 'offline integration contract probe', 'project', { sessionId: 'wb-off-contract' });
+    const requestSeen = integrationFixture.requests[integrationFixture.requests.length - 1] || null;
+    const promptCarried = String(retrieved.prompt || '').includes(integrationFixture.marker);
+    record('WB-OFF.h-integration-contract', retrieved.status === 'ready' && promptCarried && requestSeen ? 'PASS' : 'FAIL', {
+      fixtureKind: 'controlled-integration-fixture (localhost stand-in; never counted as real knowledge)',
+      retrievedStatus: retrieved.status,
+      promptCarriedMarker: promptCarried,
+      client: requestSeen && requestSeen.body && requestSeen.body.client,
+    });
+    assert.equal(retrieved.status, 'ready');
+    assert.ok(promptCarried);
+    assert.equal(requestSeen.body.client, 'workbench');
+  } finally {
+    integration.child.kill();
+    await integration.exited;
+    await integrationFixture.close();
+  }
+
+  fixture.removeTree(layoutA.root);
+  fixture.removeTree(layoutB.root);
+
+  const elapsed = Date.now() - startedAt;
+  record('WB-OFF.i-budget', elapsed < BUDGET_MS ? 'PASS' : 'FAIL', { elapsedMs: elapsed, budgetMs: BUDGET_MS });
+  assert.ok(elapsed < BUDGET_MS, `the offline slice exceeded its ${BUDGET_MS}ms budget: ${elapsed}ms`);
+
+  const failures = results.filter(entry => entry.status === 'FAIL');
+  console.log(`parallel-workbench-offline-test ${failures.length === 0 ? 'PASS' : 'FAIL'} (${results.filter(r => r.status === 'PASS').length} pass, ${failures.length} fail, ${results.filter(r => r.status.startsWith('SKIPPED')).length} skipped) in ${elapsed}ms`);
+  if (failures.length) process.exitCode = 1;
+})().catch(error => {
+  console.error(error);
+  process.exit(1);
+});

package/_site/_test/parallel-workbench-provenance-trace.js

@@ -0,0 +1,134 @@
+'use strict';
+// WB-001 provenance trace — evidence only, never a regression.
+//
+// The canonical source-match script compares trees that exist today. This
+// script answers the other half of the question: which commit of the
+// Workbench source checkout is the installed package actually built from,
+// and which later commit moved the source away from it.
+//
+// It reads Git objects of the source checkout (that is the point of the
+// trace), it never writes to that checkout, and it never changes a pin, the
+// manifest or the vendored tree. It fails loudly when the checkout or the
+// history is unavailable.
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { execFileSync } = require('node:child_process');
+const sourceMap = require('./helpers/parallel-workbench-source-map');
+
+// The Git blob id of a buffer: sha1("blob <length>\0<content>").
+function gitBlobId(buffer) {
+  const hash = crypto.createHash('sha1');
+  hash.update(`blob ${buffer.length}\0`);
+  hash.update(buffer);
+  return hash.digest('hex');
+}
+
+function git(sourceRoot, args) {
+  return execFileSync('git', args, { cwd: sourceRoot, windowsHide: true, encoding: 'utf8', maxBuffer: 1 << 26 });
+}
+
+// Blob ids of every manifest file at one commit.
+function treeBlobs(sourceRoot, commit) {
+  const out = git(sourceRoot, ['ls-tree', '-r', commit]);
+  const blobs = new Map();
+  for (const line of out.split(/\r?\n/)) {
+    const match = /^(\d{6})\s+blob\s+([0-9a-f]{40})\t(.+)$/.exec(line.trim());
+    if (match) blobs.set(match[3].replace(/\\/g, '/'), match[2]);
+  }
+  return blobs;
+}
+
+function main() {
+  const manifest = sourceMap.loadManifest();
+  const sourceRoot = sourceMap.resolveSourceCheckout();
+  if (!sourceRoot) throw new Error('no Workbench source checkout was found (set PK_WB_SOURCE_DIR)');
+  const packageRoot = sourceMap.resolveRepoTargetPackage();
+  if (!fs.existsSync(packageRoot)) throw new Error(`the pinned target package is missing: ${packageRoot}`);
+
+  const head = sourceMap.sourceCommitId(sourceRoot);
+  const commits = git(sourceRoot, ['rev-list', `--max-count=40`, 'HEAD']).split(/\r?\n/).map(line => line.trim()).filter(Boolean);
+
+  // The local blob id of each shipped file: the raw bytes and the
+  // CRLF-normalised bytes, so a Windows checkout still matches an LF blob.
+  const localBlobs = new Map();
+  for (const relative of Object.keys(manifest.files)) {
+    const content = fs.readFileSync(path.join(packageRoot, relative));
+    const normalized = Buffer.from(content.toString('utf8').replace(/\r\n/g, '\n'), 'utf8');
+    localBlobs.set(relative, new Set([gitBlobId(content), gitBlobId(normalized)]));
+  }
+
+  const matches = [];
+  const examined = [];
+  for (const commit of commits) {
+    const blobs = treeBlobs(sourceRoot, commit);
+    let matched = 0;
+    let absent = 0;
+    const differing = [];
+    for (const [relative, ids] of localBlobs) {
+      const blob = blobs.get(relative);
+      if (!blob) { absent += 1; continue; }
+      if (ids.has(blob)) matched += 1;
+      else differing.push(relative);
+    }
+    examined.push({ commit, subject: git(sourceRoot, ['log', '-1', '--format=%s', commit]).trim(), matched, absent, differing: differing.length });
+    if (matched === localBlobs.size && absent === 0) matches.push({ commit, subject: git(sourceRoot, ['log', '-1', '--format=%s', commit]).trim() });
+  }
+
+  const sourceComparison = sourceMap.compareTree(manifest.files, sourceRoot);
+  const differingFiles = sourceComparison.different;
+  const provenance = differingFiles.map(relative => ({
+    file: relative,
+    commitsTouching: sourceMap.commitsTouchingFile(sourceRoot, relative),
+  }));
+
+  // The newest examined commit whose shipped files still match the package.
+  const newestMatch = matches.length ? matches[0] : null;
+  const newestMatchIndex = newestMatch ? examined.findIndex(entry => entry.commit === newestMatch.commit) : -1;
+  const newerThanPackage = newestMatchIndex > 0 ? examined.slice(0, newestMatchIndex) : [];
+
+  const summary = {
+    lane: 'test-workbench',
+    file: 'parallel-workbench-provenance-trace.js',
+    role: 'evidence-only (reads Git objects of the source checkout; not a regression)',
+    manifest: { file: manifest.file, module: manifest.terminal.name, version: manifest.terminal.version, files: manifest.count },
+    packageRoot,
+    sourceRoot,
+    sourceHead: head,
+    sourceWorkingTreeClean: sourceMap.sourceWorkingTreeClean(sourceRoot),
+    packageEqualsCommit: matches.length ? matches : null,
+    newestMatchingCommit: newestMatch,
+    commitsNewerThanPackage: newerThanPackage,
+    commitsExamined: examined.length,
+    examined: examined.slice(0, 12),
+    sourceWorkingTreeVsPackage: {
+      identical: sourceComparison.identicalCount,
+      eolOnly: sourceComparison.eolOnlyCount,
+      different: sourceComparison.differentCount,
+      missing: sourceComparison.missingCount,
+      eolOnlyFiles: sourceComparison.eolOnly,
+      differentFiles: sourceComparison.different,
+    },
+    provenanceOfDifferences: provenance,
+    gitHistoryUsed: true,
+    networkUsed: false,
+    conclusion: newestMatch
+      ? `the installed package is byte-identical (CRLF-normalised) to the source checkout at ${newestMatch.commit} (${newestMatch.subject}); the checkout head ${head} is ${newerThanPackage.length} commit(s) newer and already differs in ${sourceComparison.differentCount} shipped file(s)`
+      : 'no examined commit matches the installed package byte for byte',
+  };
+
+  const target = process.env.PARALLEL_WORKBENCH_EVIDENCE;
+  if (target) {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, JSON.stringify(summary, null, 2), 'utf8');
+  }
+  console.log(JSON.stringify({ conclusion: summary.conclusion, packageEqualsCommit: summary.packageEqualsCommit, sourceHead: head }, null, 2));
+  return summary;
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(error);
+  process.exitCode = 1;
+}

package/_site/_test/parallel-workbench-source-match.js

@@ -0,0 +1,206 @@
+'use strict';
+// WB-001 — the Workbench source / package / manifest correspondence.
+//
+// What this script proves, with bytes:
+//   1. the currently installed target package (node_modules/claude-ai-workbench,
+//      the pin the repository ships) matches module-runtime-manifest.json on
+//      every single file;
+//   2. the copy the installed product 5.0.24 actually ships matches the same
+//      manifest on every single file;
+//   3. the Workbench source checkout is compared file by file against that
+//      manifest, and every difference is classified (identical / EOL-only /
+//      really different / missing).
+//
+// What it deliberately does NOT do:
+//   * it never judges two trees equal because their version strings match;
+//   * it never reads Git history, a remote or any Git object — the source
+//     side is compared as the working tree it is today. The historical trace
+//     lives in parallel-workbench-provenance-trace.js, which is evidence, not
+//     a regression;
+//   * it never touches pins, the manifest, the vendored tree or the installed
+//     modules.
+//
+// A mismatch is not a failure of this script and is never papered over: it is
+// reported as BLOCKED_SOURCE_MATCH, which is the defined outcome.
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const sourceMap = require('./helpers/parallel-workbench-source-map');
+
+const results = [];
+function record(caseId, status, detail) {
+  results.push({ caseId, status, detail });
+  console.log(`CASE ${caseId} ${status} ${JSON.stringify(detail)}`);
+}
+
+function summariseComparison(comparison) {
+  return {
+    root: comparison.root,
+    total: comparison.total,
+    identical: comparison.identicalCount,
+    eolOnly: comparison.eolOnlyCount,
+    different: comparison.differentCount,
+    missing: comparison.missingCount,
+  };
+}
+
+function main() {
+  const manifest = sourceMap.loadManifest();
+  const installedProductRoot = sourceMap.resolveInstalledProductRoot();
+  const installedProductVersion = installedProductRoot
+    ? sourceMap.packageIdentity(installedProductRoot)
+    : null;
+
+  const targets = [];
+
+  // --- the currently installed target package (the repository pin) -------
+  const repoTargetRoot = sourceMap.resolveRepoTargetPackage();
+  assert.ok(fs.existsSync(repoTargetRoot), `the pinned target package is missing: ${repoTargetRoot}`);
+  const repoTargetIdentity = sourceMap.packageIdentity(repoTargetRoot);
+  const repoTargetComparison = sourceMap.compareTree(manifest.files, repoTargetRoot);
+  targets.push({
+    label: 'currently-installed-package:repository-pin',
+    role: 'currently-installed-package',
+    identity: repoTargetIdentity,
+    comparison: summariseComparison(repoTargetComparison),
+  });
+  assert.equal(
+    repoTargetComparison.identicalCount,
+    manifest.count,
+    `the pinned package does not match the manifest: ${repoTargetComparison.differentCount} different, ${repoTargetComparison.missingCount} missing`,
+  );
+  assert.equal(repoTargetComparison.differentCount, 0);
+  assert.equal(repoTargetComparison.missingCount, 0);
+  assert.equal(repoTargetIdentity.name, manifest.terminal.name, 'the pinned package is not the module the manifest describes');
+  assert.equal(repoTargetIdentity.version, manifest.terminal.version, 'the pinned package version differs from the manifest');
+
+  // --- the copy the installed product 5.0.24 ships ----------------------
+  const installedModuleRoot = sourceMap.resolveInstalledProductPackage();
+  if (!installedModuleRoot) {
+    targets.push({
+      label: 'currently-installed-package:installed-product',
+      role: 'currently-installed-package',
+      status: 'BLOCKED_PRODUCT_NOT_INSTALLED',
+      detail: 'no installed product tree was found; the repository pin above is the only installed copy that could be proven',
+    });
+  } else {
+    const installedIdentity = sourceMap.packageIdentity(installedModuleRoot);
+    const installedComparison = sourceMap.compareTree(manifest.files, installedModuleRoot);
+    targets.push({
+      label: 'currently-installed-package:installed-product',
+      role: 'currently-installed-package',
+      product: installedProductVersion ? installedProductVersion.version : null,
+      identity: installedIdentity,
+      comparison: summariseComparison(installedComparison),
+    });
+    assert.equal(installedComparison.identicalCount, manifest.count, 'the installed product copy does not match the manifest');
+    assert.equal(installedComparison.differentCount, 0);
+    assert.equal(installedComparison.missingCount, 0);
+    assert.equal(installedIdentity.name, manifest.terminal.name);
+    assert.equal(installedIdentity.version, manifest.terminal.version);
+  }
+
+  // --- the source checkout (a candidate fixture, never "the package") ----
+  const sourceRoot = sourceMap.resolveSourceCheckout();
+  let sourceLeg = null;
+  if (!sourceRoot) {
+    sourceLeg = {
+      label: 'candidate-fixture:source-checkout',
+      role: 'candidate-fixture',
+      status: 'BLOCKED_SOURCE_UNAVAILABLE',
+      detail: 'no Workbench source checkout was found (set PK_WB_SOURCE_DIR to compare one)',
+    };
+  } else {
+    const sourceComparison = sourceMap.compareTree(manifest.files, sourceRoot);
+    const sourceIdentity = sourceMap.packageIdentity(sourceRoot);
+    const matchesPackage = sourceComparison.differentCount === 0 && sourceComparison.missingCount === 0;
+    sourceLeg = {
+      label: 'candidate-fixture:source-checkout',
+      role: 'candidate-fixture',
+      root: sourceRoot,
+      commit: sourceMap.sourceCommitId(sourceRoot),
+      workingTreeClean: sourceMap.sourceWorkingTreeClean(sourceRoot),
+      identity: sourceIdentity,
+      comparison: summariseComparison(sourceComparison),
+      eolOnlyFiles: sourceComparison.eolOnly,
+      differentFiles: sourceComparison.different,
+      missingFiles: sourceComparison.missing,
+      matchesInstalledPackage: matchesPackage,
+      verdict: matchesPackage ? 'SOURCE_MATCH' : 'BLOCKED_SOURCE_MATCH',
+    };
+    assert.equal(sourceComparison.missingCount, 0, 'the source checkout is missing files the manifest ships');
+    assert.equal(
+      sourceComparison.identicalCount + sourceComparison.eolOnlyCount + sourceComparison.differentCount,
+      manifest.count,
+      'the source comparison did not classify every manifest file',
+    );
+  }
+  targets.push(sourceLeg);
+
+  // --- per-expected conclusions ------------------------------------------
+  const installedLegs = targets.filter(target => target.role === 'currently-installed-package');
+  const installedProven = installedLegs.every(leg => leg.status === undefined && leg.comparison && leg.comparison.identical === leg.comparison.total);
+  record('WB-001.a-installed-package-matches-manifest', installedProven ? 'PASS' : 'PARTIAL', {
+    manifestFiles: manifest.count,
+    manifestVersion: manifest.terminal.version,
+    legs: installedLegs.map(leg => ({ label: leg.label, status: leg.status || 'PASS', comparison: leg.comparison || null })),
+  });
+
+  const everyFileOwned = Boolean(sourceLeg) && sourceLeg.status !== 'BLOCKED_SOURCE_UNAVAILABLE'
+    && sourceLeg.comparison.missing === 0
+    && sourceLeg.comparison.identical + sourceLeg.comparison.eolOnly + sourceLeg.comparison.different === manifest.count;
+  record('WB-001.b-file-ownership-traceable', everyFileOwned ? 'PASS' : 'BLOCKED', {
+    rule: '每一文件所有权可追溯',
+    manifestFiles: manifest.count,
+    traceableFiles: sourceLeg && sourceLeg.comparison ? sourceLeg.comparison.identical + sourceLeg.comparison.eolOnly + sourceLeg.comparison.different : 0,
+    identical: sourceLeg && sourceLeg.comparison ? sourceLeg.comparison.identical : null,
+    eolOnly: sourceLeg && sourceLeg.comparison ? sourceLeg.comparison.eolOnly : null,
+    reallyDifferent: sourceLeg && sourceLeg.comparison ? sourceLeg.comparison.different : null,
+    missing: sourceLeg && sourceLeg.comparison ? sourceLeg.comparison.missing : null,
+  });
+
+  const mismatchRecorded = !sourceLeg || sourceLeg.verdict === 'BLOCKED_SOURCE_MATCH' || sourceLeg.verdict === 'SOURCE_MATCH';
+  record('WB-001.c-mismatch-verdict', mismatchRecorded ? 'PASS' : 'FAIL', {
+    rule: '不匹配则BLOCKED_SOURCE_MATCH',
+    verdict: sourceLeg ? sourceLeg.verdict : 'BLOCKED_SOURCE_UNAVAILABLE',
+    reason: sourceLeg && sourceLeg.verdict === 'BLOCKED_SOURCE_MATCH'
+      ? 'the source checkout is not byte-identical to the installed package; the difference is recorded, not patched away'
+      : null,
+    noPinOrInstallChange: true,
+  });
+
+  const summary = {
+    lane: 'test-workbench',
+    file: 'parallel-workbench-source-match.js',
+    case: 'WB-001',
+    title: '源码版本匹配',
+    manifest: {
+      file: manifest.file,
+      schema: manifest.schema,
+      module: manifest.terminal.name,
+      installName: manifest.terminal.installName,
+      version: manifest.terminal.version,
+      files: manifest.count,
+    },
+    targets,
+    verdict: sourceLeg && sourceLeg.verdict ? sourceLeg.verdict : 'BLOCKED_SOURCE_UNAVAILABLE',
+    gitHistoryUsed: false,
+    networkUsed: false,
+    cases: results,
+  };
+
+  const target = process.env.PARALLEL_WORKBENCH_EVIDENCE;
+  if (target) {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, JSON.stringify(summary, null, 2), 'utf8');
+  }
+  console.log(`parallel-workbench-source-match PASS verdict=${summary.verdict}`);
+  return summary;
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(error);
+  process.exitCode = 1;
+}