@sanqianx/project-knowledge 5.0.24 → 5.0.25

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

@@ -1,147 +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-console/src/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;
-});
+// 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-console/src/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

@@ -1,99 +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;
-});
+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;
+});