@sanqianx/project-knowledge 5.0.24 → 5.0.26

package/_site/_test/parallel-workbench-integration-5025-ordering-probe.js

@@ -0,0 +1,326 @@
+'use strict';
+// P-WB-QA-INTEGRATION-5025 canonical copy of the accepted WB-004 entry
+// (_site/_test/parallel-workbench-runtime-wb004-ordering.js, frozen untracked).
+// P-WB-CANONICAL-R2 wiring: the entry goes through the canonical launcher boot
+// (paid gate + explicit real-profile authorization → read-only discovery with
+// the real environment → FULL driver isolation incl. APPDATA/LOCALAPPDATA/
+// CODEX_HOME → carried-through captures), and the real-profile digest helpers
+// come from the launcher's authorized layer instead of the pre-R5 tracked
+// fixture whose whitelist lacked those keys. Case logic, expecteds and the
+// two-level model evidence are unchanged. Real paid model probe (two turns,
+// real network to the provider) — run only explicitly via the integration-5025
+// runner with PK_WB_ALLOW_PAID_TURNS=1 and an explicit PK_WB_REAL_PROFILE_DIR.
+// WB-004 — 连续回复次序（真实浏览器 / 真实 0.13.6 隔离宿主 / 真实 MiniMax）.
+//
+// 本入口用真实 Chrome 打开模块自带的 agent-terminal UI（安装包内
+// apps/agent-terminal），在隔离宿主上跑本轮真实 Q1 与 Q2：
+//
+//   * Q1 结束后立即发 Q2（同一会话）；
+//   * 故障注入 = 把本轮真实 Q1 的一条真实事件在 Q2 进行中【延迟重放】回
+//     同一条 SSE 流。重放由页面内的记录器完成，记录器只记录与重放，不做
+//     过滤、不改顺序、不替产品判断；
+//   * 判定只看产品自身的 UI 与活动状态：Q1 正文不在 Q2 之后重复、Q2 不被
+//     错误置为 idle。
+//
+// 退出码：0 = 全部证明；3 = 诚实 BLOCKED；1 = 脚本错误。
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const launcher = require('./helpers/parallel-workbench-integration-5025-launcher');
+const fixture = require('./helpers/parallel-workbench-integration-5025-fixture');
+const harness = require('./helpers/parallel-workbench-integration-5025-runtime-harness');
+
+const PROFILE_ID = String(process.env.PK_WB_MODEL_PROFILE || 'minimax');
+const REQUESTED_MODEL = String(process.env.PK_WB_MODEL_ID || 'MiniMax-M3.1-Flash');
+const TURN_TIMEOUT_MS = Number(process.env.PK_WB_TURN_TIMEOUT_MS || 420000);
+
+const results = [];
+function record(caseId, status, detail) {
+  results.push({ caseId, status, detail });
+  console.log(`CASE ${caseId} ${status} ${JSON.stringify(detail)}`);
+}
+
+// The vendor-returned model of this run: the assistant message.model of the
+// real CLI transcript under the ISOLATED CLAUDE_CONFIG_DIR. Only model
+// strings and booleans leave here.
+function scanTranscript(roots, sessionIds, tokens) {
+  const matched = [];
+  const models = new Set();
+  let tokenEchoed = false;
+  const walk = root => {
+    let entries;
+    try { entries = fs.readdirSync(root, { withFileTypes: true }); } catch { return; }
+    for (const entry of entries) {
+      const full = path.join(root, entry.name);
+      if (entry.isDirectory()) { walk(full); continue; }
+      if (!entry.isFile() || !full.endsWith('.jsonl')) continue;
+      let text;
+      try { text = fs.readFileSync(full, 'utf8'); } catch { continue; }
+      if (!sessionIds.some(id => text.includes(id))) continue;
+      matched.push(path.basename(full));
+      for (const line of text.split(/\r?\n/)) {
+        let entry;
+        try { entry = JSON.parse(line); } catch { continue; }
+        if (entry.type !== 'assistant' || !entry.message) continue;
+        if (typeof entry.message.model === 'string' && entry.message.model) models.add(entry.message.model);
+        const content = Array.isArray(entry.message.content) ? entry.message.content : [];
+        for (const block of content) {
+          if (block && block.type === 'text' && typeof block.text === 'string' && tokens.some(token => block.text.includes(token))) tokenEchoed = true;
+        }
+      }
+    }
+  };
+  for (const root of roots) walk(root);
+  return { transcriptFilesMatched: matched, assistantModelValues: [...models], tokenEchoedInTranscript: tokenEchoed };
+}
+
+(async () => {
+  // The single safe entry discipline: gates, real-env discovery, full driver
+  // isolation, carried-through captures — before anything else happens.
+  const boot = launcher.boot({ prefix: 'parallel-wb004', paid: true, needsRealProfile: true });
+  const realProfilesBefore = launcher.digestDirectory(boot.discovery.realProfileDir);
+  const host = await harness.startHost({
+    prefix: 'parallel-wb004',
+    moduleRoot: boot.discovery.moduleRoot,
+    realProfileDir: boot.discovery.realProfileDir,
+  });
+  const identity = harness.moduleIdentity(host.moduleRoot);
+  let browser = null;
+  let ui = null;
+  let outcome = null;
+  let blocked = null;
+
+  try {
+    const opened = await harness.openBrowser(host.base, host.layout, { chrome: boot.discovery.chrome });
+    browser = opened.browser;
+    ui = opened;
+
+    const health = await harness.getJson(`${host.base}${harness.API_BASE}/health`);
+    const project = await harness.ensureProject(browser, path.join(host.layout.root, 'wb004-project'), { name: 'wb004-project' });
+    record('WB-004.a-real-browser-and-host', health.ok && health.body && health.body.status === 'ok' ? 'PASS' : 'BLOCKED', {
+      browser: 'real Chrome via CDP (headless), isolated user-data-dir below the isolated layout',
+      chrome: opened.chrome,
+      module: identity,
+      host: { mode: 'standalone', dataDir: host.layout.dataDir, workspace: host.layout.workspace, port: host.port },
+      project: { id: project.projectId, name: project.name, createdThroughTheProductForm: project.created === true },
+      health: health.body,
+    });
+    assertTrue(health.ok && health.body && health.body.status === 'ok', 'the isolated host is not healthy');
+
+    const profiles = await harness.getJson(`${host.base}${harness.API_BASE}/profiles`);
+    const listed = Array.isArray(profiles.body && profiles.body.profiles) ? profiles.body.profiles : [];
+    const profile = listed.find(item => item.id === PROFILE_ID) || null;
+    assertTrue(profile, `the ${PROFILE_ID} profile is not visible through the read-only facade`);
+    const credentialConfigured = profile.credentialConfigured === true;
+
+    await harness.selectModel(browser, profile.name, REQUESTED_MODEL);
+    const afterModel = await harness.readState(browser);
+    record('WB-004.b-model-selected-through-the-real-ui', credentialConfigured && afterModel.product.currentProfileId === PROFILE_ID && afterModel.product.currentModel === REQUESTED_MODEL ? 'PASS' : 'BLOCKED', {
+      profileId: PROFILE_ID,
+      profileName: profile.name,
+      requestedModel: REQUESTED_MODEL,
+      uiProfileId: afterModel.product.currentProfileId,
+      uiModel: afterModel.product.currentModel,
+      modelLabel: afterModel.modelLabel,
+      credentialConfigured,
+      credentialWrittenAnywhere: false,
+    });
+    assertTrue(credentialConfigured, 'the profile has no configured credential');
+
+    const token1 = `WBRT-ORDER-A-${crypto.randomBytes(5).toString('hex')}`;
+    const token2 = `WBRT-ORDER-B-${crypto.randomBytes(5).toString('hex')}`;
+    const question1 = `这是 WB-004 连续回复次序的真实抽测（第 1 问）。请只回复一行，原样包含以下随机标记，不要添加任何其他内容：${token1}`;
+    const question2 = `这是 WB-004 连续回复次序的真实抽测（第 2 问）。请先输出一行、原样包含以下随机标记：${token2}；然后再写三行简短说明，说明这是第 2 问。`;
+
+    // --- Q1 -------------------------------------------------------------
+    await harness.typeText(browser, question1);
+    await harness.clickSend(browser);
+    const q1Busy = await harness.waitForState(browser, state => state.busy === true, 'Q1 to start', 90000);
+    const q1Done = await harness.waitForState(browser, state => state.busy === false && state.product.liveRevision > 0, 'Q1 to end', TURN_TIMEOUT_MS);
+    const q1Text = q1Done.streamText;
+    const q1Answers = q1Done.assistantMessages.filter(text => text.includes(token1));
+    const q1Count = q1Answers.length;
+    record('WB-004.c-q1-answered-by-the-real-model', q1Count === 1 ? 'PASS' : 'BLOCKED', {
+      uniqueToken: token1,
+      assistantAnswersCarryingTheToken: q1Count,
+      answerPreview: q1Answers.length ? q1Answers[0].slice(0, 200) : q1Text.slice(-200),
+      uiSessionState: q1Done.product.sessionState,
+      paidTurns: 1,
+    });
+    assertTrue(q1Count === 1, `Q1 was not answered with the unique token (${q1Count} assistant answers carry it)`);
+
+    // --- Q2 immediately --------------------------------------------------
+    const q1ResultEvent = (await harness.recordedEvents(browser))
+      .filter(event => event.type === 'claude/result' && event.data.includes(token1))
+      .pop() || null;
+    const q2SentAt = Date.now();
+    await harness.typeText(browser, question2);
+    await harness.clickSend(browser);
+    const q2Busy = await harness.waitForState(browser, state => state.busy === true, 'Q2 to start', 90000);
+    const gapMs = q1ResultEvent ? q2SentAt - q1ResultEvent.at : null;
+    record('WB-004.d-q2-sent-immediately-after-q1', gapMs !== null && gapMs < 10000 ? 'PASS' : 'BLOCKED', {
+      q1ResultEventAt: q1ResultEvent ? q1ResultEvent.at : null,
+      q2SentAt,
+      gapMs,
+      sameSession: q1Busy.product.activeSessionId === q2Busy.product.activeSessionId,
+      sessionId: q2Busy.product.activeSessionId,
+    });
+    assertTrue(gapMs !== null && gapMs < 10000, 'Q2 was not sent immediately after Q1');
+
+    // The fault injection lands while Q2 is still running: the replay is
+    // issued as soon as the UI reports Q2 busy, and the product's answer to
+    // the stale event is read back immediately afterwards.
+    const beforeReplay = await harness.readState(browser);
+    assertTrue(beforeReplay.busy === true, 'Q2 was no longer running when the fault injection was due');
+    const events = await harness.recordedEvents(browser);
+    const q1ResultIndex = events.findIndex(event => event.type === 'claude/result' && event.data.includes(token1));
+    assertTrue(q1ResultIndex >= 0, 'the real Q1 result event was not recorded by the product stream');
+    const q1ResultData = events[q1ResultIndex].data;
+    const replay = await harness.replayRecordedEvent(browser, q1ResultIndex, `/sessions/${q2Busy.product.activeSessionId}/events`);
+    await harness.wait(400);
+    const afterReplay = await harness.readState(browser);
+    const replayedEvents = await harness.recordedEvents(browser);
+    const matches = event => event.type === 'claude/result' && event.data === q1ResultData;
+    const delivered = replayedEvents.filter(matches).length - events.filter(matches).length;
+
+    const q1AfterReplay = afterReplay.assistantMessages.filter(text => text.includes(token1)).length;
+    const q2DuringReplay = afterReplay.assistantMessages.filter(text => text.includes(token2)).length;
+    const assistantCountBefore = beforeReplay.assistantMessages.length;
+    const assistantCountAfter = afterReplay.assistantMessages.length;
+    const staleDropped = q1AfterReplay === 1 && assistantCountAfter === assistantCountBefore;
+    const stillBusy = afterReplay.busy === true && afterReplay.product.sessionState !== 'idle';
+    record('WB-004.e-stale-q1-message-replayed-into-the-live-q2-turn', staleDropped && stillBusy ? 'PASS' : 'BLOCKED', {
+      injectedEvent: { index: q1ResultIndex, type: events[q1ResultIndex].type, sequence: (() => { try { return JSON.parse(q1ResultData).sequence; } catch { return null; } })() },
+      replayResult: replay,
+      timesTheSameRealQ1EventReachedTheProduct: delivered,
+      productLiveRevisionBefore: beforeReplay.product.liveRevision,
+      productLiveRevisionAfter: afterReplay.product.liveRevision,
+      staleEventAcceptedByTheProduct: !staleDropped,
+      assistantMessagesBeforeReplay: assistantCountBefore,
+      assistantMessagesAfterReplay: assistantCountAfter,
+      q1BodyOccurrencesAfterReplay: q1AfterReplay,
+      q2BodyOccurrencesDuringReplay: q2DuringReplay,
+      uiBusyAfterReplay: afterReplay.busy,
+      uiSessionStateAfterReplay: afterReplay.product.sessionState,
+      uiStatusTextAfterReplay: afterReplay.statusText,
+      note: 'the replayed frame is byte-identical to the real Q1 result frame of this round and is delivered to the very same session SSE stream the product reads; whether it is rendered is decided by the product\'s own session-sequence guard (apps/agent-terminal/app.js)',
+    });
+    assertTrue(replay.replayed === true && replay.delivered >= 1, 'the replayed Q1 message never reached the product');
+    assertTrue(delivered >= 1, 'the replayed Q1 message did not reach the product a second time');
+    assertTrue(staleDropped, 'the product rendered the stale Q1 event (Q1 body repeated)');
+    assertTrue(stillBusy, 'Q2 was wrongly put into idle by the stale Q1 event');
+
+    // --- Q2 completes ----------------------------------------------------
+    const q2Done = await harness.waitForState(browser, state => state.busy === false && state.assistantMessages.filter(text => text.includes(token2)).length === 1, 'Q2 to end', TURN_TIMEOUT_MS);
+    const finalAnswers = q2Done.assistantMessages;
+    const q1Indexes = finalAnswers.map((text, index) => (text.includes(token1) ? index : -1)).filter(index => index >= 0);
+    const q2Indexes = finalAnswers.map((text, index) => (text.includes(token2) ? index : -1)).filter(index => index >= 0);
+    const q1Final = q1Indexes.length;
+    const q2Final = q2Indexes.length;
+    const order = q1Final === 1 && q2Final === 1 && q1Indexes[0] < q2Indexes[0];
+    record('WB-004.f-q2-completed-with-its-own-answer', order ? 'PASS' : 'BLOCKED', {
+      assistantMessageCount: finalAnswers.length,
+      q1Answers: q1Final,
+      q2Answers: q2Final,
+      q1BeforeQ2InTheTranscript: order,
+      uiSessionState: q2Done.product.sessionState,
+      paidTurns: 2,
+    });
+    assertTrue(order, 'the final transcript does not hold exactly one Q1 and one Q2 answer in order');
+
+    // --- the vendor-returned model of this run ---------------------------
+    const sessionId = q2Done.product.activeSessionId;
+    const initEvents = (await harness.recordedEvents(browser)).filter(event => event.type === 'claude/init');
+    const claudeSessionIds = initEvents.map(event => { try { return JSON.parse(event.data).claudeSessionId; } catch { return null; } }).filter(Boolean);
+    const transcript = scanTranscript(
+      [host.layout.claudeConfigDir, path.join(host.layout.home, '.claude')],
+      claudeSessionIds,
+      [token1, token2],
+    );
+    const vendorModelOk = transcript.assistantModelValues.length > 0
+      && transcript.assistantModelValues.every(model => model.replace(/\s+/g, '').toLowerCase() === REQUESTED_MODEL.replace(/\s+/g, '').toLowerCase())
+      && transcript.tokenEchoedInTranscript;
+    record('WB-004.g-vendor-returned-model-from-the-real-transcript', vendorModelOk ? 'PASS' : 'BLOCKED', {
+      requestedModel: REQUESTED_MODEL,
+      assistantModelValues: transcript.assistantModelValues,
+      tokenEchoedInTranscript: transcript.tokenEchoedInTranscript,
+      transcriptFilesMatched: transcript.transcriptFilesMatched,
+      claudeSessionIds,
+      workbenchSessionId: sessionId,
+    });
+
+    outcome = {
+      workbenchSessionId: sessionId,
+      q1Token: token1,
+      q2Token: token2,
+      gapMs,
+      q1FinalOccurrences: q1Final,
+      q2FinalOccurrences: q2Final,
+      vendorReturnedModels: transcript.assistantModelValues,
+      paidTurns: 2,
+    };
+  } catch (error) {
+    blocked = { message: String(error && error.message ? error.message : error) };
+    record('WB-004.runtime', 'BLOCKED', { error: blocked.message });
+  } finally {
+    if (browser) { try { await browser.close(); } catch { /* the browser is disposable */ } }
+    if (host.child) { await harness.stopHost(host); }
+  }
+
+  const digestComparison = launcher.compareDigests(realProfilesBefore, launcher.digestDirectory(boot.discovery.realProfileDir));
+  record('WB-004.h-real-profiles-byte-identical', digestComparison.byteIdentical ? 'PASS' : 'FAIL', {
+    profileDir: boot.discovery.realProfileDir,
+    comparison: 'byte-level SHA256, computed in memory; digests never printed, logged or persisted',
+    fileCount: digestComparison.count,
+    changedFiles: digestComparison.changedFiles,
+    addedFiles: digestComparison.addedFiles,
+    removedFiles: digestComparison.removedFiles,
+  });
+
+  const essential = [
+    'WB-004.a-real-browser-and-host',
+    'WB-004.b-model-selected-through-the-real-ui',
+    'WB-004.c-q1-answered-by-the-real-model',
+    'WB-004.d-q2-sent-immediately-after-q1',
+    'WB-004.e-stale-q1-message-replayed-into-the-live-q2-turn',
+    'WB-004.f-q2-completed-with-its-own-answer',
+    'WB-004.g-vendor-returned-model-from-the-real-transcript',
+    'WB-004.h-real-profiles-byte-identical',
+  ];
+  const proven = essential.every(id => (results.find(entry => entry.caseId === id) || {}).status === 'PASS');
+
+  const summary = {
+    lane: 'test-workbench-runtime',
+    file: 'parallel-workbench-runtime-wb004-ordering.js',
+    case: 'WB-004',
+    title: '连续回复次序（真实浏览器 + 真实模型 + 故障注入）',
+    module: identity,
+    host: { mode: 'standalone', engineUrlConfigured: false, dataDir: host.layout.dataDir, workspace: host.layout.workspace },
+    profile: { id: PROFILE_ID, source: 'original-subscription-store read-only, credential in memory only', credentialWrittenAnywhere: false },
+    faultInjection: 'a real Q1 event of this round, recorded on the product\'s own SSE stream, is delivered a second time to that same stream while Q2 is running',
+    turn: outcome,
+    cases: results,
+    verdict: proven ? 'PASS (ordering proven: no repeated Q1 body, no wrongly idle Q2)' : 'BLOCKED',
+    paidTurnsSent: outcome ? outcome.paidTurns : 0,
+    quotaEndpointQueried: false,
+    networkUsed: true,
+  };
+
+  const evidenceTarget = process.env.PARALLEL_WORKBENCH_RUNTIME_EVIDENCE;
+  harness.writeEvidence(evidenceTarget, summary);
+  if (!proven) {
+    // A real API error keeps the scene: the isolated layout is left on disk.
+    console.log(`SCENE KEPT ${host.layout.root}`);
+  } else {
+    fixture.removeTree(host.layout.root);
+  }
+  console.log(`parallel-workbench-runtime-wb004-ordering verdict=${summary.verdict}`);
+  process.exitCode = proven ? 0 : 3;
+})().catch(error => {
+  console.error(error);
+  process.exitCode = 1;
+});
+
+function assertTrue(condition, message) {
+  if (!condition) throw new Error(message);
+}

package/_site/_test/parallel-workbench-model-probe.js

@@ -0,0 +1,336 @@
+'use strict';
+// WB-003 — real subscription model probe through an isolated real host.
+//
+// What this probe does:
+//   * it hosts the REAL installed claude-ai-workbench module (the copy the
+//     installed product ships) as an isolated integration host, with this
+//     lane's controlled knowledge-engine fixture behind KB_KNOWLEDGE_ENGINE_URL;
+//   * it injects the ORIGINAL subscription profile store through a read-only
+//     facade: the credential is read from its real location into memory and
+//     is never written to any file, log, report or clone. No write method on
+//     the store is possible;
+//   * it asks ONE unique random question and requires, as evidence:
+//       - the SDK-REPORTED model from the system/init event — the runner
+//         copies it from the CLI's own init message, so it is what the SDK
+//         reports for the session, NOT by itself proof of what the vendor
+//         returned (the profile label alone never counts as evidence either);
+//         the vendor-RETURNED model is message.model of real assistant
+//         messages in the CLI transcript, extracted by
+//         parallel-workbench-standalone-turn.js,
+//       - the vendor claude session id,
+//       - the answer echoing the unique token of this round (request
+//         correlation),
+//       - the controlled integration fixture having received this session's
+//         context request (integration-context correlation).
+//
+// What this probe does NOT do:
+//   * it sends NO MiniMax request. The user confirmed the MiniMax quota is
+//     exhausted (real 429, vendor code 2067); the positive MiniMax-M3.1-Flash
+//     acceptance stays BLOCKED on the preserved 429 evidence and no attempt
+//     is made to turn it green, and a GLM answer is never presented as a
+//     MiniMax answer;
+//   * it never queries a quota endpoint, never switches provider or plan,
+//     and never fakes a model response.
+//
+// Exit codes: 0 = every sub-item positively verified;
+//             3 = at least one sub-item honestly BLOCKED (recorded);
+//             1 = script error.
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const fixture = require('./helpers/parallel-workbench-fixture');
+const sourceMap = require('./helpers/parallel-workbench-source-map');
+
+const PROFILE_ID = String(process.env.PK_WB_MODEL_PROFILE || 'glm');
+const REQUESTED_MODEL = String(process.env.PK_WB_MODEL_ID || 'glm-5.3');
+const EFFORT = String(process.env.PK_WB_MODEL_EFFORT || 'max');
+const TURN_TIMEOUT_MS = Number(process.env.PK_WB_TURN_TIMEOUT_MS || 360000);
+const MINIMAX_429_EVIDENCE = 'qa-autopilot/artifacts/parallel-20261023/minimax-429-handoff/minimax-result.json';
+
+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(30000) });
+  const body = await response.json().catch(() => null);
+  return { status: response.status, ok: response.ok, body };
+}
+
+// Consume the session SSE stream until the predicate is satisfied.
+async function consumeEvents(url, onEvent, until, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(new Error(`event stream timed out after ${timeoutMs}ms`)), timeoutMs);
+  let done = null;
+  const finished = new Promise(resolve => { done = resolve; });
+  (async () => {
+    try {
+      const response = await fetch(url, { signal: controller.signal });
+      if (!response.ok) throw new Error(`event stream HTTP ${response.status}`);
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = '';
+      for (;;) {
+        const { value, done: streamDone } = await reader.read();
+        if (streamDone) break;
+        buffer += decoder.decode(value, { stream: true });
+        let index;
+        while ((index = buffer.indexOf('\n')) >= 0) {
+          const line = buffer.slice(0, index).replace(/\r$/, '');
+          buffer = buffer.slice(index + 1);
+          if (!line.startsWith('data:')) continue;
+          const payload = line.slice(5).trim();
+          if (!payload) continue;
+          let event;
+          try { event = JSON.parse(payload); } catch { continue; }
+          try { onEvent(event); } catch { /* listener errors never kill the stream */ }
+          if (until(event)) { controller.abort(); return; }
+        }
+      }
+    } catch { /* aborted or ended */ }
+    finally { done && done(); }
+  })();
+  await finished;
+  clearTimeout(timer);
+}
+
+(async () => {
+  const moduleRoot = fixture.resolveHostModuleRoot();
+  assert.ok(moduleRoot, 'no claude-ai-workbench module copy was found to host');
+  const identity = sourceMap.packageIdentity(moduleRoot);
+  const moduleRootLabel = moduleRoot === sourceMap.resolveInstalledProductPackage()
+    ? 'currently-installed-package:installed-product'
+    : 'currently-installed-package:repository-pin';
+
+  // ---------- the MiniMax positive acceptance stays BLOCKED ---------------
+  // No new MiniMax request is attempted. The preserved evidence of the real
+  // 429 (vendor code 2067) is referenced, not re-run.
+  let minimaxEvidence = null;
+  try {
+    minimaxEvidence = JSON.parse(fs.readFileSync(path.resolve(fixture.REPO_ROOT, MINIMAX_429_EVIDENCE), 'utf8'));
+  } catch { minimaxEvidence = null; }
+  const minimaxBlocked = Boolean(
+    minimaxEvidence
+    && minimaxEvidence.isError === true
+    && /429/.test(String(minimaxEvidence.result || '')),
+  );
+  record('WB-003.x-minimax-positive', 'BLOCKED', {
+    rule: '模型返回的确是MiniMax-M3.1-Flash',
+    status: 'BLOCKED',
+    reason: 'the MiniMax subscription quota is exhausted; the real API rejected the lanes with 429 (vendor code 2067, Token Plan 用量上限)',
+    newMiniMaxRequestAttempted: false,
+    glmEvidenceCountedAsMiniMax: false,
+    preservedEvidence: MINIMAX_429_EVIDENCE,
+    preservedEvidenceVerified: Boolean(minimaxEvidence),
+    preservedIsError: minimaxEvidence ? minimaxEvidence.isError : null,
+    preservedAt: minimaxEvidence ? minimaxEvidence.at : null,
+    note: 'per the user instruction the probe does not send further MiniMax requests and does not present GLM responses as MiniMax evidence',
+  });
+
+  // ---------- the real subscription turn ----------------------------------
+  const layout = fixture.createIsolationLayout('parallel-wb-model');
+  const integrationFixture = await fixture.startIntegrationFixture();
+  const port = await fixture.freePort();
+  const base = `http://127.0.0.1:${port}`;
+  const child = 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: 'integration',
+    PK_WB_ENGINE_URL: integrationFixture.url,
+    PK_WB_PROFILE_SOURCE: 'real-readonly',
+  }));
+
+  const token = `WB003-${PROFILE_ID.toUpperCase()}-${crypto.randomBytes(5).toString('hex')}`;
+  const question = [
+    '这是一次真实订阅模型抽测（Workbench WB-003）。',
+    `请只回复一行，原样包含以下随机标记，不要添加任何其他内容：${token}`,
+  ].join('\n');
+
+  let glmOutcome;
+  try {
+    await fixture.waitForHttp(`${base}/api/claude-workbench/v1/health`, 30000);
+
+    // The original profile store, read through the read-only facade: the
+    // masked public shape only, never the credential.
+    const profiles = await getJson(`${base}/api/claude-workbench/v1/profiles`);
+    const listed = Array.isArray(profiles.body && profiles.body.profiles) ? profiles.body.profiles : [];
+    const target = listed.find(profile => profile.id === PROFILE_ID) || null;
+    record('WB-003.a-profile-injected-readonly', target ? 'PASS' : 'BLOCKED', {
+      profileId: PROFILE_ID,
+      credentialConfigured: target ? target.credentialConfigured === true : null,
+      baseUrl: target ? target.baseUrl : null,
+      defaultModel: target ? target.models && target.models.default : null,
+      credentialMaterialLogged: false,
+      storeWritesPossible: false,
+    });
+    assert.ok(target, `the ${PROFILE_ID} profile was not visible through the read-only facade`);
+    assert.equal(target.credentialConfigured, true, 'the original credential is not configured');
+
+    const session = await getJson(`${base}/api/claude-workbench/v1/sessions`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        context: { contextId: 'wb003-model-probe', workspaceRef: 'wb-fixture' },
+        aiProfileId: PROFILE_ID,
+        model: REQUESTED_MODEL,
+        effort: EFFORT,
+      }),
+    });
+    const created = session.body && session.body.session;
+    record('WB-003.b-session-with-subscription-profile', session.status === 201 && created ? 'PASS' : 'BLOCKED', {
+      httpStatus: session.status,
+      sessionId: created && created.sessionId,
+      model: created && created.model,
+      authSource: created && created.authSource,
+      providerName: created && created.providerName,
+    });
+    assert.equal(session.status, 201);
+    const sessionId = created.sessionId;
+    assert.equal(created.authSource, 'profile-injected');
+
+    // Stream the session events and run the unique question.
+    const events = [];
+    let settle = null;
+    const settled = new Promise(resolve => { settle = resolve; });
+    const isTerminal = event => event.type === 'claude/result';
+    const streamUrl = `${base}/api/claude-workbench/v1/sessions/${encodeURIComponent(sessionId)}/events`;
+    const consume = consumeEvents(streamUrl, event => {
+      if (['claude/init', 'claude/result', 'claude/error', 'claude/aborted'].includes(event.type)) events.push(event);
+    }, isTerminal, TURN_TIMEOUT_MS + 60000).catch(() => {});
+
+    const send = await getJson(`${base}/api/claude-workbench/v1/sessions/${encodeURIComponent(sessionId)}/input`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ text: question }),
+    });
+    record('WB-003.c-unique-question-accepted', send.status === 202 ? 'PASS' : 'BLOCKED', {
+      httpStatus: send.status,
+      uniqueToken: token,
+    });
+    assert.equal(send.status, 202);
+
+    const deadline = Date.now() + TURN_TIMEOUT_MS;
+    while (Date.now() < deadline && !events.some(isTerminal)) {
+      await new Promise(resolve => setTimeout(resolve, 250));
+    }
+    settle && settle();
+    await Promise.race([consume, new Promise(resolve => setTimeout(resolve, 5000))]);
+
+    const init = events.find(event => event.type === 'claude/init') || null;
+    const result = events.find(event => event.type === 'claude/result') || null;
+    const error = events.find(event => event.type === 'claude/error') || null;
+    // SDK-reported model: the system/init string the CLI produced for this
+    // session. Vendor-RETURNED evidence is the assistant message.model of the
+    // CLI transcript (see parallel-workbench-standalone-turn.js).
+    const sdkReportedModel = init ? init.model : null;
+    const vendorSessionId = init ? init.claudeSessionId : null;
+    const answer = result ? String(result.result || '') : '';
+    const tokenEchoed = answer.includes(token);
+    const isError = result ? result.isError === true : true;
+
+    glmOutcome = {
+      requestedModel: REQUESTED_MODEL,
+      effort: EFFORT,
+      sdkReportedModel,
+      sdkReportedModelMatchesRequest: typeof sdkReportedModel === 'string'
+        ? sdkReportedModel.replace(/\s+/g, '').toLowerCase() === REQUESTED_MODEL.replace(/\s+/g, '').toLowerCase()
+        : false,
+      vendorClaudeSessionId: vendorSessionId,
+      workbenchSessionId: sessionId,
+      isError,
+      answerPreview: answer.slice(0, 300),
+      tokenEchoed,
+      usage: result && result.usage ? {
+        inputTokens: result.usage.input_tokens,
+        outputTokens: result.usage.output_tokens,
+      } : null,
+      errorEvent: error,
+    };
+
+    // S1: the SDK-reported model, verbatim — labelled as what it is.
+    record('WB-003.d1-sdk-model-reported', typeof sdkReportedModel === 'string' && sdkReportedModel.length > 0 ? 'PASS' : 'BLOCKED', {
+      sdkReportedModel,
+      note: 'the system/init model string the SDK reports for the session; it is NOT by itself vendor-returned evidence — the vendor-returned model is the assistant message.model of the CLI transcript (parallel-workbench-standalone-turn.js)',
+    });
+
+    // S2: the response is correlated to THIS round.
+    record('WB-003.d2-response-correlated', !isError && tokenEchoed ? 'PASS' : 'BLOCKED', {
+      isError,
+      uniqueToken: token,
+      tokenEchoedInAnswer: tokenEchoed,
+      vendorClaudeSessionId: vendorSessionId,
+      workbenchSessionId: sessionId,
+    });
+
+    // S3: no stand-in anywhere in the chain.
+    record('WB-003.d3-no-standin', !isError && typeof sdkReportedModel === 'string' && sdkReportedModel.length > 0 ? 'PASS' : 'BLOCKED', {
+      profileSource: 'original-subscription-store-read-only-in-memory',
+      standInEmbedderUsed: false,
+      mockProviderUsed: false,
+      lexicalFallbackUsed: false,
+      providerSwitched: false,
+    });
+
+    // S4: the integration context was consumed by the SAME real turn.
+    const knowledge = await getJson(`${base}/api/claude-workbench/v1/sessions/${encodeURIComponent(sessionId)}/knowledge`);
+    const fixtureRequest = integrationFixture.requests.find(request => request.body && request.body.sessionId === sessionId) || null;
+    const queryCarriedToken = Boolean(fixtureRequest && String(fixtureRequest.body.query || '').includes(token));
+    record('WB-003.d4-integration-context-correlated', knowledge.ok && knowledge.body && knowledge.body.status === 'ready' && fixtureRequest ? 'PASS' : 'BLOCKED', {
+      knowledgeStatus: knowledge.body && knowledge.body.status,
+      fixtureKind: 'controlled-integration-fixture',
+      fixtureSawSession: Boolean(fixtureRequest),
+      fixtureSawUniqueTokenInQuery: queryCarriedToken,
+    });
+  } finally {
+    child.child.kill();
+    await child.exited;
+    await integrationFixture.close();
+  }
+
+  const glmPass = ['WB-003.d1-sdk-model-reported', 'WB-003.d2-response-correlated', 'WB-003.d3-no-standin']
+    .every(id => (results.find(entry => entry.caseId === id) || {}).status === 'PASS');
+
+  if (!glmPass) {
+    console.log('WB-003 GLM turn did not produce positive evidence — recording the real outcome, no retry loop, no provider switch');
+  }
+
+  const summary = {
+    lane: 'test-workbench',
+    file: 'parallel-workbench-model-probe.js',
+    case: 'WB-003',
+    title: '真实模型抽测',
+    module: { label: moduleRootLabel, root: moduleRoot, name: identity.name, version: identity.version },
+    host: { mode: 'integration', engineFixture: 'controlled-integration-fixture', dataDir: layout.dataDir, workspace: layout.workspace },
+    profile: { id: PROFILE_ID, source: 'original-subscription-store read-only, credential in memory only', credentialWrittenAnywhere: false },
+    glmTurn: glmOutcome,
+    minimaxPositiveAcceptance: {
+      status: 'BLOCKED',
+      reason: 'MiniMax subscription quota exhausted — real 429 with vendor code 2067 (Token Plan 用量上限), preserved in the handoff evidence; no further MiniMax request attempted per user instruction',
+      evidence: MINIMAX_429_EVIDENCE,
+      glmCountedAsMiniMax: false,
+    },
+    verdict: glmPass ? 'PARTIAL (GLM methodology PASS; MiniMax positive acceptance BLOCKED)' : 'BLOCKED',
+    networkUsed: true,
+    quotaEndpointQueried: 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');
+  }
+  fixture.removeTree(layout.root);
+  console.log(`parallel-workbench-model-probe verdict=${summary.verdict}`);
+  // The MiniMax positive acceptance is BLOCKED, so the probe never exits 0,
+  // even when every GLM methodology sub-item passes.
+  process.exitCode = 3;
+})().catch(error => {
+  console.error(error);
+  process.exitCode = 1;
+});