@sanqianx/project-knowledge 4.6.1

package/_site/_test/bridge-adapter-test.js

@@ -0,0 +1,95 @@
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { BridgeAdapter } = require('../lib/bridge-adapter');
+const bridgeModule = require('@sanqianx/ai-coding-event-bridge');
+
+(async () => {
+  const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-bridge-adapter-'));
+  const bridgeHome = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-bridge-adapter-home-'));
+
+  // Real facade: the adapter talks to createBridge() only, with an isolated
+  // bridge home — never the user's global spool and never PK's data dir.
+  const adapter = new BridgeAdapter({ dataDir, bridgeModule, bridgeHomeDir: bridgeHome });
+  assert.strictEqual(adapter.isAvailable(), true);
+
+  // v1 identity flows through the adapter into the real journal.
+  const repoTmp = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-bridge-adapter-repo-'));
+  require('child_process').execSync('git init -q', { cwd: repoTmp, stdio: 'ignore' });
+  const identityResult = await adapter.resolveRepoIdentity(repoTmp);
+  assert.strictEqual(identityResult.status, 'ok');
+  assert.strictEqual(identityResult.repoIdentity.schema, 'repo-identity/v1');
+  assert.match(identityResult.repoIdentity.workspaceId, /^sha256:[0-9a-f]{64}$/);
+
+  const baseline = await adapter.getHighWatermark({});
+  assert.deepStrictEqual(baseline, { status: 'captured', cursor: 0 });
+
+  await adapter.registerConsumer('project-knowledge', { notifyUrl: 'http://127.0.0.1:9/bridge' });
+  const consumer = await adapter.getHealth?.();
+  assert.strictEqual(consumer.status, 'ok');
+  assert.ok(consumer.health.consumers.some(entry => entry.name === 'project-knowledge'));
+
+  const result = await adapter.appendCommitBoundary({
+    projectId: 'project-bridge',
+    repoIdentity: identityResult.repoIdentity,
+    commitSha: 'a'.repeat(40),
+    parentShas: ['b'.repeat(40)],
+    branch: 'main',
+    committedAt: '2026-08-18T02:00:00.000Z',
+    operationId: 'op-boundary-test',
+  });
+  assert.strictEqual(result.status, 'captured');
+  assert.strictEqual(result.boundary.bridgeCursorAtCommit, 1);
+  assert.deepStrictEqual(result.boundary.repoIdentity.workspaceId, identityResult.repoIdentity.workspaceId);
+
+  // Consumer APIs through the adapter.
+  await adapter.ackConsumerCursor('project-knowledge', 1);
+  const acked = await adapter.getHealth();
+  assert.strictEqual(acked.health.minConsumerAck, 1);
+  const compacted = await adapter.compact({ throughSequence: 1 });
+  assert.strictEqual(compacted.status, 'ok');
+
+  // The old PK-only { commonDir } shape must produce a deterministic gap,
+  // never a Bridge write.
+  const legacy = await adapter.appendCommitBoundary({
+    projectId: 'project-legacy',
+    repoIdentity: { commonDir: 'D:\\repo\\.git' },
+    commitSha: 'c'.repeat(40),
+    operationId: 'op-legacy-test',
+  });
+  assert.strictEqual(legacy.status, 'unavailable');
+  assert.strictEqual(legacy.gap.reason, 'repo-identity-legacy-shape');
+
+  const missing = await adapter.appendCommitBoundary({
+    projectId: 'project-missing',
+    repoIdentity: null,
+    commitSha: 'd'.repeat(40),
+    operationId: 'op-missing-test',
+  });
+  assert.strictEqual(missing.status, 'unavailable');
+  assert.strictEqual(missing.gap.reason, 'repo-identity-missing');
+
+  // No further journal growth from rejected shapes.
+  const after = await adapter.getHighWatermark({});
+  assert.strictEqual(after.cursor, 1, 'rejected identities must not append journal records');
+
+  const unavailable = new BridgeAdapter({ dataDir, bridgeModule: {} });
+  const gapResult = await unavailable.appendCommitBoundary({
+    projectId: 'project-gap',
+    repoIdentity: null,
+    commitSha: 'e'.repeat(40),
+    operationId: 'op-gap-test',
+  });
+  assert.strictEqual(gapResult.status, 'unavailable');
+  assert.strictEqual(gapResult.gap.reason, 'bridge-unavailable');
+  const gapsPath = path.join(dataDir, 'runtime', 'conversation-capture-gaps.jsonl');
+  const gaps = fs.readFileSync(gapsPath, 'utf8').trim().split(/\r?\n/).map(JSON.parse);
+  assert(gaps.some(gap => gap.commitSha === 'e'.repeat(40) && gap.reason === 'bridge-unavailable'));
+  assert(!JSON.stringify(gaps).includes('prompt'), 'capture gap diagnostics must not contain conversation bodies');
+
+  console.log('bridge-adapter-test PASS');
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+});

package/_site/_test/bridge-consumer-service-test.js

@@ -0,0 +1,310 @@
+// Run: node _site/_test/bridge-consumer-service-test.js
+//
+// T11 core gates: exact workspace matching, unimported skip + ACK,
+// duplicate-notify idempotency, contiguous ACK under forced failure,
+// drainThrough joining, ambiguity stop.
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync } = require('child_process');
+const { StorageLayout } = require('../lib/storage-layout');
+const { ProjectRegistryStore } = require('../lib/project-registry-store');
+const { ProjectStore } = require('../lib/project-store');
+const { ConversationStore } = require('../lib/conversation-store');
+const { BridgeAdapter } = require('../lib/bridge-adapter');
+const { BridgeConsumerService } = require('../lib/bridge-consumer-service');
+const bridgeModule = require('@sanqianx/ai-coding-event-bridge');
+
+const temp = fs.mkdtempSync(path.join(os.tmpdir(), `kb-bridge-consumer-${process.pid}-`));
+const layout = new StorageLayout({ dataDir: path.join(temp, 'data') });
+const registry = new ProjectRegistryStore({ layout });
+const projects = new ProjectStore({ layout });
+const bridgeHome = path.join(temp, 'bridge-home');
+const adapter = new BridgeAdapter({ dataDir: layout.dataDir, bridgeModule, bridgeHomeDir: bridgeHome });
+const store = new ConversationStore({ layout, projectStore: projects, logger: null });
+
+function gitRepo(name) {
+  const dir = path.join(temp, name);
+  fs.mkdirSync(dir, { recursive: true });
+  execSync('git init -q', { cwd: dir, stdio: 'ignore' });
+  return dir;
+}
+
+async function importProject(projectId, repoPath, repoIdentity) {
+  await projects.create(projectId, {
+    storageName: projectId,
+    displayName: projectId,
+    repoPath,
+    knowledgePath: path.join(temp, 'knowledge', projectId),
+    repoIdentity,
+  });
+  await registry.add(projectId, { displayName: projectId });
+}
+
+async function bridgeEvent(eventType, role, content, repoIdentity, sessionId, turnId) {
+  return adapter.bridge.appendConversationEvent({
+    source: 'claude-code', eventType, role, content,
+    sessionId, turnId, repoIdentity,
+  });
+}
+
+(async () => {
+  await registry.initialize();
+  const ccsPath = gitRepo('ccs');
+  const ccbPath = gitRepo('ccb');
+  const ccsIdentity = (await bridgeModule.resolveRepoContext(ccsPath)).repoIdentity;
+  const ccbIdentity = (await bridgeModule.resolveRepoContext(ccbPath)).repoIdentity;
+
+  // Only CCS is imported.
+  await importProject('project-ccs', ccsPath, ccsIdentity);
+
+  const service = new BridgeConsumerService({
+    bridgeAdapter: adapter,
+    conversationStore: store,
+    registryStore: registry,
+    projectStore: projects,
+    logger: null,
+  });
+  const started = await service.start();
+  assert.strictEqual(started.started, true);
+
+  // The notifyUrl passed to start() must land in the registered consumer
+  // meta — connector wake-ups are routed through it. Regression: start(url)
+  // used to ignore its argument, leaving meta {} and drains unnotified.
+  {
+    const registered = await adapter.getConsumer('project-knowledge');
+    assert.strictEqual(registered.consumer.meta.notifyUrl, undefined, 'baseline service registered without notifyUrl');
+    const svc = new BridgeConsumerService({
+      bridgeAdapter: adapter, conversationStore: store, registryStore: registry, projectStore: projects, logger: null,
+    });
+    await svc.start('http://127.0.0.1:5757/api/bridge/notify');
+    const withUrl = await adapter.getConsumer('project-knowledge');
+    assert.strictEqual(withUrl.consumer.meta.notifyUrl, 'http://127.0.0.1:5757/api/bridge/notify', 'start(notifyUrl) wires the wake-up URL into consumer meta');
+  }
+
+  // Phase A: develop in unimported CCB.
+  const ccbUser = await bridgeEvent('user_prompt', 'user', 'Modify CCB parser', ccbIdentity, 'ccb-s1', 'turn-ccb-1');
+  await bridgeEvent('assistant_response', 'assistant', 'CCB parser modified', ccbIdentity, 'ccb-s1', 'turn-ccb-1');
+  const drainA = await service.drain('notify');
+  assert.strictEqual(drainA.stats.skippedUnregistered, 2, 'unimported workspace events are skipped');
+  assert.strictEqual(drainA.stats.persisted, 0);
+  assert.deepStrictEqual(store.readEvents('project-ccs'), [], 'CCS store stays empty');
+  const ccbStoreDir = layout.getProjectConversationEventsPath('project-ccb');
+  assert.ok(!fs.existsSync(path.dirname(ccbStoreDir)), 'no CCB project conversation store is created');
+  const consumerA = await adapter.getConsumer('project-knowledge');
+  assert.strictEqual(consumerA.consumer.ack, ccbUser.sequence + 1, 'consumer ACK advances through skipped CCB events');
+
+  // Phase B: develop in imported CCS.
+  const ccsUser = await bridgeEvent('user_prompt', 'user', 'Modify CCS autofocus', ccsIdentity, 'ccs-s1', 'turn-ccs-1');
+  await bridgeEvent('assistant_response', 'assistant', 'CCS autofocus modified', ccsIdentity, 'ccs-s1', 'turn-ccs-1');
+  await service.drain('notify');
+  const ccsEvents = store.readEvents('project-ccs');
+  assert.strictEqual(ccsEvents.length, 2, 'exactly the CCS turn is projected');
+  assert.ok(ccsEvents.every(event => !event.content.includes('CCB')), 'no CCB content leaked into CCS');
+  assert.strictEqual(ccsEvents[0].eventId, ccsUser.eventId, 'global bridge eventId preserved');
+  assert.strictEqual(ccsEvents[0].sequence, ccsUser.sequence, 'global bridge sequence preserved');
+  assert.strictEqual(ccsEvents[0].turnId, 'turn-ccs-1', 'canonical bridge turnId preserved');
+
+  // Unattributed evidence is never projected into a project.
+  await bridgeEvent('user_prompt', 'user', 'no workspace at all', null, 'lost-s1', 'turn-lost-1');
+  const drainLost = await service.drain('notify');
+  assert.strictEqual(drainLost.stats.skippedNoWorkspace, 1);
+
+  // Duplicate notifications are idempotent.
+  const before = store.readEvents('project-ccs').length;
+  await service.handleNotification();
+  await service.handleNotification();
+  assert.strictEqual(store.readEvents('project-ccs').length, before, 'duplicate wake-ups create no duplicates');
+
+  // drainThrough joins in-flight drains and covers the boundary sequence.
+  const boundaryUser = await bridgeEvent('user_prompt', 'user', 'boundary prompt', ccsIdentity, 'ccs-s2', 'turn-ccs-2');
+  const throughResult = await service.drainThrough(boundaryUser.sequence, 'commit-boundary');
+  assert.strictEqual(throughResult.ack, boundaryUser.sequence);
+  const statusAfter = await service.status();
+  assert.strictEqual(statusAfter.ack, boundaryUser.sequence);
+  assert.strictEqual(statusAfter.consumerRegistered, true);
+  assert.strictEqual(statusAfter.bridgeHealthy, true);
+
+  // Boundaries are facts too: a startup/notify drain persists them without
+  // asking the knowledge analyzer to scan or analyze any commit.
+  const boundaryCommit = 'a'.repeat(40);
+  const capturedBoundary = await adapter.appendCommitBoundary({
+    projectId: 'project-ccs', repoIdentity: ccsIdentity, commitSha: boundaryCommit,
+    parentShas: [], branch: 'main', bridgeCursorAtCommit: boundaryUser.sequence,
+    openTurnIdsAtCommit: ['turn-ccs-2'], operationId: 'op-boundary-consumer',
+  });
+  assert.strictEqual(capturedBoundary.status, 'captured');
+  const boundaryDrain = await service.drainThrough(capturedBoundary.boundary.journalSequence, 'startup');
+  assert.strictEqual(boundaryDrain.stats.boundariesPersisted, 1);
+  assert.strictEqual(store.readBoundary('project-ccs', boundaryCommit).commitSha, boundaryCommit);
+  await service.drain('duplicate-boundary');
+  assert.strictEqual(store.readBoundary('project-ccs', boundaryCommit).commitSha, boundaryCommit, 'duplicate boundary drains are idempotent');
+
+  // Contiguous ACK under forced persist failure (GATE ACK-001 semantics).
+  const failStore = {
+    appendBridgeEvent: async (projectId, record) => {
+      if (record.content === 'fails once') throw new Error('forced persist failure');
+      return { appended: true };
+    },
+  };
+  const failService = new BridgeConsumerService({
+    bridgeAdapter: adapter,
+    conversationStore: failStore,
+    registryStore: registry,
+    projectStore: projects,
+    logger: null,
+    consumerName: 'project-knowledge',
+  });
+  await failService.start();
+  const okSeq = (await bridgeEvent('user_prompt', 'user', 'succeeds', ccsIdentity, 'ccs-s3', 'turn-f1')).sequence;
+  const failSeq = (await bridgeEvent('user_prompt', 'user', 'fails once', ccsIdentity, 'ccs-s3', 'turn-f2')).sequence;
+  const afterSeq = (await bridgeEvent('user_prompt', 'user', 'would succeed', ccsIdentity, 'ccs-s3', 'turn-f3')).sequence;
+  let drainError = null;
+  try {
+    await failService.drain('notify');
+  } catch (error) {
+    drainError = error;
+  }
+  assert.ok(drainError, 'failing sequence must surface an error');
+  const failConsumer = await adapter.getConsumer('project-knowledge');
+  assert.strictEqual(failConsumer.consumer.ack, okSeq, 'ACK stopped exactly at the last contiguous success');
+
+  // After removing the failure, ACK may advance through the rest.
+  const healStore = {
+    appendBridgeEvent: async () => ({ appended: true }),
+  };
+  failService.conversationStore = healStore;
+  const recovered = await failService.drain('retry');
+  assert.strictEqual(recovered.ack, afterSeq, 'recovered drain advances through previously failed sequences');
+  await service.stop();
+
+  // Ambiguous workspace mapping stops ACK and records a gap.
+  await importProject('project-ccs-clone', ccsPath, ccsIdentity);
+  const ambSeq = (await bridgeEvent('user_prompt', 'user', 'ambiguous', ccsIdentity, 'ccs-s4', 'turn-amb')).sequence;
+  let ambiguityError = null;
+  try {
+    await failService.drain('notify');
+  } catch (error) {
+    ambiguityError = error;
+  }
+  assert.ok(ambiguityError && ambiguityError.code === 'PROJECT_AMBIGUOUS', 'ambiguous mapping must stop the drain');
+  const ambConsumer = await adapter.getConsumer('project-knowledge');
+  assert.strictEqual(ambConsumer.consumer.ack, ambSeq - 1, 'ACK never crosses the ambiguous sequence');
+
+  // GATE BASELINE-001 (isolated world: fresh stores + fresh bridge journal).
+  const temp2 = fs.mkdtempSync(path.join(os.tmpdir(), `kb-bridge-consumer-base-${process.pid}-`));
+  const layout2 = new StorageLayout({ dataDir: path.join(temp2, 'data') });
+  const registry2 = new ProjectRegistryStore({ layout: layout2 });
+  const projects2 = new ProjectStore({ layout: layout2 });
+  const adapter2 = new BridgeAdapter({ dataDir: layout2.dataDir, bridgeModule, bridgeHomeDir: path.join(temp2, 'bridge-home') });
+  const store2 = new ConversationStore({ layout: layout2, projectStore: projects2, logger: null });
+  const emit2 = async (eventType, role, content, repoIdentity, sessionId, turnId) =>
+    adapter2.bridge.appendConversationEvent({ source: 'claude-code', eventType, role, content, sessionId, turnId, repoIdentity });
+
+  await registry2.initialize();
+  const basePath = gitRepo('ccs-base');
+  const baseIdentity = (await bridgeModule.resolveRepoContext(basePath)).repoIdentity;
+  const oldUser = await emit2('user_prompt', 'user', 'old pre-import conversation', baseIdentity, 'base-s1', 'turn-base-old');
+  await projects2.create('project-base', {
+    storageName: 'project-base', displayName: 'project-base',
+    repoPath: basePath, knowledgePath: path.join(temp2, 'knowledge', 'project-base'),
+    repoIdentity: baseIdentity,
+  }, { conversationBaselineCursor: oldUser.sequence });
+  await registry2.add('project-base', { displayName: 'project-base' });
+
+  const baseService = new BridgeConsumerService({
+    bridgeAdapter: adapter2,
+    conversationStore: store2,
+    registryStore: registry2,
+    projectStore: projects2,
+    logger: null,
+    consumerName: 'project-knowledge',
+  });
+  const baseStart = await baseService.start();
+  const baseDrain = baseStart.drain && baseStart.drain.stats ? baseStart.drain : await baseService.drain('baseline-check');
+  assert.strictEqual(baseDrain.stats.skippedBelowBaseline >= 1, true, 'pre-baseline events are skipped, not backfilled');
+  assert.deepStrictEqual(store2.readEvents('project-base'), [], 'no pre-import history projected');
+  const newUser = await emit2('user_prompt', 'user', 'fresh post-import conversation', baseIdentity, 'base-s2', 'turn-base-new');
+  await baseService.drain('notify');
+  const baseEvents = store2.readEvents('project-base');
+  assert.strictEqual(baseEvents.length, 1);
+  assert.strictEqual(baseEvents[0].eventId, newUser.eventId, 'post-import events are projected');
+
+  // Offline recovery: project imported without a baseline gets one at the
+  // current watermark on first attachment — still no backfill.
+  const offlinePath = gitRepo('ccs-offline');
+  const offlineIdentity = (await bridgeModule.resolveRepoContext(offlinePath)).repoIdentity;
+  await emit2('user_prompt', 'user', 'history before offline project attached', offlineIdentity, 'off-s0', 'turn-off-old');
+  await projects2.create('project-offline', {
+    storageName: 'project-offline', displayName: 'project-offline',
+    repoPath: offlinePath, knowledgePath: path.join(temp2, 'knowledge', 'project-offline'),
+    repoIdentity: offlineIdentity,
+  }, { conversationBaselineCursor: null });
+  await registry2.add('project-offline', { displayName: 'project-offline' });
+  const attachDrain = await baseService.drain('first-attachment');
+  assert.deepStrictEqual(store2.readEvents('project-offline'), [], 'first attachment establishes baseline without backfilling');
+  const offlineState = projects2.readState('project-offline');
+  assert.ok(Number.isInteger(offlineState.conversationBaselineCursor), 'baseline persisted at attachment-time watermark');
+  await emit2('user_prompt', 'user', 'after offline project attached', offlineIdentity, 'off-s1', 'turn-off-new');
+  await baseService.drain('notify');
+  const offlineEvents = store2.readEvents('project-offline');
+  assert.strictEqual(offlineEvents.length, 1, 'only post-attachment events project');
+  assert.ok(offlineEvents[0].content.includes('after offline project attached'));
+
+  // Legacy upgrade (isolated world): a project imported before v4.2.3 has no
+  // workspaceId in its config. One drain backfills the canonical identity
+  // automatically and the project's conversations start projecting without
+  // any manual step.
+  {
+    const temp3 = fs.mkdtempSync(path.join(os.tmpdir(), `kb-bridge-consumer-legacy-${process.pid}-`));
+    const layout3 = new StorageLayout({ dataDir: path.join(temp3, 'data') });
+    const registry3 = new ProjectRegistryStore({ layout: layout3 });
+    const projects3 = new ProjectStore({ layout: layout3 });
+    const adapter3 = new BridgeAdapter({ dataDir: layout3.dataDir, bridgeModule, bridgeHomeDir: path.join(temp3, 'bridge-home') });
+    const store3 = new ConversationStore({ layout: layout3, projectStore: projects3, logger: null });
+    const emit3 = (eventType, role, content, repoIdentity, sessionId, turnId) =>
+      adapter3.bridge.appendConversationEvent({ source: 'claude-code', eventType, role, content, sessionId, turnId, repoIdentity });
+    await registry3.initialize();
+
+    const legacyPath = gitRepo('ccs-legacy');
+    const legacyIdentity = (await bridgeModule.resolveRepoContext(legacyPath)).repoIdentity;
+    await projects3.create('project-legacy', {
+      storageName: 'project-legacy', displayName: 'project-legacy',
+      repoPath: legacyPath, knowledgePath: path.join(temp3, 'knowledge', 'project-legacy'),
+      repoIdentity: { commonDir: path.join(legacyPath, '.git') }, // pre-v4.2.3 shape
+    }, {});
+    await registry3.add('project-legacy', { displayName: 'project-legacy' });
+    const legacyService = new BridgeConsumerService({
+      bridgeAdapter: adapter3, conversationStore: store3, registryStore: registry3, projectStore: projects3, logger: null,
+    });
+    await legacyService.start();
+    await emit3('user_prompt', 'user', 'legacy project conversation', legacyIdentity, 'legacy-s1', 'turn-legacy-1');
+    await legacyService.drain('legacy-migration');
+    const migratedConfig = projects3.readConfig('project-legacy');
+    assert.strictEqual(migratedConfig.repoIdentity.workspaceId, legacyIdentity.workspaceId, 'identity auto-migrated to v1 on first drain');
+    assert.ok(Number.isInteger(projects3.readState('project-legacy').conversationBaselineCursor), 'baseline established during the same drain');
+    const legacyEvents = store3.readEvents('project-legacy');
+    assert.strictEqual(legacyEvents.length, 1, 'post-migration conversation projected automatically');
+    assert.strictEqual(legacyEvents[0].content, 'legacy project conversation');
+
+    // Collision guard: a second legacy project pointing at the same working
+    // tree must NOT receive the same workspaceId (that would create the
+    // ambiguity the consumer refuses to guess through).
+    await projects3.create('project-legacy-clone', {
+      storageName: 'project-legacy-clone', displayName: 'project-legacy-clone',
+      repoPath: legacyPath, knowledgePath: path.join(temp3, 'knowledge', 'project-legacy-clone'),
+      repoIdentity: null,
+    }, {});
+    await registry3.add('project-legacy-clone', { displayName: 'project-legacy-clone' });
+    await legacyService.drain('legacy-collision');
+    const cloneConfig = projects3.readConfig('project-legacy-clone');
+    assert.ok(!(cloneConfig.repoIdentity && cloneConfig.repoIdentity.workspaceId), 'colliding workspace is never written to a second project');
+  }
+
+  console.log('bridge-consumer-service-test PASS');
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+});

package/_site/_test/cdp-browser-failure-test.js

@@ -0,0 +1,100 @@
+// Regression test for CDP browser launch failures (T00):
+// - browser that exits immediately must fail fast with exit/stderr diagnostics
+// - browser that stays alive but never exposes CDP must hit the launch timeout,
+//   then be killed and cleaned up
+// - in both cases: no child process remains alive, profile dir is removed.
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { isWindowsChromeLauncher, platformLaunchArgs, launchCdpBrowser } = require('./helpers/cdp-browser');
+
+const FIXTURE_EXIT = path.join(__dirname, 'fixtures', 'fake-browser-exit.js');
+const FIXTURE_HANG = path.join(__dirname, 'fixtures', 'fake-browser-hang.js');
+const FAST_FAIL_BUDGET_MS = 5000;
+
+function isPidAlive(pid) {
+  try { process.kill(pid, 0); return true; }
+  catch (error) { return error.code === 'EPERM'; }
+}
+
+async function waitForPidExit(pid, timeoutMs = 8000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isPidAlive(pid)) return false;
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  return isPidAlive(pid);
+}
+
+async function expectLaunchFailure(scenario) {
+  const pidFile = path.join(os.tmpdir(), `pk-cdp-failure-${scenario}-pid-${process.pid}.txt`);
+  const profileDir = path.join(os.tmpdir(), `pk-cdp-failure-${scenario}-profile-${process.pid}`);
+  process.env.KB_FAKE_BROWSER_PIDFILE = pidFile;
+  try {
+    const start = Date.now();
+    let error = null;
+    try {
+      await launchCdpBrowser(scenario.options(profileDir));
+    } catch (caught) {
+      error = caught;
+    }
+    const durationMs = Date.now() - start;
+    assert(error, `${scenario.name}: launchCdpBrowser must reject`);
+    assert(durationMs < FAST_FAIL_BUDGET_MS, `${scenario.name}: must fail fast, took ${durationMs}ms`);
+    const message = error.message;
+    assert(message.includes(process.execPath), `${scenario.name}: error must include executable path, got: ${message}`);
+    assert(message.includes(profileDir), `${scenario.name}: error must include user-data-dir, got: ${message}`);
+    scenario.assertions(message, durationMs);
+    assert(!fs.existsSync(profileDir), `${scenario.name}: profile dir must be cleaned after failed launch`);
+    assert(fs.existsSync(pidFile), `${scenario.name}: fixture pid file missing; cannot verify cleanup`);
+    const pid = Number.parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
+    const stillAlive = await waitForPidExit(pid);
+    assert(!stillAlive, `${scenario.name}: spawned child pid ${pid} still alive after failure cleanup`);
+    return durationMs;
+  } finally {
+    delete process.env.KB_FAKE_BROWSER_PIDFILE;
+    try { fs.rmSync(pidFile, { force: true }); } catch {}
+    try { fs.rmSync(profileDir, { recursive: true, force: true }); } catch {}
+  }
+}
+
+(async () => {
+  assert.strictEqual(isWindowsChromeLauncher('C:/Program Files/Google/Chrome/Application/chrome.exe'), process.platform === 'win32');
+  assert.strictEqual(isWindowsChromeLauncher(process.execPath), false);
+  assert.deepStrictEqual(platformLaunchArgs('linux'), ['--disable-dev-shm-usage', '--no-sandbox']);
+  assert.deepStrictEqual(platformLaunchArgs('win32'), []);
+  const exitDuration = await expectLaunchFailure({
+    name: 'immediate-exit',
+    options: profileDir => ({
+      chrome: process.execPath,
+      prependArgs: [FIXTURE_EXIT],
+      profileDir,
+      url: 'http://127.0.0.1:1/',
+    }),
+    assertions(message) {
+      assert(message.includes('exit code: 3'), `immediate-exit: error must contain exit code, got: ${message}`);
+      assert(message.includes('fake-browser-exit stderr: simulated browser crash before CDP'), `immediate-exit: error must contain stderr tail, got: ${message}`);
+    },
+  });
+  console.log(`cdp-browser immediate-exit failure test PASS (${exitDuration}ms)`);
+
+  const hangDuration = await expectLaunchFailure({
+    name: 'hang-timeout',
+    options: profileDir => ({
+      chrome: process.execPath,
+      prependArgs: [FIXTURE_HANG],
+      profileDir,
+      url: 'http://127.0.0.1:1/',
+      launchTimeoutMs: 1500,
+    }),
+    assertions(message, durationMs) {
+      assert(message.includes('DevToolsActivePort'), `hang-timeout: error must mention DevToolsActivePort wait, got: ${message}`);
+      assert(durationMs < FAST_FAIL_BUDGET_MS, `hang-timeout: bounded duration, took ${durationMs}ms`);
+    },
+  });
+  console.log(`cdp-browser hang-timeout failure test PASS (${hangDuration}ms)`);
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+});

package/_site/_test/chat-claudecodeui-match-test.js

@@ -0,0 +1,92 @@
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-claude-runner-v2-'));
+process.env.KB_DATA_DIR = path.join(temp, 'data');
+require('../lib/data-dir')._resetCache();
+const runner = require('../lib/claude-cli-runner');
+
+(async () => {
+  const projectPath = path.join(temp, 'repo');
+  const kbPath = path.join(temp, 'knowledge');
+  fs.mkdirSync(projectPath, { recursive: true });
+  fs.mkdirSync(kbPath, { recursive: true });
+  const slug = 'chat-runner-v2';
+
+  try {
+    const started = runner.startSession({
+      slug,
+      projectPath,
+      kbPath,
+      promptKey: 'initial-analysis',
+      aiProfile: { id: 'test-profile', implementation: 'claude-code-agent', mainModel: 'test-model' },
+      vars: { SLUG: slug, PROJECT_PATH: projectPath, KNOWLEDGE_LANGUAGE: 'zh-CN' },
+    });
+    assert(started.sessionId);
+
+    const source = fs.readFileSync(path.join(ROOT, '_site', 'lib', 'claude-cli-runner.js'), 'utf8');
+    assert(/normalizePermissionMode\(opts\.permissionMode \|\| session\.permissionMode \|\| 'default'\)/.test(source));
+    assert(/type === 'claude\/usage' && ev\.usage/.test(source));
+    assert(/input_tokens/.test(source) && /output_tokens/.test(source) && /cache_creation_input_tokens/.test(source));
+    assert(/spawnClaude is no longer supported/.test(source));
+    assert(/type:\s*'claude\/retry'/.test(source) && /maxSdkRetries\(\)/.test(source));
+
+    const fresh = runner.getSessionTokenUsage(started.sessionId);
+    assert.strictEqual(fresh.used, 0);
+    assert.strictEqual(fresh.hasUsage, false);
+    assert(fresh.total > 0);
+
+    const liveSession = runner.getSession(started.sessionId);
+    liveSession.contextWindow = 1048576;
+    assert.strictEqual(runner.getSessionTokenUsage(started.sessionId).total, 1048576);
+    liveSession.contextWindow = null;
+    assert.strictEqual(runner.getSessionTokenUsage(started.sessionId).total, 200000);
+
+    const overrides = runner.buildSdkOverridesFromProfile({});
+    assert(overrides.systemPrompt && overrides.systemPrompt.preset === 'claude_code');
+    const env = runner.buildClaudeEnvFromProfile({
+      apiKey: 'sk-plaintext',
+      baseUrl: 'https://example.test/anthropic',
+      mainModel: 'main',
+      thinkingModel: 'think',
+      haikuModel: 'hk',
+      sonnetModel: 'sn',
+      opusModel: 'op',
+      timeoutMs: 1234,
+    });
+    assert.strictEqual(env.ANTHROPIC_AUTH_TOKEN, 'sk-plaintext');
+    assert.strictEqual(env.ANTHROPIC_MODEL, 'main');
+    assert.strictEqual(env.ANTHROPIC_DEFAULT_HAIKU_MODEL, 'hk');
+    assert.strictEqual(env.ANTHROPIC_DEFAULT_SONNET_MODEL, 'sn');
+    assert.strictEqual(env.ANTHROPIC_DEFAULT_OPUS_MODEL, 'op');
+    assert.strictEqual(env.ANTHROPIC_DEFAULT_THINKING_MODEL, 'think');
+    assert.strictEqual(env.API_TIMEOUT_MS, '1234');
+    assert.strictEqual(env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC, '1');
+    assert(runner.isTransientClaudeError(new Error('429 too many requests')));
+    assert(!runner.isTransientClaudeError(new Error('model does not exist')));
+
+    const server = fs.readFileSync(path.join(ROOT, '_site', 'lib', 'server-app.js'), 'utf8');
+    assert(server.includes('body.permissionMode'));
+
+    const html = fs.readFileSync(path.join(ROOT, 'ui', 'index.html'), 'utf8');
+    const app = fs.readFileSync(path.join(ROOT, 'ui', 'app.js'), 'utf8');
+    // T2: 内嵌终端取代旧 workbench 聊天面板 —— 壳经 kb:* 协议与会话/事件交互
+    assert(html.includes('id="view-terminal"') && html.includes('id="fr-5760"'));
+    assert(html.includes('id="view-search"') && html.includes('id="fr-8787"'));
+    assert(app.includes("'kb:select-project'") && app.includes("'kb:list-sessions'") && app.includes("'kb:open-session'"));
+    assert(app.includes("'kb:sidebar'"), 'embed protocol wiring must cover fold');
+    // 会话生命周期（archive/restore）只属于 terminal 模块，壳保持只读投影
+    assert(!app.includes("'kb:archive-session'") && !app.includes("'kb:restore-session'"), 'session lifecycle wiring must stay terminal-module-only');
+
+    runner.deleteSession(started.sessionId);
+    console.log('chat runner contract test PASS');
+  } finally {
+    try { fs.rmSync(temp, { recursive: true, force: true }); } catch {}
+  }
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+});