groove-dev 0.27.77 → 0.27.78

package/moe-training/test/client/parsers/gemini.test.js

@@ -0,0 +1,99 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { GeminiParser } from '../../../client/parsers/gemini.js';
+
+describe('GeminiParser', () => {
+  it('parses thought content type as thought', () => {
+    const parser = new GeminiParser();
+    const result = parser.parseEvent({
+      type: 'message',
+      role: 'model',
+      content: [{ type: 'thought', thought: 'I should check the imports' }],
+    });
+    assert.equal(result.type, 'thought');
+    assert.equal(result.content, 'I should check the imports');
+  });
+
+  it('parses model text message as thought', () => {
+    const parser = new GeminiParser();
+    const result = parser.parseEvent({
+      type: 'message',
+      role: 'model',
+      content: [{ text: 'Let me look at that file' }],
+    });
+    assert.equal(result.type, 'thought');
+    assert.equal(result.content, 'Let me look at that file');
+  });
+
+  it('skips user messages', () => {
+    const parser = new GeminiParser();
+    const result = parser.parseEvent({
+      type: 'message',
+      role: 'user',
+      content: [{ text: 'fix the bug' }],
+    });
+    assert.equal(result, null);
+  });
+
+  it('parses tool_request as action', () => {
+    const parser = new GeminiParser();
+    const result = parser.parseEvent({
+      type: 'tool_request',
+      name: 'Grep',
+      args: { pattern: 'TODO' },
+    });
+    assert.equal(result.type, 'action');
+    assert.equal(result.tool, 'Grep');
+    assert.deepEqual(result.arguments, { pattern: 'TODO' });
+  });
+
+  it('parses tool_response as observation', () => {
+    const parser = new GeminiParser();
+    const result = parser.parseEvent({
+      type: 'tool_response',
+      content: 'Found 3 matches',
+    });
+    assert.equal(result.type, 'observation');
+    assert.equal(result.content, 'Found 3 matches');
+  });
+
+  it('parses error event', () => {
+    const parser = new GeminiParser();
+    const result = parser.parseEvent({
+      type: 'error',
+      message: 'Rate limit exceeded',
+    });
+    assert.equal(result.type, 'error');
+    assert.equal(result.content, 'Rate limit exceeded');
+  });
+
+  it('parses agent_end as resolution', () => {
+    const parser = new GeminiParser();
+    const result = parser.parseEvent({ type: 'agent_end' });
+    assert.equal(result.type, 'resolution');
+  });
+
+  it('extracts tokens from usage event', () => {
+    const parser = new GeminiParser();
+    const tokens = parser.extractTokens({
+      type: 'usage',
+      inputTokens: 300,
+      outputTokens: 150,
+      cachedTokens: 50,
+    });
+    assert.deepEqual(tokens, { input: 300, output: 150, cacheRead: 50, cacheCreation: 0 });
+  });
+
+  it('returns null for non-usage token extraction', () => {
+    const parser = new GeminiParser();
+    assert.equal(parser.extractTokens({ type: 'message' }), null);
+  });
+
+  it('extracts session id from agent_start', () => {
+    const parser = new GeminiParser();
+    assert.equal(parser.extractSessionId({ type: 'agent_start', streamId: 'stream-456' }), 'stream-456');
+    assert.equal(parser.extractSessionId({ type: 'message' }), null);
+  });
+});

package/moe-training/test/client/scrubber.test.js

@@ -0,0 +1,133 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { PIIScrubber } from '../../client/scrubber.js';
+
+const scrubber = new PIIScrubber();
+
+describe('PIIScrubber', () => {
+  it('scrubs PEM private keys', () => {
+    const input = '-----BEGIN RSA PRIVATE KEY-----\nMIIEpAIB...\n-----END RSA PRIVATE KEY-----';
+    assert.equal(scrubber.scrub(input), '[PRIVATE_KEY]');
+  });
+
+  it('scrubs AWS access keys', () => {
+    const input = 'key is AKIAIOSFODNN7EXAMPLE here';
+    assert.equal(scrubber.scrub(input), 'key is [AWS_KEY] here');
+  });
+
+  it('scrubs Bearer tokens', () => {
+    const input = 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9';
+    assert.equal(scrubber.scrub(input), 'Authorization: [API_KEY]');
+  });
+
+  it('scrubs sk_/pk_ prefixed keys', () => {
+    const input = 'apikey: sk_test_51HQdMnAbcDefGhIjKlMn';
+    assert.equal(scrubber.scrub(input), 'apikey: [API_KEY]');
+  });
+
+  it('scrubs valid credit cards with Luhn check', () => {
+    const input = 'card: 4111 1111 1111 1111';
+    assert.equal(scrubber.scrub(input), 'card: [CREDIT_CARD]');
+  });
+
+  it('does not scrub random 16-digit numbers failing Luhn', () => {
+    const input = 'number: 1234 5678 9012 3456';
+    assert.equal(scrubber.scrub(input), 'number: 1234 5678 9012 3456');
+  });
+
+  it('scrubs SSNs', () => {
+    const input = 'ssn: 123-45-6789';
+    assert.equal(scrubber.scrub(input), 'ssn: [SSN]');
+  });
+
+  it('scrubs email addresses', () => {
+    const input = 'contact user@example.com for info';
+    assert.equal(scrubber.scrub(input), 'contact [EMAIL] for info');
+  });
+
+  it('scrubs IPv6 addresses', () => {
+    const input = 'server at 2001:0db8:85a3:0000:0000:8a2e:0370:7334';
+    assert.equal(scrubber.scrub(input), 'server at [IP]');
+  });
+
+  it('scrubs IPv4 addresses', () => {
+    const input = 'connect to 192.168.1.100';
+    assert.equal(scrubber.scrub(input), 'connect to [IP]');
+  });
+
+  it('scrubs phone numbers', () => {
+    const input = 'call (555) 123-4567';
+    assert.equal(scrubber.scrub(input), 'call [PHONE]');
+  });
+
+  it('scrubs URLs with token/key/secret params', () => {
+    const input = 'visit https://api.example.com/data?token=abc123&other=val';
+    assert.equal(scrubber.scrub(input), 'visit [REDACTED_URL]&other=val');
+  });
+
+  it('scrubs long hex strings (40+ chars)', () => {
+    const hex = 'a'.repeat(40);
+    const input = `hash: ${hex}`;
+    assert.equal(scrubber.scrub(input), 'hash: [API_KEY]');
+  });
+
+  it('scrubs home directory paths', () => {
+    const input = 'file at /Users/john/Documents/secret.txt';
+    assert.equal(scrubber.scrub(input), 'file at [FILE_PATH]');
+  });
+
+  it('scrubs URL-encoded emails', () => {
+    const input = 'param=ryan%40motovizion.com&next=home';
+    assert.equal(scrubber.scrub(input), 'param=[EMAIL]&next=home');
+  });
+
+  it('scrubs international phone numbers', () => {
+    const input = 'call +44 20 7946 0958 for help';
+    assert.equal(scrubber.scrub(input), 'call [PHONE] for help');
+  });
+
+  it('scrubs JWT tokens without Bearer prefix', () => {
+    const input = 'token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIn0.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';
+    const result = scrubber.scrub(input);
+    assert.ok(result.includes('[API_KEY]'));
+    assert.ok(!result.includes('eyJhbGciOi'));
+  });
+
+  it('scrubs file paths without trailing slash', () => {
+    const input = 'reading /home/alice/project/secret.key now';
+    const result = scrubber.scrub(input);
+    assert.ok(result.includes('[FILE_PATH]'));
+    assert.ok(!result.includes('/home/alice'));
+  });
+
+  it('scrubs base64 encoded secrets', () => {
+    const b64 = 'YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXoxMjM0NTY3ODk=';
+    const input = `secret: ${b64} done`;
+    const result = scrubber.scrub(input);
+    assert.ok(result.includes('[API_KEY]'));
+    assert.ok(!result.includes(b64));
+  });
+
+  it('passes through non-PII content unchanged', () => {
+    const input = 'This is a normal sentence about coding in JavaScript.';
+    assert.equal(scrubber.scrub(input), input);
+  });
+
+  it('handles null/undefined input gracefully', () => {
+    assert.equal(scrubber.scrub(null), null);
+    assert.equal(scrubber.scrub(undefined), undefined);
+    assert.equal(scrubber.scrub(''), '');
+  });
+
+  it('patterns do not interfere with each other', () => {
+    const input = 'user@example.com called 555-123-4567 from 192.168.1.1';
+    const result = scrubber.scrub(input);
+    assert.ok(result.includes('[EMAIL]'));
+    assert.ok(result.includes('[PHONE]'));
+    assert.ok(result.includes('[IP]'));
+    assert.ok(!result.includes('user@example.com'));
+    assert.ok(!result.includes('192.168.1.1'));
+  });
+});

package/moe-training/test/client/session-attestation-security.test.js

@@ -0,0 +1,95 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { SessionAttestation } from '../../client/session-attestation.js';
+import { verifyEnvelope } from '../../shared/crypto.js';
+
+describe('SessionAttestation security', () => {
+  let attestation;
+
+  beforeEach(() => {
+    attestation = new SessionAttestation('http://localhost:9999');
+  });
+
+  it('HMAC signs entire envelope — tampering metadata after signing fails verification', async () => {
+    const sessionId = 'sess_test_1';
+    await attestation.openSession(sessionId, {
+      provider: 'claude-code',
+      model_engine: 'claude-opus-4-6',
+      groove_version: '0.27.0',
+    });
+
+    const session = attestation._sessions.get(sessionId);
+    if (session.offline) {
+      return;
+    }
+
+    const envelope = {
+      envelope_id: 'env_test',
+      session_id: sessionId,
+      chunk_sequence: 0,
+      contributor_id: 'user_1',
+      attestation: { session_hmac: '', sequence: 0, app_version_hash: '' },
+      metadata: { agent_role: 'backend', agent_id: 'backend-1', provider: 'claude-code' },
+      trajectory_log: [{ step: 1, type: 'thought', timestamp: 123 }],
+    };
+
+    const signed = attestation.signEnvelope(sessionId, envelope);
+    const hmac = signed.attestation.session_hmac;
+    const seq = signed.attestation.sequence - 1;
+
+    const forVerify = { ...signed };
+    delete forVerify.attestation;
+    const valid = verifyEnvelope(session.sharedSecret, JSON.stringify(forVerify), seq, hmac);
+    assert.equal(valid, true, 'HMAC should verify against the full envelope minus attestation');
+
+    forVerify.metadata.agent_role = 'hacked';
+    const invalid = verifyEnvelope(session.sharedSecret, JSON.stringify(forVerify), seq, hmac);
+    assert.equal(invalid, false, 'Tampered metadata should fail HMAC verification');
+  });
+
+  it('offline mode uses OFFLINE marker not empty string', async () => {
+    const sessionId = 'sess_offline';
+    attestation._sessions.set(sessionId, {
+      keypair: null,
+      sharedSecret: null,
+      sequence: 0,
+      appVersionHash: 'test',
+      offline: true,
+    });
+
+    const envelope = {
+      envelope_id: 'env_off',
+      session_id: sessionId,
+      attestation: { session_hmac: '', sequence: 0, app_version_hash: '' },
+      metadata: {},
+      trajectory_log: [],
+    };
+
+    const signed = attestation.signEnvelope(sessionId, envelope);
+    assert.equal(signed.attestation.session_hmac, 'OFFLINE');
+    assert.notEqual(signed.attestation.session_hmac, '');
+  });
+
+  it('machine fingerprint includes hostname and core count', async () => {
+    const os = await import('node:os');
+    const fp = SessionAttestation.getMachineFingerprint();
+    assert.equal(typeof fp, 'string');
+    assert.equal(fp.length, 64);
+
+    const signals = [
+      os.platform(),
+      os.arch(),
+      os.cpus()[0]?.model || '',
+      String(os.totalmem()),
+      os.hostname(),
+      String(os.cpus().length),
+      os.release(),
+      os.endianness(),
+    ];
+    const { createHash } = await import('node:crypto');
+    const expected = createHash('sha256').update(signals.join('|')).digest('hex');
+    assert.equal(fp, expected);
+  });
+});

package/moe-training/test/client/step-classifier.test.js

@@ -0,0 +1,88 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { StepClassifier } from '../../client/step-classifier.js';
+
+describe('StepClassifier', () => {
+  it('user message before any action is not a correction', () => {
+    const classifier = new StepClassifier();
+    const result = classifier.classifyUserMessage('fix the bug');
+    assert.equal(result, null);
+  });
+
+  it('user message after action is a correction', () => {
+    const classifier = new StepClassifier();
+    classifier.onStep({ type: 'action' });
+    const result = classifier.classifyUserMessage('no, use exponential backoff');
+    assert.equal(result.type, 'correction');
+    assert.equal(result.content, 'no, use exponential backoff');
+    assert.equal(result.source, 'user');
+  });
+
+  it('classifies coordination event', () => {
+    const classifier = new StepClassifier();
+    const result = classifier.classifyCoordinationEvent({
+      coordination_id: 'coord-1',
+      direction: 'outbound',
+      target_agent: 'backend-1',
+      protocol: 'knock',
+      content: 'Requesting lock on src/api.js',
+    });
+    assert.equal(result.type, 'coordination');
+    assert.equal(result.coordination_id, 'coord-1');
+    assert.equal(result.direction, 'outbound');
+    assert.equal(result.target_agent, 'backend-1');
+    assert.equal(result.protocol, 'knock');
+  });
+
+  it('detects error recovery', () => {
+    const steps = [
+      { type: 'thought', step: 1 },
+      { type: 'action', step: 2 },
+      { type: 'error', step: 3 },
+      { type: 'thought', step: 4 },
+      { type: 'action', step: 5 },
+      { type: 'resolution', step: 6 },
+    ];
+    assert.equal(StepClassifier.detectErrorRecovery(steps), true);
+  });
+
+  it('no error recovery when no resolution after error', () => {
+    const steps = [
+      { type: 'thought', step: 1 },
+      { type: 'error', step: 2 },
+      { type: 'error', step: 3 },
+    ];
+    assert.equal(StepClassifier.detectErrorRecovery(steps), false);
+  });
+
+  it('no error recovery when no errors', () => {
+    const steps = [
+      { type: 'thought', step: 1 },
+      { type: 'action', step: 2 },
+      { type: 'resolution', step: 3 },
+    ];
+    assert.equal(StepClassifier.detectErrorRecovery(steps), false);
+  });
+
+  it('counts user interventions', () => {
+    const steps = [
+      { type: 'thought' },
+      { type: 'correction' },
+      { type: 'action' },
+      { type: 'correction' },
+      { type: 'resolution' },
+    ];
+    assert.equal(StepClassifier.countUserInterventions(steps), 2);
+  });
+
+  it('counts zero interventions when none present', () => {
+    const steps = [
+      { type: 'thought' },
+      { type: 'action' },
+      { type: 'resolution' },
+    ];
+    assert.equal(StepClassifier.countUserInterventions(steps), 0);
+  });
+});

package/moe-training/test/integration/handshake.test.js

@@ -0,0 +1,260 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { generateECDHKeypair, deriveSharedSecret, signEnvelope, verifyEnvelope } from '../../shared/crypto.js';
+import { SessionRegistry } from '../../server/session-registry.js';
+import { EnvelopeVerifier } from '../../server/verifier.js';
+import { SessionAttestation } from '../../client/session-attestation.js';
+import { EnvelopeBuilder } from '../../client/envelope-builder.js';
+
+describe('ECDH Handshake End-to-End', () => {
+  let tmpDir, registry, verifier;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'handshake-test-'));
+    registry = new SessionRegistry(join(tmpDir, 'sessions.db'));
+    verifier = new EnvelopeVerifier(registry);
+  });
+
+  afterEach(() => {
+    registry.close();
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('client and server derive the same shared secret', () => {
+    const clientKeypair = generateECDHKeypair();
+    const result = registry.openSession(
+      'sess_hs_001', clientKeypair.publicKey, 'claude-code', 'claude-opus-4-6',
+      'fp_test', 'hash_test', '0.27.77'
+    );
+
+    const serverSession = registry.getSession('sess_hs_001');
+    const clientSecret = deriveSharedSecret(clientKeypair.privateKey, result.serverPublicKey);
+    assert.equal(clientSecret, serverSession.shared_secret);
+  });
+
+  it('client-signed envelope passes server verification', () => {
+    const clientKeypair = generateECDHKeypair();
+    const result = registry.openSession(
+      'sess_hs_002', clientKeypair.publicKey, 'claude-code', 'claude-opus-4-6',
+      'fp_test', 'hash_test', '0.27.77'
+    );
+
+    const serverSession = registry.getSession('sess_hs_002');
+    const sharedSecret = deriveSharedSecret(clientKeypair.privateKey, result.serverPublicKey);
+    assert.equal(sharedSecret, serverSession.shared_secret);
+
+    const envelope = {
+      envelope_id: 'env_hs_001',
+      session_id: 'sess_hs_002',
+      chunk_sequence: 0,
+      contributor_id: 'cccccccccccccccccccccccccccccccc',
+      metadata: {
+        model_engine: 'claude-opus-4-6',
+        provider: 'claude-code',
+        agent_role: 'frontend',
+        agent_id: 'frontend-1',
+      },
+      trajectory_log: [
+        { step: 1, type: 'thought', timestamp: Date.now() / 1000, content: 'planning', token_count: 10 },
+      ],
+      attestation: { session_hmac: '', sequence: 0, app_version_hash: '' },
+    };
+
+    const envelopeForHmac = { ...envelope };
+    delete envelopeForHmac.attestation;
+    const envelopeBytes = JSON.stringify(envelopeForHmac);
+    const hmac = signEnvelope(sharedSecret, envelopeBytes, 0);
+    envelope.attestation = { session_hmac: hmac, sequence: 0, app_version_hash: 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' };
+
+    const verifyResult = verifier.verify(envelope);
+    assert.equal(verifyResult.valid, true);
+  });
+
+  it('tampered envelope is rejected by server', () => {
+    const clientKeypair = generateECDHKeypair();
+    const result = registry.openSession(
+      'sess_hs_003', clientKeypair.publicKey, 'claude-code', 'claude-opus-4-6',
+      'fp_test', 'hash_test', '0.27.77'
+    );
+
+    const sharedSecret = deriveSharedSecret(clientKeypair.privateKey, result.serverPublicKey);
+
+    const envelope = {
+      envelope_id: 'env_hs_002',
+      session_id: 'sess_hs_003',
+      chunk_sequence: 0,
+      contributor_id: 'cccccccccccccccccccccccccccccccc',
+      metadata: {
+        model_engine: 'claude-opus-4-6',
+        provider: 'claude-code',
+        agent_role: 'frontend',
+        agent_id: 'frontend-1',
+      },
+      trajectory_log: [
+        { step: 1, type: 'thought', timestamp: Date.now() / 1000, content: 'original', token_count: 10 },
+      ],
+      attestation: { session_hmac: '', sequence: 0, app_version_hash: '' },
+    };
+
+    const envelopeForHmac = { ...envelope };
+    delete envelopeForHmac.attestation;
+    const envelopeBytes = JSON.stringify(envelopeForHmac);
+    const hmac = signEnvelope(sharedSecret, envelopeBytes, 0);
+    envelope.attestation = { session_hmac: hmac, sequence: 0, app_version_hash: 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' };
+
+    envelope.trajectory_log.push({ step: 2, type: 'action', timestamp: Date.now() / 1000, content: 'injected' });
+
+    const verifyResult = verifier.verify(envelope);
+    assert.equal(verifyResult.valid, false);
+    assert.ok(verifyResult.reason.includes('HMAC'));
+  });
+
+  it('sequence numbers enforce ordering', () => {
+    const clientKeypair = generateECDHKeypair();
+    const result = registry.openSession(
+      'sess_hs_004', clientKeypair.publicKey, 'claude-code', 'claude-opus-4-6',
+      'fp_test', 'hash_test', '0.27.77'
+    );
+    const sharedSecret = deriveSharedSecret(clientKeypair.privateKey, result.serverPublicKey);
+
+    function makeEnv(seq) {
+      const env = {
+        envelope_id: `env_hs_seq_${seq}`,
+        session_id: 'sess_hs_004',
+        chunk_sequence: seq,
+        contributor_id: 'cccccccccccccccccccccccccccccccc',
+        metadata: { model_engine: 'claude-opus-4-6', provider: 'claude-code', agent_role: 'frontend', agent_id: 'frontend-1' },
+        trajectory_log: [{ step: seq + 1, type: 'thought', timestamp: Date.now() / 1000, content: `step ${seq}`, token_count: 5 }],
+      };
+      const bytes = JSON.stringify(env);
+      const hmac = signEnvelope(sharedSecret, bytes, seq);
+      env.attestation = { session_hmac: hmac, sequence: seq, app_version_hash: 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' };
+      return env;
+    }
+
+    const r0 = verifier.verify(makeEnv(0));
+    assert.equal(r0.valid, true);
+
+    const r1 = verifier.verify(makeEnv(1));
+    assert.equal(r1.valid, true);
+
+    const rSkip = verifier.verify(makeEnv(5));
+    assert.equal(rSkip.valid, false);
+    assert.ok(rSkip.reason.includes('sequence'));
+
+    const r2 = verifier.verify(makeEnv(2));
+    assert.equal(r2.valid, true);
+  });
+
+  it('different client keypairs produce different shared secrets', () => {
+    const client1 = generateECDHKeypair();
+    const client2 = generateECDHKeypair();
+
+    registry.openSession('sess_hs_005a', client1.publicKey, 'claude-code', 'claude-opus-4-6', 'fp1', 'h1', '0.27.77');
+    registry.openSession('sess_hs_005b', client2.publicKey, 'claude-code', 'claude-opus-4-6', 'fp2', 'h2', '0.27.77');
+
+    const s1 = registry.getSession('sess_hs_005a');
+    const s2 = registry.getSession('sess_hs_005b');
+
+    assert.notEqual(s1.shared_secret, s2.shared_secret);
+  });
+
+  it('EnvelopeBuilder output is verifiable after client signing', () => {
+    const clientKeypair = generateECDHKeypair();
+    const result = registry.openSession(
+      'sess_hs_006', clientKeypair.publicKey, 'claude-code', 'claude-opus-4-6',
+      'fp_test', 'hash_test', '0.27.77'
+    );
+    const sharedSecret = deriveSharedSecret(clientKeypair.privateKey, result.serverPublicKey);
+
+    const builder = new EnvelopeBuilder('sess_hs_006', 'cccccccccccccccccccccccccccccccc', {
+      model_engine: 'claude-opus-4-6',
+      provider: 'claude-code',
+      agent_role: 'frontend',
+      agent_id: 'frontend-1',
+      task_complexity: 'medium',
+      team_size: 1,
+      session_quality: 80,
+      groove_version: '0.27.77',
+    });
+
+    builder.addStep({ step: 1, type: 'thought', timestamp: Date.now() / 1000, content: 'test', token_count: 5 });
+    const envelope = builder.flush();
+    assert.ok(envelope);
+
+    const envelopeForHmac = { ...envelope };
+    delete envelopeForHmac.attestation;
+    const envelopeBytes = JSON.stringify(envelopeForHmac);
+    const hmac = signEnvelope(sharedSecret, envelopeBytes, 0);
+    envelope.attestation = { session_hmac: hmac, sequence: 0, app_version_hash: 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' };
+
+    const verifyResult = verifier.verify(envelope);
+    assert.equal(verifyResult.valid, true);
+  });
+
+  it('SESSION_CLOSE from builder is verifiable', () => {
+    const clientKeypair = generateECDHKeypair();
+    const result = registry.openSession(
+      'sess_hs_007', clientKeypair.publicKey, 'claude-code', 'claude-opus-4-6',
+      'fp_test', 'hash_test', '0.27.77'
+    );
+    const sharedSecret = deriveSharedSecret(clientKeypair.privateKey, result.serverPublicKey);
+
+    const builder = new EnvelopeBuilder('sess_hs_007', 'cccccccccccccccccccccccccccccccc', {
+      model_engine: 'claude-opus-4-6',
+      provider: 'claude-code',
+      agent_role: 'frontend',
+      agent_id: 'frontend-1',
+    });
+
+    const closeEnvelope = builder.buildSessionClose({
+      status: 'SUCCESS',
+      user_interventions: 0,
+      total_steps: 10,
+      total_chunks: 1,
+      total_tokens: 500,
+      duration_seconds: 60,
+      files_modified: 2,
+      errors_encountered: 0,
+      errors_recovered: 0,
+      coordination_events: 0,
+    });
+
+    const forHmac = { ...closeEnvelope };
+    delete forHmac.attestation;
+    const bytes = JSON.stringify(forHmac);
+    const hmac = signEnvelope(sharedSecret, bytes, 0);
+    closeEnvelope.attestation = { session_hmac: hmac, sequence: 0, app_version_hash: 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' };
+
+    const verifyResult = verifier.verifyClose(closeEnvelope);
+    assert.equal(verifyResult.valid, true);
+
+    const session = registry.getSession('sess_hs_007');
+    assert.equal(session.status, 'closed');
+  });
+
+  it('HMAC verification is constant-time (no short-circuit)', () => {
+    const clientKeypair = generateECDHKeypair();
+    registry.openSession(
+      'sess_hs_008', clientKeypair.publicKey, 'claude-code', 'claude-opus-4-6',
+      'fp_test', 'hash_test', '0.27.77'
+    );
+    const session = registry.getSession('sess_hs_008');
+    const sharedSecret = session.shared_secret;
+
+    const payload = JSON.stringify({ test: 'data' });
+    const validHmac = signEnvelope(sharedSecret, payload, 0);
+
+    const wrongFirstChar = String.fromCharCode(validHmac.charCodeAt(0) ^ 1) + validHmac.slice(1);
+    const wrongLastChar = validHmac.slice(0, -1) + String.fromCharCode(validHmac.charCodeAt(validHmac.length - 1) ^ 1);
+
+    assert.equal(verifyEnvelope(sharedSecret, payload, 0, wrongFirstChar), false);
+    assert.equal(verifyEnvelope(sharedSecret, payload, 0, wrongLastChar), false);
+    assert.equal(verifyEnvelope(sharedSecret, payload, 0, validHmac), true);
+  });
+});