@sanqianx/project-knowledge 4.6.1

package/_site/_test/client-capture-restart-e2e-test.js

@@ -0,0 +1,189 @@
+// Run: node _site/_test/client-capture-restart-e2e-test.js
+//
+// T21 gates: OpenCode + Claude Code + Codex external sessions are captured into the
+// imported project's Development Conversation; Project-Knowledge offline
+// accumulation is recovered by the startup drain in order without
+// duplicates; fake/duplicate notifications never fabricate events.
+
+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 { readDevelopmentEvents } = require('../lib/conversation-exclusions');
+const bridgePackage = require('@sanqianx/ai-coding-event-bridge');
+const opencodeEntry = require('@sanqianx/ai-coding-event-bridge/src/connectors/opencode/hook-entry');
+const claudeEntry = require('@sanqianx/ai-coding-event-bridge/src/connectors/claude-code/hook-entry');
+const codexEntry = require('@sanqianx/ai-coding-event-bridge/src/connectors/codex/hook-entry');
+
+const temp = fs.mkdtempSync(path.join(os.tmpdir(), `kb-client-e2e-${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: bridgePackage, bridgeHomeDir: bridgeHome });
+const store = new ConversationStore({ layout, projectStore: projects, logger: null });
+
+const ccs = path.join(temp, 'CCS');
+fs.mkdirSync(ccs, { recursive: true });
+execSync('git init -q', { cwd: ccs, stdio: 'ignore' });
+execSync('git config user.email e@example.test && git config user.name E', { cwd: ccs, shell: true, stdio: 'ignore' });
+fs.writeFileSync(path.join(ccs, 'README.md'), '# ccs\n');
+execSync('git add . && git commit -q -m init', { cwd: ccs, shell: true, stdio: 'ignore' });
+
+const sessionsRoot = path.join(temp, 'codex-sessions');
+fs.mkdirSync(sessionsRoot, { recursive: true });
+
+function codexSessionFile(sessionId, cwd, turns, { day = '20', suffix = '' } = {}) {
+  const dir = path.join(sessionsRoot, '2026', '08', day);
+  fs.mkdirSync(dir, { recursive: true });
+  const lines = [JSON.stringify({ type: 'session_meta', payload: { cwd } })];
+  for (const turn of turns) {
+    lines.push(JSON.stringify({
+      type: 'response_item',
+      payload: {
+        type: 'message',
+        role: turn.role,
+        phase: turn.phase,
+        internal_chat_message_metadata_passthrough: { turn_id: turn.turnId },
+        content: [{ type: turn.role === 'user' ? 'input_text' : 'output_text', text: turn.text }],
+      },
+    }));
+  }
+  const file = path.join(dir, `rollout-2026-08-${day}T00-00-00-${sessionId}${suffix ? `_${suffix}` : ''}.jsonl`);
+  fs.writeFileSync(file, `${lines.join('\n')}\n`);
+  return file;
+}
+
+async function main() {
+  await registry.initialize();
+  const identity = (await bridgePackage.resolveRepoContext(ccs)).repoIdentity;
+  const watermark = await adapter.getHighWatermark({});
+  await projects.create('project-ccs', {
+    storageName: 'project-ccs', displayName: 'project-ccs',
+    repoPath: ccs, knowledgePath: path.join(temp, 'knowledge', 'project-ccs'),
+    repoIdentity: identity,
+  }, { conversationBaselineCursor: watermark.cursor });
+  await registry.add('project-ccs', { displayName: 'project-ccs' });
+
+  // OpenCode external session without client turnIds (GATE CLIENT-OPENCODE-001).
+  const ocUser = await opencodeEntry.main({ home: bridgeHome, payload: { type: 'user', sessionId: 'oc-s1', cwd: ccs, text: 'OpenCode prompt in CCS' } });
+  const ocAssistant = await opencodeEntry.main({ home: bridgeHome, payload: { type: 'assistant', sessionId: 'oc-s1', cwd: ccs, text: 'OpenCode reply in CCS' } });
+  assert.match(ocUser.turnId, /^turn_/, 'Bridge mints the user turnId');
+  assert.strictEqual(ocAssistant.turnId, ocUser.turnId, 'assistant binds to the same durable turn');
+
+  // Claude Code real hook payload names and durable prompt/Stop pairing
+  // (GATE CLIENT-CLAUDE-001).
+  const claudeUser = await claudeEntry.main({ home: bridgeHome, payload: {
+    hook_event_name: 'UserPromptSubmit', session_id: 'claude-s1', cwd: ccs, prompt: 'Claude prompt in CCS',
+  } });
+  const claudeAssistant = await claudeEntry.main({ home: bridgeHome, payload: {
+    hook_event_name: 'Stop', session_id: 'claude-s1', cwd: ccs, last_assistant_message: 'Claude reply in CCS',
+  } });
+  assert.strictEqual(claudeAssistant.turnId, claudeUser.turnId, 'Claude Stop closes the submitted prompt turn');
+
+  // Codex external session driven by authoritative session_meta cwd and the
+  // real nested turn id. Simulate an installed Bridge 0.1.1 cursor pinned to
+  // the first rollout, then discover and recover its continuation (GATE
+  // CLIENT-CODEX-001 / CODEX-CURSOR-MIGRATION-001).
+  const codexFirst = codexSessionFile('codex-s1', ccs, [
+    { role: 'user', turnId: 'codex-turn-1', text: '<environment_context>generated transport context</environment_context>' },
+    { role: 'user', turnId: 'codex-turn-1', text: 'Codex prompt in CCS' },
+    { role: 'assistant', turnId: 'codex-turn-1', phase: 'commentary', text: 'Codex working in CCS' },
+  ]);
+  const codexFirstResult = await codexEntry.main({ home: bridgeHome, payload: { session_id: 'codex-s1', sessions_root: sessionsRoot } });
+  assert.strictEqual(codexFirstResult.status, 'captured');
+  assert.strictEqual(codexFirstResult.captured, 3);
+  const codexCursorFile = path.join(bridgeHome, 'cursors', 'codex', 'codex-s1.json');
+  const codexCursorV2 = JSON.parse(fs.readFileSync(codexCursorFile, 'utf8'));
+  const firstFileCursor = Object.values(codexCursorV2.files)[0];
+  fs.writeFileSync(codexCursorFile, JSON.stringify({
+    sessionId: 'codex-s1',
+    filePath: codexFirst,
+    byteOffset: firstFileCursor.byteOffset,
+    lastRecordKey: firstFileCursor.lastRecordKey,
+    activeCwd: firstFileCursor.activeCwd,
+    repoIdentity: firstFileCursor.repoIdentity,
+    projectPath: firstFileCursor.projectPath,
+    branch: firstFileCursor.branch,
+    headAtCapture: firstFileCursor.headAtCapture,
+  }));
+  codexSessionFile('codex-s1', ccs, [
+    { role: 'assistant', turnId: 'codex-turn-1', phase: 'final_answer', text: 'Codex reply in CCS' },
+  ], { day: '21', suffix: 'continuation' });
+  const codexResult = await codexEntry.main({ home: bridgeHome, payload: { session_id: 'codex-s1', sessions_root: sessionsRoot } });
+  assert.strictEqual(codexResult.captured, 1, 'continuation captured without replaying the first rollout');
+  assert.strictEqual(codexResult.files, 2);
+  const migratedCursor = JSON.parse(fs.readFileSync(codexCursorFile, 'utf8'));
+  assert.strictEqual(migratedCursor.schema, 'codex-cursor/v2');
+  assert.strictEqual(Object.keys(migratedCursor.files).length, 2);
+
+  // OFFLINE-001: the consumer process was "stopped" while the events above
+  // accumulated; a fresh service instance (restart) recovers everything from
+  // the durable journal — in order, once, with no notification dependency.
+  const restarted = new BridgeConsumerService({
+    bridgeAdapter: adapter, conversationStore: store, registryStore: registry, projectStore: projects, logger: null,
+  });
+  await restarted.start();
+  const rawEvents = store.readEvents('project-ccs');
+  assert.strictEqual(rawEvents.length, 8, 'startup drain recovered every durable external record');
+  const events = readDevelopmentEvents(store, 'project-ccs');
+  assert.strictEqual(events.length, 7, 'generated Codex context is excluded from Development Conversation');
+  assert.deepStrictEqual(
+    events.map(event => event.sequence).sort((a, b) => a - b),
+    [...events.map(event => event.sequence)].sort((a, b) => a - b),
+  );
+  const ocEvents = events.filter(event => event.source === 'opencode');
+  assert.strictEqual(ocEvents.length, 2);
+  assert.strictEqual(ocEvents[0].turnId, ocEvents[1].turnId, 'OpenCode turn grouped durably');
+  const claudeEvents = events.filter(event => event.source === 'claude-code');
+  assert.strictEqual(claudeEvents.length, 2);
+  assert.strictEqual(claudeEvents[0].turnId, claudeEvents[1].turnId, 'Claude Code turn grouped durably');
+  const codexEvents = events.filter(event => event.source === 'codex');
+  assert.strictEqual(codexEvents.length, 3);
+  assert.ok(codexEvents.every(event => event.repoIdentity.workspaceId === identity.workspaceId),
+    'Codex events attributed from session_meta.cwd, not the session file location');
+  assert.ok(codexEvents.every(event => event.turnId === 'codex-turn-1'), 'all Codex phases share the real turn identity');
+  assert.strictEqual(new Set(events.map(event => event.eventId)).size, 7, 'no duplicates after recovery');
+
+  // NOTIFY-001: fake/duplicate notifications with garbage bodies never
+  // fabricate journal events; the consumer only drains the durable journal.
+  const beforeNotify = store.readEvents('project-ccs').length;
+  await restarted.handleNotification();
+  await restarted.handleNotification();
+  assert.strictEqual(store.readEvents('project-ccs').length, beforeNotify, 'duplicate wake-ups are idempotent');
+
+  // Duplicate physical events (re-fired connector payload with same eventKey
+  // semantics) do not double-project: re-running the Codex notify with no new
+  // bytes captures nothing.
+  const codexAgain = await codexEntry.main({ home: bridgeHome, payload: { session_id: 'codex-s1', sessions_root: sessionsRoot } });
+  assert.strictEqual(codexAgain.captured, 0, 'cursor-based idempotency');
+  await restarted.drain('notify');
+  assert.strictEqual(store.readEvents('project-ccs').length, beforeNotify, 'no event loss or duplication from replayed notifies');
+
+  // Capture-disable: an internal-marked session never reaches the store.
+  const previousCapture = process.env.AI_CODING_EVENT_BRIDGE_CAPTURE;
+  process.env.AI_CODING_EVENT_BRIDGE_CAPTURE = '0';
+  try {
+    const disabled = await opencodeEntry.main({ home: bridgeHome, payload: { type: 'user', sessionId: 'oc-internal', cwd: ccs, text: 'internal session' } });
+    assert.deepStrictEqual(disabled, { status: 'ignored', reason: 'capture-disabled' });
+  } finally {
+    if (previousCapture === undefined) delete process.env.AI_CODING_EVENT_BRIDGE_CAPTURE;
+    else process.env.AI_CODING_EVENT_BRIDGE_CAPTURE = previousCapture;
+  }
+  await restarted.drain('notify');
+  assert.strictEqual(store.readEvents('project-ccs').length, beforeNotify, 'internal sessions add zero Development Conversation events');
+
+  console.log('client-capture-restart-e2e-test PASS');
+}
+
+main().catch(error => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+});

package/_site/_test/codex-conversation-projection-test.js

@@ -0,0 +1,59 @@
+// Run: node _site/_test/codex-conversation-projection-test.js
+//
+// Codex Bridge 0.1.1 compatibility: generated rollout context is excluded,
+// orphan assistant records are projected onto the latest real user turn, and
+// raw append-only events are never rewritten.
+
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const {
+  computeConversationExclusions,
+  projectCodexTurns,
+} = require('../lib/conversation-exclusions');
+
+const projectId = 'project-codex-projection';
+const sessionId = 'codex-session';
+const base = {
+  source: 'codex',
+  sessionId,
+  rawEventType: 'response_item',
+  capturedAt: '2026-08-24T16:06:00.000Z',
+};
+const event = input => ({ ...base, ...input });
+const context = event({
+  eventId: 'context', sequence: 1, role: 'user', turnId: 'generated-context',
+  content: '<recommended_plugins>generated</recommended_plugins>\n<environment_context>generated</environment_context>',
+});
+const user = event({ eventId: 'user', sequence: 2, role: 'user', turnId: 'turn-user', content: 'hello' });
+const commentary = event({ eventId: 'assistant-1', sequence: 3, role: 'assistant', turnId: null, content: 'Working.' });
+const finalReply = event({ eventId: 'assistant-2', sequence: 4, role: 'assistant', turnId: null, content: 'Done.' });
+const nextUser = event({ eventId: 'next-user', sequence: 5, role: 'user', turnId: 'turn-next', content: 'Next request.' });
+const aborted = event({
+  eventId: 'aborted', sequence: 6, role: 'user', turnId: 'generated-abort',
+  content: '<turn_aborted>\nThe user interrupted the previous turn.\n</turn_aborted>',
+});
+const orphan = event({ eventId: 'orphan', sequence: 7, role: 'assistant', turnId: null, sessionId: 'other-session', content: 'No known user.' });
+const raw = [orphan, aborted, finalReply, nextUser, context, commentary, user];
+const before = JSON.stringify(raw);
+
+const manifest = computeConversationExclusions(projectId, raw);
+assert.deepStrictEqual(manifest.excludedEventIds, ['aborted', 'context']);
+
+const projected = projectCodexTurns(raw, manifest.excludedEventIds);
+assert.deepStrictEqual(projected.map(item => item.eventId), ['user', 'assistant-1', 'assistant-2', 'next-user', 'orphan']);
+assert.deepStrictEqual(
+  projected.filter(item => item.eventId.startsWith('assistant-')).map(item => item.turnId),
+  ['turn-user', 'turn-user'],
+  'all Codex assistant messages in the turn must pair with its real user prompt',
+);
+assert.strictEqual(projected.find(item => item.eventId === 'user').developmentTurnClosedAtSequence, 5);
+assert.strictEqual(projected.find(item => item.eventId === 'next-user').developmentTurnClosedAtSequence, 6);
+assert.strictEqual(projected.find(item => item.eventId === 'orphan').turnId, null, 'never pair across Codex sessions');
+assert.strictEqual(JSON.stringify(raw), before, 'projection must not rewrite durable source events');
+
+const uiSource = fs.readFileSync(path.resolve(__dirname, '..', '..', 'ui', 'app.js'), 'utf8');
+assert(!uiSource.includes('（无用户文本）'), 'UI must not invent a user message for an assistant-only record');
+assert(!uiSource.includes('（尚无回复）'), 'UI must not invent an assistant reply for an incomplete turn');
+
+console.log('codex-conversation-projection-test PASS');

package/_site/_test/codex-notify-fanout-test.js

@@ -0,0 +1,45 @@
+// Run: node _site/_test/codex-notify-fanout-test.js
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const TEMP = fs.mkdtempSync(path.join(os.tmpdir(), `pk-codex-fanout-${process.pid}-`));
+const receiver = path.join(TEMP, 'receiver.cjs');
+const nextOutput = path.join(TEMP, 'next.json');
+const bridgeOutput = path.join(TEMP, 'bridge.json');
+
+fs.writeFileSync(receiver, "let data=''; process.stdin.on('data', chunk => data += chunk); process.stdin.on('end', () => require('fs').writeFileSync(process.argv[2], data));", 'utf8');
+
+function encoded(output) {
+  return Buffer.from(JSON.stringify([process.execPath, receiver, output])).toString('base64');
+}
+
+async function waitFor(file) {
+  for (let attempt = 0; attempt < 100; attempt += 1) {
+    if (fs.existsSync(file)) return;
+    await new Promise(resolve => setTimeout(resolve, 20));
+  }
+  throw new Error(`timed out waiting for ${path.basename(file)}`);
+}
+
+(async () => {
+  const payload = JSON.stringify({ session_id: 'codex-session-test', type: 'turn-ended' });
+  const result = spawnSync(process.execPath, [
+    path.join(ROOT, '_site', 'scripts', 'codex-notify-fanout.cjs'),
+    '--next-base64', encoded(nextOutput),
+    '--bridge-base64', encoded(bridgeOutput),
+  ], { input: payload, encoding: 'utf8', windowsHide: true });
+  assert.strictEqual(result.status, 0, result.stderr || 'fan-out process should succeed');
+  await Promise.all([waitFor(nextOutput), waitFor(bridgeOutput)]);
+  assert.strictEqual(fs.readFileSync(nextOutput, 'utf8'), payload, 'existing notifier must receive the original Codex payload');
+  assert.strictEqual(fs.readFileSync(bridgeOutput, 'utf8'), payload, 'Bridge must receive the same Codex payload');
+  console.log('codex-notify-fanout-test PASS');
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+}).finally(() => {
+  fs.rmSync(TEMP, { recursive: true, force: true });
+});

package/_site/_test/commit-boundary-freeze-test.js

@@ -0,0 +1,147 @@
+// Run: node _site/_test/commit-boundary-freeze-test.js
+//
+// T13 gates: frozen snapshots never contain events beyond the commit
+// boundary (I-13), same-workspace-only binding, legacy confidence
+// translation, and idempotent freeze.
+
+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 { CommitConversationBinder } = require('../lib/commit-conversation-binder');
+const bridgeModule = require('@sanqianx/ai-coding-event-bridge');
+
+const temp = fs.mkdtempSync(path.join(os.tmpdir(), `kb-boundary-freeze-${process.pid}-`));
+const layout = new StorageLayout({ dataDir: path.join(temp, 'data') });
+const registry = new ProjectRegistryStore({ layout });
+const projects = new ProjectStore({ layout });
+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;
+}
+
+function bridgeRecord(sequence, eventType, role, content, repoIdentity, turnId, confidence) {
+  return {
+    schema: 'ai-coding-event/v1',
+    eventId: `evt-${sequence}`,
+    sequence,
+    source: 'claude-code',
+    eventType,
+    role,
+    content,
+    sessionId: 's-boundary',
+    turnId,
+    repoIdentity,
+    identityConfidence: confidence || 'exact',
+    captureStatus: 'complete',
+    capturedAt: new Date().toISOString(),
+  };
+}
+
+(async () => {
+  await registry.initialize();
+  const ccsPath = gitRepo('ccs');
+  const ccbPath = gitRepo('ccb');
+  const ccs = (await bridgeModule.resolveRepoContext(ccsPath)).repoIdentity;
+  const ccb = (await bridgeModule.resolveRepoContext(ccbPath)).repoIdentity;
+  const projectId = 'project-freeze';
+  await projects.create(projectId, {
+    storageName: projectId,
+    displayName: projectId,
+    repoPath: ccsPath,
+    knowledgePath: path.join(temp, 'knowledge', projectId),
+    repoIdentity: ccs,
+  }, { conversationBaselineCursor: 99 });
+  await registry.add(projectId, { displayName: projectId });
+
+  const binder = new CommitConversationBinder({ layout, projectStore: projects, conversationStore: store, logger: null });
+
+  const boundary = (commitSha, cursor, openTurnIds) => store.writeBoundary(projectId, {
+    repoIdentity: ccs,
+    commitSha,
+    parentShas: [],
+    branch: 'main',
+    committedAt: new Date().toISOString(),
+    bridgeCursorAtCommit: cursor,
+    openTurnIdsAtCommit: openTurnIds || [],
+    operationId: `op-${cursor}`,
+    journalSequence: cursor,
+  });
+
+  // BOUNDARY-001: user(100), boundary(101), assistant(102) created later.
+  await store.appendBridgeEvent(projectId, bridgeRecord(100, 'user_prompt', 'user', 'prompt before boundary', ccs, 'turn-1'));
+  await store.appendBridgeEvent(projectId, bridgeRecord(102, 'assistant_response', 'assistant', 'reply after boundary', ccs, 'turn-1'));
+  boundary('a'.repeat(40), 101, []);
+  const snapshotA = await binder.bind({ projectId, commitSha: 'a'.repeat(40) });
+  assert.strictEqual(snapshotA.status, 'available');
+  assert.strictEqual(snapshotA.turns.length, 1);
+  assert.strictEqual(snapshotA.turns[0].turnId, 'turn-1');
+  assert.ok(snapshotA.turns[0].userEvents.some(event => event.sequence === 100), 'user event inside window is bound');
+  assert.strictEqual(snapshotA.turns[0].assistantEvents.length, 0, 'assistant beyond boundaryEndCursor must never enter the frozen snapshot');
+
+  // BOUNDARY-002: user(200), assistant(201) before boundary(202).
+  await store.appendBridgeEvent(projectId, bridgeRecord(200, 'user_prompt', 'user', 'second prompt', ccs, 'turn-2'));
+  await store.appendBridgeEvent(projectId, bridgeRecord(201, 'assistant_response', 'assistant', 'reply before boundary', ccs, 'turn-2'));
+  boundary('b'.repeat(40), 202, []);
+  const snapshotB = await binder.bind({ projectId, commitSha: 'b'.repeat(40) });
+  assert.ok(snapshotB.turns.some(turn => turn.turnId === 'turn-2'
+    && turn.assistantEvents.some(event => event.sequence === 201)), 'assistant before boundary may enter');
+  assert.ok(!snapshotB.turns.some(turn => turn.turnId === 'turn-1'), 'already-bound turn is not re-selected in the next window');
+
+  // Cross-repo: CCB event right before a CCS commit is never substituted.
+  // The consumer would never project a CCB event into the CCS store at all
+  // (appendBridgeEvent rejects it); raw appendEvent simulates legacy stored
+  // data so the binder's workspace filter is exercised directly.
+  {
+    const rejected = await store.appendBridgeEvent(projectId, bridgeRecord(299, 'user_prompt', 'user', 'blocked at the door', ccb, 'turn-ccb-blocked')).catch(error => error);
+    assert.ok(rejected instanceof Error && rejected.code === 'DATA_CORRUPT', 'appendBridgeEvent rejects foreign-workspace events');
+  }
+  await store.appendEvent(projectId, {
+    eventId: 'evt-300',
+    sequence: 300,
+    source: 'claude-code',
+    eventType: 'user_prompt',
+    role: 'user',
+    content: 'Modify CCB parser',
+    sessionId: 's-boundary',
+    turnId: 'turn-ccb',
+    repoIdentity: ccb,
+    identityConfidence: 'exact',
+    captureStatus: 'complete',
+    capturedAt: new Date().toISOString(),
+  });
+  boundary('c'.repeat(40), 301, []);
+  const snapshotC = await binder.bind({ projectId, commitSha: 'c'.repeat(40) });
+  assert.strictEqual(snapshotC.status, 'no-new-user-prompt', 'no CCS conversation yields a deterministic empty status');
+  assert.ok(!JSON.stringify(snapshotC).includes('Modify CCB parser'), 'CCB conversation must not leak into a CCS snapshot');
+
+  // Legacy confidence translation: stored 'high' behaves as exact.
+  await store.appendBridgeEvent(projectId, bridgeRecord(400, 'user_prompt', 'user', 'legacy confidence prompt', ccs, 'turn-3', 'high'));
+  boundary('d'.repeat(40), 401, []);
+  const snapshotD = await binder.bind({ projectId, commitSha: 'd'.repeat(40) });
+  assert.ok(snapshotD.turns.some(turn => turn.turnId === 'turn-3'), 'legacy high/trusted translates to exact for old stored data');
+
+  // Partial confidence never binds as direct evidence.
+  await store.appendBridgeEvent(projectId, bridgeRecord(500, 'user_prompt', 'user', 'partial identity prompt', ccs, 'turn-4', 'partial'));
+  boundary('e'.repeat(40), 501, []);
+  const snapshotE = await binder.bind({ projectId, commitSha: 'e'.repeat(40) });
+  assert.ok(!snapshotE.turns.some(turn => turn.turnId === 'turn-4'), 'partial identity is ambiguous, never direct evidence');
+
+  // Immutable freeze: rebinding returns the identical hash.
+  const rebound = await binder.bind({ projectId, commitSha: 'a'.repeat(40) });
+  assert.strictEqual(rebound.snapshotHash, snapshotA.snapshotHash, 'frozen snapshots are never rewritten');
+
+  console.log('commit-boundary-freeze-test PASS');
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+});

package/_site/_test/commit-conversation-binding-test.js

@@ -0,0 +1,99 @@
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { StorageLayout } = require('../lib/storage-layout');
+const { ProjectStore } = require('../lib/project-store');
+const { ConversationStore } = require('../lib/conversation-store');
+const { CommitConversationBinder } = require('../lib/commit-conversation-binder');
+
+(async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-conversation-binding-'));
+  const layout = new StorageLayout({ dataDir: path.join(root, 'data') });
+  const projectStore = new ProjectStore({ layout });
+  const projectId = 'project-binding';
+  const repoIdentity = { commonDir: path.join(root, 'repo', '.git') };
+  await projectStore.create(projectId, {
+    displayName: 'Binding',
+    storageName: 'binding',
+    repoPath: path.join(root, 'repo'),
+    knowledgePath: path.join(root, 'knowledge'),
+    repoIdentity,
+  }, { conversationBaselineCursor: 0, conversation: { lastConsumedCursor: 0, captureStatus: 'captured' } });
+  const store = new ConversationStore({ layout, projectStore });
+  const binder = new CommitConversationBinder({ layout, projectStore, conversationStore: store });
+  const c1 = '1'.repeat(40);
+  const c2 = '2'.repeat(40);
+  const c3 = '3'.repeat(40);
+  const cMerge = '4'.repeat(40);
+  const cAmbiguous = '5'.repeat(40);
+
+  const append = input => store.appendEvent(projectId, {
+    source: 'codex',
+    sessionId: 'session-1',
+    projectPath: path.join(root, 'repo'),
+    repoIdentity,
+    branch: 'main',
+    headAtCapture: '0'.repeat(40),
+    capturedAt: `2026-08-18T02:${String(input.sequence || 0).padStart(2, '0')}:00.000Z`,
+    rawEventType: input.eventType,
+    identityConfidence: 'high',
+    captureStatus: 'captured',
+    ...input,
+  });
+  await append({ eventId: 'r1', sequence: 1, eventType: 'user_prompt', role: 'user', content: 'Requirement before C1.', turnId: 'turn-1' });
+  const boundaryC1 = { commitSha: c1, repoIdentity, parentShas: [], branch: 'main', committedAt: '2026-08-18T02:02:00.000Z', bridgeCursorAtCommit: 2, journalSequence: 2, openTurnIdsAtCommit: ['turn-1'], operationId: 'op-c1' };
+  store.writeBoundary(projectId, boundaryC1);
+  assert.strictEqual(store.writeBoundary(projectId, boundaryC1).commitSha, c1, 'identical bridge/hook boundary is idempotent');
+  assert.throws(() => store.writeBoundary(projectId, { ...boundaryC1, branch: 'other' }), error => error.code === 'DATA_CORRUPT');
+  await append({ eventId: 'a1', sequence: 3, eventType: 'assistant_response', role: 'assistant', content: 'Late assistant before claim.', turnId: 'turn-1' });
+  await append({ eventId: 'r2', sequence: 4, eventType: 'user_prompt', role: 'user', content: 'Requirement after C1.', turnId: 'turn-2', headAtCapture: c1 });
+
+  const frozenC1 = await binder.bind({ projectId, commitSha: c1 });
+  assert.strictEqual(frozenC1.status, 'available');
+  assert.deepStrictEqual(frozenC1.turns.map(turn => turn.turnId), ['turn-1'], 'future R2 must never bind back to C1');
+  assert.deepStrictEqual(frozenC1.turns[0].assistantEvents.map(event => event.eventId), [], 'assistant beyond boundaryEndCursor must never enter the frozen snapshot (I-13)');
+  assert.strictEqual(frozenC1.excludedFuturePromptCount, 1);
+  const frozenHash = frozenC1.snapshotHash;
+  await append({ eventId: 'a1-after-claim', sequence: 6, eventType: 'assistant_response', role: 'assistant', content: 'Assistant arrived after Claim.', turnId: 'turn-1' });
+  const retriedC1 = await binder.bind({ projectId, commitSha: c1 });
+  assert.strictEqual(retriedC1.snapshotHash, frozenHash, 'retry must reuse the exact Claim-time conversation freeze');
+  assert.deepStrictEqual(retriedC1.turns[0].assistantEvents.map(event => event.eventId), [], 'delayed binder execution must not pull post-commit replies into the old snapshot');
+
+  store.writeBoundary(projectId, { commitSha: c2, repoIdentity, parentShas: [c1], branch: 'main', committedAt: '2026-08-18T02:05:00.000Z', bridgeCursorAtCommit: 5, journalSequence: 5, openTurnIdsAtCommit: ['turn-1'], operationId: 'op-c2' });
+  const frozenC2 = await binder.bind({ projectId, commitSha: c2 });
+  assert.deepStrictEqual(frozenC2.turns.map(turn => [turn.turnId, turn.bindingKind]), [['turn-1', 'shared-spanning'], ['turn-2', 'direct']]);
+  assert.deepStrictEqual(frozenC2.turns[0].assistantEvents.map(event => event.eventId), ['a1'], 'the assistant reply inside the C2 window belongs to the spanning turn');
+  assert.strictEqual(frozenC2.turns[0].turnId, frozenC1.turns[0].turnId, 'spanning turns must retain one stable identity across commits');
+
+  store.writeBoundary(projectId, { commitSha: c3, repoIdentity, parentShas: [c2], branch: 'main', committedAt: '2026-08-18T02:07:00.000Z', bridgeCursorAtCommit: 7, journalSequence: 7, openTurnIdsAtCommit: ['turn-1'], operationId: 'op-c3' });
+  const frozenC3 = await binder.bind({ projectId, commitSha: c3 });
+  assert.strictEqual(frozenC3.status, 'no-new-user-prompt');
+  assert.deepStrictEqual(frozenC3.turns, [], 'a stale Bridge open-turn id must not copy a closed requirement into a later commit');
+
+  await append({ eventId: 'r-merge', sequence: 8, eventType: 'user_prompt', role: 'user', content: 'Merge-window requirement.', turnId: 'turn-merge' });
+  store.writeBoundary(projectId, { commitSha: cMerge, repoIdentity, parentShas: [c1, c2], branch: 'main', committedAt: '2026-08-18T02:10:00.000Z', bridgeCursorAtCommit: 10, journalSequence: 10, openTurnIdsAtCommit: [], operationId: 'op-merge' });
+  const mergeSnapshot = await binder.bind({ projectId, commitSha: cMerge });
+  assert.strictEqual(mergeSnapshot.boundaryStartCursor, 7, 'merge window must use previous durable repo boundary, not an arbitrary Git parent');
+  assert.deepStrictEqual(mergeSnapshot.turns.map(turn => turn.turnId), ['turn-merge']);
+
+  await append({ eventId: 'r-ambiguous', sequence: 11, eventType: 'user_prompt', role: 'user', content: 'Identity unavailable.', turnId: null, repoIdentity: null, identityConfidence: 'unknown' });
+  store.writeBoundary(projectId, { commitSha: cAmbiguous, repoIdentity, parentShas: [cMerge], branch: 'main', committedAt: '2026-08-18T02:12:00.000Z', bridgeCursorAtCommit: 12, journalSequence: 12, openTurnIdsAtCommit: [], operationId: 'op-ambiguous' });
+  const ambiguous = await binder.bind({ projectId, commitSha: cAmbiguous });
+  assert.strictEqual(ambiguous.status, 'ambiguous');
+  assert.deepStrictEqual(ambiguous.turns, []);
+
+  const missingBoundary = await binder.bind({ projectId, commitSha: '6'.repeat(40) });
+  assert.strictEqual(missingBoundary.status, 'unavailable', 'missing boundary/capture gap must never fall back to timestamp or ancestry guessing');
+
+  const explicitSha = '7'.repeat(40);
+  await append({ eventId: 'explicit-r', sequence: null, eventType: 'user_prompt', role: 'user', content: 'Explicit requirement.', turnId: 'turn-explicit', explicitCommitSha: explicitSha, identityConfidence: 'explicit' });
+  const explicit = await binder.bind({ projectId, commitSha: explicitSha });
+  assert.strictEqual(explicit.status, 'available');
+  assert.strictEqual(explicit.turns[0].bindingKind, 'explicit');
+
+  console.log('commit-conversation-binding-test PASS');
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+});