@sanqianx/project-knowledge 5.0.23 → 5.0.25

package/_site/_test/parallel-ci-r9-posix-socket-budget-test.js

@@ -0,0 +1,156 @@
+'use strict';
+// _site/_test/parallel-ci-r9-posix-socket-budget-test.js
+//
+// P-CI-LAST-LINUX-R9 focused case: the POSIX control-socket path budget that
+// killed normalhook on CI 40075242420 (linux24, exit 1, empty pipes).
+//
+// Mechanism (all source-proven, see the R9 evidence lane): the product's
+// runtime-control listens on a filesystem unix socket at
+// <dataDir>/runtime-control.sock on POSIX (runtime-control.js:14; Windows uses
+// a hashed named pipe with no length dependence). Linux sun_path is 108 bytes
+// including the NUL, so paths longer than 107 chars cannot bind. The logging
+// lane stacks three name layers — laneTmp (5025-env mkdtemp `${prefix}-`),
+// its `temp` dir (TEMP/TMP/TMPDIR), and the acceptance fixture's dataDir
+// mkdtemp — and the OLD 'pk-logging-acc-' fixture prefix made the
+// logfixr2-normal dataDir produce a 109-char socket on the CI temp root
+// (/home/runner/work/_temp): unbindable, so the server exited 1 before the
+// health gate and the test timed out with zero child output.
+//
+// This case locks the class, not the incident:
+//   1. every logging-lane (prefix, caseId) pair builds a bindable socket
+//      string on the documented CI Linux temp root (pure string math, runs
+//      and holds on BOTH platforms);
+//   2. the fixture's fail-fast guard rejects an over-budget dataDir and
+//      accepts in-budget ones (on win32 it is a no-op — named pipes);
+//   3. on POSIX the kernel verdict is reproduced live: the fixed normalhook
+//      length binds; the 109 incident is recorded, without assuming whether
+//      this Node/libuv version refuses or truncates it. 108 is also diagnostic.
+//      on win32 this leg is reported platform-skipped (no sun_path there);
+//   4. the product's controlPath shape per platform is asserted unchanged.
+//
+// No server spawn, no engine, no browser: naming + kernel contracts only.
+
+const fs = require('node:fs');
+const os = require('node:os');
+const net = require('node:net');
+const path = require('node:path');
+const assert = require('node:assert/strict');
+
+const { applyDriverIsolation } = require('./helpers/parallel-qa-engine-endpoint-isolate');
+const isolation = applyDriverIsolation({ prefix: 'r9-socket-budget' });
+const ownedRoot = fs.realpathSync(isolation.layout.root);
+const { controlPath } = require('../lib/runtime-control');
+const { assertPosixSocketBudget, POSIX_SOCKET_CHAR_LIMIT } = require('./helpers/parallel-logging-acceptance-fixture');
+
+const CI_LINUX_TEMP_ROOT = '/home/runner/work/_temp'; // from the 40075242420 log (PK_TEST_TEMP_ROOT)
+const MKDTEMP_RANDOM = 6; // fs.mkdtempSync appends exactly 6 random chars
+const SOCK_SUFFIX = '/runtime-control.sock'; // 21 chars — runtime-control.js:14 (POSIX)
+
+// Every spawnServer consumer of the acceptance fixture in the logging lane
+// (test file → lane prefix → fixture caseId).
+const LANE_CASES = [
+  ['parallel-logging-acceptance-log003-test.js', 'log003', 'log003'],
+  ['parallel-logging-acceptance-log004-test.js', 'log004', 'log004'],
+  ['parallel-logging-acceptance-log005-test.js', 'log005', 'log005'],
+  ['parallel-logging-acceptance-log006-test.js', 'log006', 'log006'],
+  ['parallel-logging-acceptance-log007-test.js', 'log007', 'log007'],
+  ['parallel-logging-acceptance-log008-test.js', 'log008', 'log008'],
+  ['parallel-logging-fix-r2-gap-test.js', 'logfixr2-gap', 'logfixr2gap'],
+  ['parallel-logging-fix-r2-normalhook-test.js', 'logfixr2-normal', 'logfixr2normal'],
+];
+
+// Replicates the three naming layers verbatim (5025-env:331,336,361-363 and
+// the fixture's mkdtemp) against an arbitrary temp root.
+function laneSocketPath(tempRoot, prefix, caseId, fixturePrefix) {
+  const laneTmp = path.posix.join(tempRoot, `${prefix}-${'x'.repeat(MKDTEMP_RANDOM)}`);
+  const tmpdir = path.posix.join(laneTmp, 'temp');
+  const dataDir = path.posix.join(tmpdir, `${fixturePrefix}${caseId}-${'x'.repeat(MKDTEMP_RANDOM)}`);
+  return path.posix.join(dataDir, 'runtime-control.sock');
+}
+
+function tryListen(socketPath) {
+  return new Promise(resolve => {
+    const server = net.createServer(() => {});
+    const fail = error => resolve({ bound: false, code: error.code || null, message: String(error.message).slice(0, 160) });
+    server.once('error', fail);
+    server.listen(socketPath, () => server.close(() => resolve({ bound: true })));
+  });
+}
+
+async function main() {
+  const proof = { case: 'P-CI-LAST-LINUX-R9 posix-socket-budget', startedAt: new Date().toISOString() };
+
+  // ---- 1. every lane case is bindable on the CI Linux temp root -----------
+  const rows = LANE_CASES.map(([test, prefix, caseId]) => {
+    const fixed = laneSocketPath(CI_LINUX_TEMP_ROOT, prefix, caseId, 'pk-la-').length;
+    const old = laneSocketPath(CI_LINUX_TEMP_ROOT, prefix, caseId, 'pk-logging-acc-').length;
+    return { test, oldLength: old, fixedLength: fixed, oldWasBindable: old <= POSIX_SOCKET_CHAR_LIMIT, fixedBindable: fixed <= POSIX_SOCKET_CHAR_LIMIT };
+  });
+  for (const row of rows) {
+    assert.ok(row.fixedBindable, `${row.test}: fixed socket length ${row.fixedLength} exceeds the POSIX budget ${POSIX_SOCKET_CHAR_LIMIT} on the CI temp root`);
+  }
+  const normalhook = rows.find(r => r.test.includes('normalhook'));
+  assert.ok(!normalhook.oldWasBindable && normalhook.oldLength === 109, `the CI incident stays red as history: normalhook OLD length was 109 (> ${POSIX_SOCKET_CHAR_LIMIT})`);
+  proof.laneBudgets = rows;
+
+  // ---- 2. the fixture guard fails fast on over-budget, passes in-budget ---
+  const okDir = laneSocketPath(CI_LINUX_TEMP_ROOT, 'logfixr2-normal', 'logfixr2normal', 'pk-la-').slice(0, -SOCK_SUFFIX.length);
+  const longDir = laneSocketPath(CI_LINUX_TEMP_ROOT, 'logfixr2-normal', 'logfixr2normal', 'pk-logging-acc-').slice(0, -SOCK_SUFFIX.length);
+  if (process.platform === 'win32') {
+    assert.equal(assertPosixSocketBudget(longDir), longDir, 'on win32 the control channel is a named pipe: the guard is a no-op');
+    proof.fixtureGuard = { platform: 'win32', behavior: 'no-op (named pipe)' };
+  } else {
+    assert.equal(assertPosixSocketBudget(okDir), okDir, 'an in-budget dataDir passes the guard');
+    assert.throws(() => assertPosixSocketBudget(longDir), /POSIX control socket/, 'an over-budget dataDir is rejected at fixture time, before any spawn');
+    proof.fixtureGuard = { platform: process.platform, behavior: 'throws on over-budget, passes in-budget' };
+  }
+
+  // ---- 3. the kernel verdict where sun_path actually applies --------------
+  if (process.platform === 'win32') {
+    proof.kernelVerdict = { platform: 'win32', skipped: true, reason: 'no sun_path limit on Windows named pipes; leg 1 proves the CI-Linux string math' };
+  } else {
+    const base = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-r9-budget-'));
+    const makeAtLength = length => {
+      const parent = path.join(base, 'a'.repeat(Math.max(1, length - SOCK_SUFFIX.length - base.length - 1)));
+      fs.mkdirSync(parent, { recursive: true });
+      const socketPath = path.join(parent, 'runtime-control.sock');
+      assert.equal(socketPath.length, length);
+      return socketPath;
+    };
+    const fixedLength = laneSocketPath(CI_LINUX_TEMP_ROOT, 'logfixr2-normal', 'logfixr2normal', 'pk-la-').length;
+    const outcomes = {};
+    outcomes.fixed = { length: fixedLength, ...(await tryListen(makeAtLength(fixedLength))) };
+    outcomes.incident109 = { length: 109, ...(await tryListen(makeAtLength(109))) };
+    // 108 is measured but NOT asserted: the exact sun_path boundary is
+    // runtime-dependent (some libuv callers truncate; others reject),
+    // so neither boundary observation is a cross-version product contract.
+    outcomes.boundary108 = { length: 108, ...(await tryListen(makeAtLength(108))) };
+    assert.ok(outcomes.fixed.bound, `the fixed normalhook socket length (${fixedLength}) binds on this POSIX kernel`);
+    // Node 22 may truncate both bind and connect names; a universal refusal
+    // assertion would characterize the runtime incorrectly. The fixture guard
+    // above remains strict, and the fixed in-budget socket must really bind.
+    proof.kernelVerdict = { platform: process.platform, outcomes };
+    fs.rmSync(base, { recursive: true, force: true });
+  }
+
+  // ---- 4. the product control-path shape per platform ---------------------
+  const sampleDataDir = '/tmp/pk-la-sample-abc123';
+  if (process.platform === 'win32') {
+    assert.match(controlPath(sampleDataDir), /^\\\\\.\\pipe\\project-knowledge-[0-9a-f]{32}$/, 'win32 control channel is the hashed named pipe (no length dependence)');
+  } else {
+    assert.equal(controlPath(sampleDataDir), path.join(sampleDataDir, 'runtime-control.sock'), 'POSIX control channel is the in-dir unix socket');
+  }
+  proof.controlPathShape = String(controlPath(sampleDataDir));
+
+  proof.verdict = 'PASS';
+  console.log(`parallel-ci-r9-posix-socket-budget-test PASS (${proof.kernelVerdict.skipped ? 'string-math + guard legs; kernel leg platform-skipped on win32' : 'string-math + guard + live kernel legs'}; normalhook fixed=${normalhook.fixedLength} ≤ ${POSIX_SOCKET_CHAR_LIMIT}, old=${normalhook.oldLength})`);
+  console.log(JSON.stringify(proof, null, 2));
+}
+
+main().catch(error => { console.error(error.stack || error.message); process.exitCode = 1; }).finally(() => {
+  const owner = JSON.parse(fs.readFileSync(path.join(ownedRoot, 'owner.json'), 'utf8'));
+  assert.equal(fs.realpathSync(isolation.layout.root), ownedRoot, 'cleanup stays in the freshly owned isolation root');
+  assert.equal(owner.pid, process.pid);
+  assert.equal(owner.tag, 'r9-socket-budget');
+  fs.rmSync(ownedRoot, { recursive: true, force: true });
+});

package/_site/_test/parallel-engine-advanced-eng005-test.js

@@ -0,0 +1,136 @@
+'use strict';
+
+// P-ENG-ADVANCED ENG-005 单项目顺序 (single-project ordering) acceptance driver.
+//
+// Case (qa-autopilot/config/test-cases.json ENG-005):
+//   steps:    连续提交A/B/C，令B失败。
+//   expected: 1) A成功、B失败、C等待。 2) 不能越过B宣告分析到C。
+//
+// Real behavior under test: vendored knowledge-engine child process, real
+// fixture git commits, real disk state (engine-state.json, knowledge tree),
+// analyzer = declarative stand-in (NO real model output), failure of B via the
+// engine's own debug fault surface (simulateFailure, honored before the
+// analyzer runs). Vector endpoint is a loopback double (vector-hub not covered).
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+  makeLaneDir, buildFixtureRepo, waitUntil, callJson, startVectorDouble,
+  startEngineChild, readEventsFile, writePlan, saveEvidence,
+} = require('./helpers/parallel-engine-advanced-harness.js');
+
+const ARTIFACTS = process.env.PK_TEST_EVIDENCE_ROOT
+  ? path.join(process.env.PK_TEST_EVIDENCE_ROOT, 'eng005')
+  : path.resolve(__dirname, '../../qa-autopilot/artifacts/parallel-20261023/engine-review-r3/reruns/eng005');
+const PROJECT_ID = 'project-eng005';
+
+async function main() {
+  const lane = makeLaneDir('eng005');
+  const commands = [];
+  const evidence = { caseId: 'ENG-005', laneDir: lane, phases: {}, commands };
+  const fixture = buildFixtureRepo(lane, 'eng005', ['A', 'B', 'C']);
+  const knowledgePath = path.join(lane, 'knowledge-eng005');
+  fs.mkdirSync(knowledgePath, { recursive: true });
+  const planFile = path.join(lane, 'analyzer-plan.json');
+  const eventsFile = path.join(lane, 'analyzer-events.jsonl');
+  writePlan(planFile, { default: { delayMs: 250 }, rules: [] });
+
+  const vector = await startVectorDouble();
+  const engine = await startEngineChild({ label: 'eng005', dataDir: path.join(lane, 'engine-data'), vectorUrl: vector.url, planFile, eventsFile });
+  commands.push(`POST /api/projects (trackingStartCommit=${fixture.baseline.slice(0, 7)})`, 'POST /api/runs A', 'POST /api/runs B simulateFailure:true', 'POST /api/runs C');
+
+  try {
+    const registered = await callJson(engine.base, '/api/projects', {
+      projectId: PROJECT_ID, name: 'eng005', repoPath: fixture.repoPath, knowledgePath, trackingStartCommit: fixture.baseline,
+    });
+    assert.equal(registered.status, 200, `project registration failed: ${JSON.stringify(registered.body)}`);
+
+    const runA = (await callJson(engine.base, '/api/runs', { projectId: PROJECT_ID, commitSha: fixture.shas.A })).body.run;
+    const runB = (await callJson(engine.base, '/api/runs', { projectId: PROJECT_ID, commitSha: fixture.shas.B, simulateFailure: true })).body.run;
+    const runC = (await callJson(engine.base, '/api/runs', { projectId: PROJECT_ID, commitSha: fixture.shas.C })).body.run;
+    assert.ok(runA && runB && runC, 'enqueue responses carry run objects');
+
+    // --- Expected 1: A成功、B失败、C等待 ---
+    await waitUntil(async () => {
+      const runs = (await callJson(engine.base, `/api/runs?projectId=${PROJECT_ID}`)).body.runs;
+      const by = sha => runs.find(r => r.commitSha === sha);
+      return by(fixture.shas.A)?.state === 'succeeded' && by(fixture.shas.B)?.state === 'failed' && by(fixture.shas.C)?.state === 'queued';
+    }, 30000, 'A succeeded / B failed / C queued');
+
+    const snapshot1 = (await callJson(engine.base, `/api/runs?projectId=${PROJECT_ID}`)).body.runs;
+    const sA = snapshot1.find(r => r.commitSha === fixture.shas.A);
+    const sB = snapshot1.find(r => r.commitSha === fixture.shas.B);
+    const sC = snapshot1.find(r => r.commitSha === fixture.shas.C);
+    assert.equal(sA.state, 'succeeded'); assert.equal(sA.phase, 'ready');
+    assert.equal(sB.state, 'failed'); assert.equal(sB.error.code, 'DEBUG_SIMULATED_FAILURE');
+    assert.equal(sC.state, 'queued'); assert.equal(sC.phase, 'waiting-previous');
+    evidence.phases.afterBfailed = {
+      A: { state: sA.state, phase: sA.phase, promotedAt: sA.promotedAt },
+      B: { state: sB.state, phase: sB.phase, error: sB.error },
+      C: { state: sC.state, phase: sC.phase },
+    };
+
+    // --- Expected 2: 不能越过B宣告分析到C ---
+    const events1 = readEventsFile(eventsFile);
+    const startedShas = new Set(events1.filter(e => e.kind === 'start').map(e => e.commitSha));
+    assert.equal(events1.filter(e => e.kind === 'start' && e.commitSha === fixture.shas.A).length, 1, 'A analyzed exactly once');
+    assert.ok(!startedShas.has(fixture.shas.B), 'B never reached the analyzer (engine refuses before stand-in)');
+    assert.ok(!startedShas.has(fixture.shas.C), 'C was never analyzed while B failed - no skipping past B');
+    assert.ok(!fs.existsSync(path.join(knowledgePath, 'changes', `${fixture.shas.B.slice(0, 12)}.md`)), 'no B knowledge file');
+    assert.ok(!fs.existsSync(path.join(knowledgePath, 'changes', `${fixture.shas.C.slice(0, 12)}.md`)), 'no C knowledge file');
+    assert.ok(fs.existsSync(path.join(knowledgePath, 'changes', `${fixture.shas.A.slice(0, 12)}.md`)), 'A knowledge file exists');
+
+    const stateAfterFailure = (await callJson(engine.base, `/api/snapshot?projectId=${PROJECT_ID}`)).body;
+    const runtime1 = stateAfterFailure.projects.find(p => p.projectId === PROJECT_ID).runtime;
+    assert.equal(runtime1.lastAnalyzedCommit, fixture.shas.A, 'pointer stays at A while B failed');
+    evidence.phases.pointerAfterBfailed = runtime1.lastAnalyzedCommit;
+
+    // Recovery: retry B, then C must proceed strictly after B.
+    commands.push('POST /api/runs/:B/retry', 'wait C succeeded');
+    const retried = await callJson(engine.base, `/api/runs/${encodeURIComponent(runB.runId)}/retry`, {});
+    assert.equal(retried.status, 200, `retry B failed: ${JSON.stringify(retried.body)}`);
+    await waitUntil(async () => {
+      const runs = (await callJson(engine.base, `/api/runs?projectId=${PROJECT_ID}`)).body.runs;
+      return runs.every(r => r.state === 'succeeded');
+    }, 30000, 'B retry and C both succeed');
+    const snapshot2 = (await callJson(engine.base, `/api/runs?projectId=${PROJECT_ID}`)).body.runs;
+    const events2 = readEventsFile(eventsFile);
+    const bStart = events2.find(e => e.kind === 'start' && e.commitSha === fixture.shas.B);
+    const cStart = events2.find(e => e.kind === 'start' && e.commitSha === fixture.shas.C);
+    const bFinish = events2.find(e => e.kind === 'finish' && e.commitSha === fixture.shas.B);
+    assert.ok(bStart && cStart && bFinish, 'analyzer saw B (after retry) then C');
+    assert.ok(new Date(cStart.at) >= new Date(bFinish.at), 'C analysis started only after B finished');
+    for (const sha of ['A', 'B', 'C']) {
+      assert.equal(events2.filter(e => e.kind === 'start' && e.commitSha === fixture.shas[sha]).length, 1, `${sha} analyzed exactly once across failure+retry`);
+    }
+    const runtime2 = (await callJson(engine.base, `/api/snapshot?projectId=${PROJECT_ID}`)).body.projects.find(p => p.projectId === PROJECT_ID).runtime;
+    assert.equal(runtime2.lastAnalyzedCommit, fixture.shas.C, 'pointer ends at C after ordered recovery');
+    evidence.phases.afterRecovery = {
+      runs: snapshot2.map(r => ({ commit: r.commitSha.slice(0, 7), state: r.state, phase: r.phase, promotedAt: r.promotedAt })),
+      analyzerStarts: events2.filter(e => e.kind === 'start').map(e => ({ sha: e.commitSha.slice(0, 7), at: e.at })),
+      lastAnalyzedCommit: runtime2.lastAnalyzedCommit,
+    };
+
+    evidence.verdict = {
+      'expected1 A成功、B失败、C等待': 'PASS',
+      'expected2 不能越过B宣告分析到C': 'PASS',
+      analyzerStandin: 'declarative stand-in - real staged bytes, NO real model output covered',
+      vectorDouble: 'loopback HTTP double - vector-hub itself not covered',
+    };
+    await engine.stop();
+    await vector.close();
+    saveEvidence(ARTIFACTS, 'eng005-evidence.json', evidence);
+    console.log('ENG-005 PASS');
+    process.exitCode = 0;
+  } catch (error) {
+    evidence.verdict = { failed: String(error && error.stack || error) };
+    try { await engine.stop(); } catch {}
+    try { await vector.close(); } catch {}
+    saveEvidence(ARTIFACTS, 'eng005-evidence.json', evidence);
+    console.error(`ENG-005 FAIL: ${error.message}`);
+    process.exitCode = 1;
+  }
+}
+
+main();

package/_site/_test/parallel-engine-advanced-eng006-test.js

@@ -0,0 +1,171 @@
+'use strict';
+
+// P-ENG-ADVANCED ENG-006 跨项目并发 (cross-project concurrency) acceptance driver.
+//
+// Case (qa-autopilot/config/test-cases.json ENG-006):
+//   steps:    两个或更多fixture提交并观察调度。
+//   expected: 1) 按当前实际并发上限排队。 2) 项目之间无文件串写。
+//
+// Real behavior under test: vendored knowledge-engine child process with its
+// DEFAULT concurrency (coordinator clamps to 2), three projects (one with a
+// non-ASCII knowledge path), four queued runs, real analyzer-interval evidence
+// from the stand-in's JSONL log (no real model output), real per-project
+// knowledge trees on disk, loopback vector double.
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+  makeLaneDir, buildFixtureRepo, waitUntil, callJson, startVectorDouble,
+  startEngineChild, readEventsFile, writePlan, saveEvidence, listFilesRecursive,
+} = require('./helpers/parallel-engine-advanced-harness.js');
+
+const ARTIFACTS = process.env.PK_TEST_EVIDENCE_ROOT
+  ? path.join(process.env.PK_TEST_EVIDENCE_ROOT, 'eng006')
+  : path.resolve(__dirname, '../../qa-autopilot/artifacts/parallel-20261023/engine-review-r3/reruns/eng006');
+const PROJECTS = [
+  { projectId: 'project-eng006-a', name: 'eng006-a', dirName: 'repo-eng006-a', knowledgeName: 'knowledge-eng006-a' },
+  { projectId: 'project-eng006-b', name: 'eng006-b', dirName: 'repo-eng006-b', knowledgeName: 'knowledge-eng006-b' },
+  { projectId: 'project-eng006-c', name: 'eng006-c（中文路径）', dirName: 'repo-eng006-c', knowledgeName: '知识-eng006-c' },
+];
+
+function maxOverlap(intervals) {
+  const points = [];
+  for (const [start, end] of intervals) { points.push([start, 1], [end, -1]); }
+  points.sort((x, y) => x[0] - y[0] || y[1] - x[1]);
+  let live = 0; let peak = 0;
+  for (const [, delta] of points) { live += delta; peak = Math.max(peak, live); }
+  return peak;
+}
+
+async function main() {
+  const lane = makeLaneDir('eng006');
+  const commands = [];
+  const evidence = { caseId: 'ENG-006', laneDir: lane, phases: {}, commands };
+  const fixtures = [];
+  for (const spec of PROJECTS) {
+    fixtures.push({ spec, fixture: buildFixtureRepo(lane, spec.dirName, ['one', 'two']) });
+  }
+  const planFile = path.join(lane, 'analyzer-plan.json');
+  const eventsFile = path.join(lane, 'analyzer-events.jsonl');
+  writePlan(planFile, { default: { delayMs: 700 }, rules: [] });
+
+  const vector = await startVectorDouble();
+  const engine = await startEngineChild({ label: 'eng006', dataDir: path.join(lane, 'engine-data'), vectorUrl: vector.url, planFile, eventsFile });
+  commands.push('POST /api/projects x3 (default concurrency, no override)', 'POST /api/runs a#one, b#one, c#one, a#two');
+
+  try {
+    for (const { spec, fixture } of fixtures) {
+      const knowledgePath = path.join(lane, spec.knowledgeName);
+      fs.mkdirSync(knowledgePath, { recursive: true });
+      spec.knowledgePath = knowledgePath;
+      const registered = await callJson(engine.base, '/api/projects', {
+        projectId: spec.projectId, name: spec.name, repoPath: fixture.repoPath, knowledgePath, trackingStartCommit: fixture.baseline,
+      });
+      assert.equal(registered.status, 200, `registration failed for ${spec.projectId}`);
+    }
+
+    const enqueuePlan = [[0, 'one'], [1, 'one'], [2, 'one'], [0, 'two']];
+    for (const [index, label] of enqueuePlan) {
+      const { spec, fixture } = fixtures[index];
+      const commitSha = fixture.shas[label];
+      const response = await callJson(engine.base, '/api/runs', { projectId: spec.projectId, commitSha });
+      assert.equal(response.status, 200, `enqueue failed: ${JSON.stringify(response.body)}`);
+    }
+    evidence.enqueueNote = 'runs queued in order: a#one, b#one, c#one, a#two (a#two is project a second fixture commit)';
+
+    const health = (await callJson(engine.base, '/api/health')).body;
+    assert.equal(health.concurrency, 2, `actual concurrency limit is 2, got ${health.concurrency}`);
+    evidence.phases.healthConcurrency = { concurrency: health.concurrency, active: health.counts.running };
+
+    // Mid-flight: while the 700ms analyzer intervals run, expect exactly 2 running and 2 queued.
+    const midflight = await waitUntil(async () => {
+      const runs = (await callJson(engine.base, '/api/runs')).body.runs;
+      return runs.length === 4 && runs.filter(r => r.state === 'running').length === 2 && runs.filter(r => r.state === 'queued').length === 2 ? runs : null;
+    }, 20000, 'two runs active while two queued');
+    evidence.phases.midflight = midflight.map(r => ({ project: r.projectId, sha: r.commitSha.slice(0, 7), state: r.state, phase: r.phase }));
+
+    await waitUntil(async () => {
+      const runs = (await callJson(engine.base, '/api/runs')).body.runs;
+      return runs.length === 4 && runs.every(r => r.state === 'succeeded');
+    }, 40000, 'all four runs succeed');
+
+    // --- Expected 1: 按当前实际并发上限排队 ---
+    const events = readEventsFile(eventsFile);
+    const byRun = new Map();
+    for (const e of events) {
+      const key = `${e.projectId}:${e.commitSha.slice(0, 7)}`;
+      if (!byRun.has(key)) byRun.set(key, { projectId: e.projectId, sha: e.commitSha.slice(0, 7) });
+      byRun.get(key)[e.kind === 'start' ? 'startAt' : 'finishAt'] = e.at;
+    }
+    const intervals = [...byRun.values()].map(r => [new Date(r.startAt).getTime(), new Date(r.finishAt).getTime()]);
+    const peak = maxOverlap(intervals);
+    assert.equal(intervals.length, 4, 'four analysis intervals recorded');
+    assert.equal(peak, 2, `analyzer never exceeded the actual concurrency limit (peak=${peak}, limit=2)`);
+    // project a serialized: a#two start after a#one finish
+    const aOne = [...byRun.values()].find(r => r.projectId === PROJECTS[0].projectId && r.sha === fixtures[0].fixture.shas.one.slice(0, 7));
+    const aTwo = [...byRun.values()].find(r => r.projectId === PROJECTS[0].projectId && r.sha === fixtures[0].fixture.shas.two.slice(0, 7));
+    assert.ok(aOne && aTwo, 'both project-a commits analyzed');
+    assert.ok(new Date(aTwo.startAt) >= new Date(aOne.finishAt), 'same-project runs serialized');
+    evidence.phases.schedule = {
+      concurrencyLimit: health.concurrency,
+      peakConcurrentAnalyzerIntervals: peak,
+      intervals: [...byRun.values()],
+      sameProjectSerialized: { aOneFinish: aOne.finishAt, aTwoStart: aTwo.startAt },
+    };
+
+    // --- Expected 2: 项目之间无文件串写 ---
+    const enqueuedLabelsByIndex = { 0: ['one', 'two'], 1: ['one'], 2: ['one'] };
+    for (const [index, { spec, fixture }] of fixtures.entries()) {
+      const files = listFilesRecursive(spec.knowledgePath);
+      const own = files.filter(f => f.startsWith('changes/'));
+      const expectedOwn = enqueuedLabelsByIndex[index].map(label => `changes/${fixture.shas[label].slice(0, 12)}.md`).sort();
+      assert.deepEqual(own.sort(), expectedOwn, `${spec.projectId} knowledge tree contains exactly its own promoted files`);
+      for (const file of own) {
+        const content = fs.readFileSync(path.join(spec.knowledgePath, ...file.split('/')), 'utf8');
+        assert.ok(content.includes(spec.projectId), `${file} mentions its own project`);
+        for (const other of PROJECTS) {
+          if (other.projectId !== spec.projectId) assert.ok(!content.includes(other.projectId), `${file} must not mention ${other.projectId} (no cross-write)`);
+        }
+      }
+    }
+    const finalRuns = (await callJson(engine.base, '/api/runs')).body.runs;
+    for (const run of finalRuns) {
+      const owner = PROJECTS.find(p => p.projectId === run.projectId);
+      assert.ok(owner, 'every run attributed to a registered project');
+      assert.ok([fixtures[PROJECTS.indexOf(owner)].fixture.shas.one, fixtures[PROJECTS.indexOf(owner)].fixture.shas.two].includes(run.commitSha), 'run commit belongs to its own project fixture');
+    }
+    const syncs = vector.requests.filter(r => r.url === '/api/sync');
+    assert.equal(syncs.length, 4, 'four index syncs (one per promoted run)');
+    for (const sync of syncs) {
+      const project = PROJECTS.find(p => p.projectId === sync.body.project);
+      assert.ok(project, `sync project ${sync.body.project} is one of ours`);
+      assert.ok(sync.body.sourceDir && PROJECTS.some(p => p.knowledgePath && sync.body.sourceDir.replace(/\//g, '\\').endsWith(path.basename(p.knowledgePath)) || sync.body.sourceDir === p.knowledgePath || p.knowledgePath.endsWith(sync.body.sourceDir.split(/[\\/]/).pop())), 'sync sourceDir belongs to that project');
+    }
+    evidence.phases.crossWriteCheck = {
+      knowledgeTrees: Object.fromEntries(PROJECTS.map(p => [p.projectId, listFilesRecursive(p.knowledgePath)])),
+      syncRequests: syncs.map(s => ({ project: s.body.project, sourceDir: s.body.sourceDir })),
+    };
+
+    evidence.verdict = {
+      'expected1 按当前实际并发上限排队(实际上限=2, 峰值=2, 同项目串行)': 'PASS',
+      'expected2 项目之间无文件串写(知识树/归属/索引请求逐项核对)': 'PASS',
+      analyzerStandin: 'declarative stand-in - real intervals, NO real model output covered',
+      vectorDouble: 'loopback HTTP double - vector-hub itself not covered',
+    };
+    await engine.stop();
+    await vector.close();
+    saveEvidence(ARTIFACTS, 'eng006-evidence.json', evidence);
+    console.log('ENG-006 PASS');
+    process.exitCode = 0;
+  } catch (error) {
+    evidence.verdict = { failed: String(error && error.stack || error) };
+    try { await engine.stop(); } catch {}
+    try { await vector.close(); } catch {}
+    saveEvidence(ARTIFACTS, 'eng006-evidence.json', evidence);
+    console.error(`ENG-006 FAIL: ${error.message}`);
+    process.exitCode = 1;
+  }
+}
+
+main();