job-application-agent 3.4.2 → 3.5.0

package/job-application-agent/tests/accounting-retry-cli.test.mjs

@@ -0,0 +1,96 @@
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { createServer } from 'node:http';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import test from 'node:test';
+
+import { validateDelivery } from '../scripts/application-accounting.mjs';
+
+const script = fileURLToPath(new URL('../scripts/job-application.mjs', import.meta.url));
+
+test('CLI records a transmitted cloud retry when late receipt evidence invalidates its original preparation eligibility', async t => {
+  const stateDir = await mkdtemp(join(tmpdir(), 'accounting-retry-cli-'));
+  t.after(() => rm(stateDir, { recursive: true, force: true }));
+  const token = 'synthetic-accounting-retry-cli-token-long-enough';
+  const intentId = 'prepared-recovery-intent';
+  const leaseId = 'synthetic-live-lease';
+  const occurredAt = '2026-09-14T10:00:00.000Z';
+  const application = { id: 'app', company: 'Example', role: 'Engineer', url: 'https://jobs.example.com/app', source: 'email', status: 'submitted', submittedAt: '2026-09-12T10:00:00.000Z' };
+  const failure = validateDelivery({ version: 1, id: 'failure-event', applicationId: 'app', attemptId: 'initial:app', type: 'delivery-failed', occurredAt: '2026-09-13T10:00:00.000Z', evidenceType: 'final-delivery-failure', evidence: 'Synthetic final failure matched to original email.' });
+  const receipt = validateDelivery({ version: 1, id: 'late-receipt', applicationId: 'app', attemptId: 'initial:app', type: 'receipt-confirmed', occurredAt, evidenceType: 'employer-acknowledgement', evidence: 'Synthetic employer acknowledgement arrived after recovery was transmitted.' });
+  const retry = validateDelivery({ version: 1, id: 'retry-event', applicationId: 'app', attemptId: intentId, type: 'retry-confirmed', channel: 'browser', url: application.url, channelVerifiedAt: occurredAt, approval: 'STANDING AUTHORIZATION', evidenceType: 'browser-confirmation', evidence: 'Synthetic visible ATS success for prepared recovery.', occurredAt });
+  const streams = { applications: [application], delivery: [failure, receipt] };
+  const confirmations = [];
+  const unexpected = [];
+  const server = createServer(async (request, response) => {
+    const url = new URL(request.url, 'http://127.0.0.1');
+    response.setHeader('content-type', 'application/json');
+    if (request.headers.authorization !== `Bearer ${token}`) {
+      response.writeHead(401).end(JSON.stringify({ error: 'Synthetic authentication required' }));
+      return;
+    }
+    if (request.method === 'GET' && url.pathname === '/v2/status') {
+      response.end(JSON.stringify({ apiVersion: 2, backend: 'synthetic-accounting-backend', capabilities: ['application-accounting-v1'], documents: [], streams: [], files: [] }));
+      return;
+    }
+    if (request.method === 'GET' && url.pathname.startsWith('/v2/streams/')) {
+      const stream = url.pathname.split('/').at(-1);
+      const records = (streams[stream] ?? []).map((value, index) => ({ sequence: index + 1, recordKey: value.id, idempotencyKey: `accounting:${value.id}`, value }));
+      const after = Number(url.searchParams.get('after') ?? 0);
+      const page = records.filter(record => record.sequence > after);
+      response.end(JSON.stringify({ stream, records: page, nextCursor: page.at(-1)?.sequence ?? after }));
+      return;
+    }
+    if (request.method === 'GET' && url.pathname.startsWith('/v2/documents/')) {
+      response.writeHead(404).end(JSON.stringify({ error: 'Synthetic document not present' }));
+      return;
+    }
+    if (request.method === 'POST' && url.pathname === `/v2/intents/${intentId}/confirm`) {
+      let raw = '';
+      for await (const chunk of request) raw += chunk;
+      const body = JSON.parse(raw);
+      confirmations.push(body);
+      if (body.leaseId !== leaseId || body.delivery?.attemptId !== intentId) {
+        response.writeHead(409).end(JSON.stringify({ error: 'Wrong prepared intent or lease' }));
+        return;
+      }
+      streams.delivery.push(body.delivery);
+      response.end(JSON.stringify({ confirmed: true, intentId }));
+      return;
+    }
+    unexpected.push(`${request.method} ${url.pathname}`);
+    response.writeHead(500).end(JSON.stringify({ error: 'Unexpected synthetic backend request' }));
+  });
+  await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+  t.after(() => new Promise(resolve => server.close(resolve)));
+  const backendUrl = `http://127.0.0.1:${server.address().port}`;
+  const preload = `const realFetch = globalThis.fetch; globalThis.fetch = (input, init) => { const url = new URL(typeof input === 'string' ? input : input.url); if (url.origin !== 'https://state.example.com') throw new Error('Unexpected non-fixture network request'); return realFetch(process.env.ACCOUNTING_TEST_BACKEND_URL + url.pathname + url.search, init); };`;
+  const configPath = join(stateDir, 'cloud-config.json');
+  await writeFile(configPath, JSON.stringify({ version: 2, url: 'https://state.example.com', token, clientId: 'synthetic-client' }), { mode: 0o600 });
+  await writeFile(join(stateDir, 'telemetry.json'), JSON.stringify({ version: 1, enabled: false, disclosed: true, graceConsumed: true, installationEventPending: false }));
+  for (const [stream, rows] of Object.entries(streams)) {
+    await writeFile(join(stateDir, `${stream}.ndjson`), `${rows.map(row => JSON.stringify(row)).join('\n')}\n`, { mode: 0o600 });
+  }
+  const env = { ...process.env, ACCOUNTING_TEST_BACKEND_URL: backendUrl, JOB_APPLICATION_AGENT_STATE_DIR: stateDir, JOB_APPLICATION_AGENT_CLOUD_CONFIG: configPath, JOB_APPLICATION_AGENT_SOURCE_COMMUNITY_URL: 'http://127.0.0.1:9' };
+  const result = await new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, ['--import', `data:text/javascript,${encodeURIComponent(preload)}`, script, 'ledger', 'retry', '--stdin'], { env, stdio: ['pipe', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', chunk => { stdout += chunk; });
+    child.stderr.on('data', chunk => { stderr += chunk; });
+    child.on('error', reject);
+    child.on('close', code => resolve({ code, stdout, stderr }));
+    child.stdin.end(JSON.stringify({ ...retry, cloudIntentId: intentId, cloudLeaseId: leaseId }));
+  });
+
+  assert.deepEqual(unexpected, []);
+  assert.equal(result.code, 0, result.stderr);
+  assert.equal(confirmations.length, 1);
+  assert.deepEqual(confirmations[0], { delivery: retry, leaseId });
+  assert.equal(JSON.parse(result.stdout).recorded, true);
+  const localEvents = (await readFile(join(stateDir, 'delivery.ndjson'), 'utf8')).trim().split('\n').map(JSON.parse);
+  assert.equal(localEvents.filter(event => event.type === 'retry-confirmed' && event.attemptId === intentId).length, 1);
+});

package/job-application-agent/tests/accounting-source-race.test.mjs

@@ -0,0 +1,109 @@
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import test from 'node:test';
+
+const script = fileURLToPath(new URL('../scripts/job-application.mjs', import.meta.url));
+// Constant preload: pause immediately before the source command acquires its
+// rounds lock, allowing a real lead command to commit first without timing sleeps.
+const lockBarrierPreload = `
+import fs from 'node:fs/promises';
+import { basename } from 'node:path';
+import { syncBuiltinESMExports } from 'node:module';
+const originalOpen = fs.open;
+let intercepted = false;
+fs.open = async function(path, ...args) {
+  if (!intercepted && basename(String(path)) === '.rounds.lock') {
+    intercepted = true;
+    await new Promise((resolve, reject) => {
+      process.once('message', message => {
+        if (message !== 'release-lock-attempt') return reject(new Error('Unexpected barrier message'));
+        process.disconnect();
+        resolve();
+      });
+      process.send('before-rounds-lock');
+    });
+  }
+  return originalOpen.call(fs, path, ...args);
+};
+syncBuiltinESMExports();
+`;
+
+function launch(env, args, input, preloadPath) {
+  const runtime = preloadPath ? ['--import', pathToFileURL(preloadPath).href] : [];
+  const child = spawn(process.execPath, [...runtime, script, ...args], {
+    env, stdio: preloadPath ? ['pipe', 'pipe', 'pipe', 'ipc'] : ['pipe', 'pipe', 'pipe'],
+  });
+  const completed = new Promise((resolve, reject) => {
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', chunk => { stdout += chunk; });
+    child.stderr.on('data', chunk => { stderr += chunk; });
+    child.once('error', reject);
+    child.once('close', code => resolve({ code, stdout, stderr }));
+  });
+  child.stdin.end(JSON.stringify(input));
+  return { child, completed };
+}
+
+for (const explicitStaleCounts of [false, true]) {
+  test(explicitStaleCounts
+    ? 'source coverage rejects stale count assertions after a lead commits before lock acquisition'
+    : 'source coverage derives counts from the lead committed before lock acquisition', { timeout: 15000 }, async t => {
+    const dir = await mkdtemp(join(tmpdir(), 'accounting-source-race-'));
+    t.after(() => rm(dir, { recursive: true, force: true }));
+    const preloadPath = join(dir, 'rounds-lock-barrier.mjs');
+    await writeFile(preloadPath, lockBarrierPreload);
+    await writeFile(join(dir, 'telemetry.json'), JSON.stringify({ enabled: false, disclosed: true }));
+    const env = {
+      ...process.env,
+      JOB_APPLICATION_AGENT_STATE_DIR: dir,
+      JOB_APPLICATION_AGENT_CLOUD_CONFIG: join(dir, 'absent-cloud-config.json'),
+      JOB_APPLICATION_AGENT_SOURCE_COMMUNITY_URL: 'http://127.0.0.1:9',
+    };
+    const started = await launch(env, ['round', 'start', '--stdin'], { requestedCount: 1 }).completed;
+    assert.equal(started.code, 0, started.stderr);
+    const { roundId } = JSON.parse(started.stdout);
+    const sourceId = 'indeed';
+    const source = launch(env, ['round', 'source', '--stdin'], {
+      roundId, sourceId, status: 'searched', evidence: 'Synthetic source search.',
+      ...(explicitStaleCounts ? { reviewedCount: 0, qualifiedCount: 0 } : {}),
+    }, preloadPath);
+    t.after(() => { if (source.child.exitCode === null) source.child.kill(); });
+    await Promise.race([
+      new Promise((resolve, reject) => {
+        source.child.once('message', message => {
+          if (message === 'before-rounds-lock') resolve();
+          else reject(new Error('Source sent an unexpected barrier message.'));
+        });
+      }),
+      source.completed.then(result => { throw new Error(`Source exited before the lock barrier: ${result.stderr}`); }),
+    ]);
+    const lead = await launch(env, ['round', 'lead', '--stdin'], {
+      id: 'qualified-lead', roundId, sourceId, company: 'Synthetic Example', role: 'Engineer',
+      url: 'https://example.test/jobs/123', disposition: 'qualified',
+      observedAt: '2026-09-14T10:00:00.000Z', evidence: 'Synthetic qualifying employer requisition.',
+    }).completed;
+    assert.equal(lead.code, 0, lead.stderr);
+    source.child.send('release-lock-attempt');
+    const result = await source.completed;
+    const stored = (await readFile(join(dir, 'rounds.ndjson'), 'utf8')).split('\n').filter(Boolean).map(JSON.parse);
+    const coverage = stored.filter(event => event.type === 'source-checked');
+    if (explicitStaleCounts) {
+      assert.notEqual(result.code, 0, 'Stale zero-count assertions must not be accepted after one qualified lead commits.');
+      assert.match(result.stderr, /count assertions do not match recorded leads/i);
+      assert.equal(coverage.length, 0);
+    } else {
+      assert.equal(result.code, 0, result.stderr);
+      const event = JSON.parse(result.stdout);
+      assert.equal(event.reviewedCount, 1);
+      assert.equal(event.qualifiedCount, 1);
+      assert.equal(coverage.length, 1);
+      assert.equal(coverage[0].reviewedCount, 1);
+      assert.equal(coverage[0].qualifiedCount, 1);
+    }
+  });
+}

package/job-application-agent/tests/application-accounting.test.mjs

@@ -0,0 +1,315 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { deliveryProjection, discoveryProjection } from '../scripts/application-accounting.mjs';
+
+const occurredAt = '2026-09-13T10:00:00Z';
+
+function application(overrides = {}) {
+  return { id: 'application-1', company: 'Example', role: 'Engineer', source: 'email', url: 'https://example.com/jobs/123', status: 'submitted', submittedAt: '2026-09-12T10:00:00Z', ...overrides };
+}
+
+function delivery(overrides = {}) {
+  return { version: 1, id: 'bounce-1', applicationId: 'application-1', attemptId: 'initial:application-1', type: 'delivery-failed', occurredAt, evidenceType: 'final-delivery-failure', evidence: 'Final recipient failure matched to the sent application message.', ...overrides };
+}
+
+function lead(overrides = {}) {
+  return { version: 1, type: 'lead-reviewed', id: 'lead-event-1', roundId: 'round-1', sourceId: 'direct', url: 'https://example.com/jobs/123', company: 'Example', role: 'Engineer', disposition: 'qualified', observedAt: occurredAt, evidence: 'Active employer posting assessed against candidate requirements.', ...overrides };
+}
+
+test('email sends count once while their receipt remains unknown', () => {
+  const result = deliveryProjection([application()], []);
+  assert.equal(result.effectiveSubmissionCount, 1);
+  assert.equal(result.receiptUnknownEmailCount, 1);
+  assert.equal(result.failedDeliveryCount, 0);
+  assert.equal(result.applications[0].receiptUnknown, true);
+  assert.equal(result.applications[0].attempts.length, 1);
+});
+
+test('confirmed browser applications need no email acknowledgement', () => {
+  const result = deliveryProjection([application({ source: 'ashby' })], []);
+  assert.equal(result.effectiveSubmissionCount, 1);
+  assert.equal(result.receiptUnknownEmailCount, 0);
+});
+
+test('a matched final email failure removes the application from effective totals', () => {
+  const result = deliveryProjection([application()], [delivery()]);
+  assert.equal(result.effectiveSubmissionCount, 0);
+  assert.equal(result.failedDeliveryCount, 1);
+  assert.equal(result.receiptUnknownEmailCount, 0);
+  assert.equal(result.applications[0].counted, false);
+  assert.equal(result.applications[0].failed, true);
+});
+
+test('notification failure cannot invalidate independent browser confirmation', () => {
+  const result = deliveryProjection([application({ source: 'ashby' })], [delivery()]);
+  assert.equal(result.effectiveSubmissionCount, 1);
+  assert.equal(result.failedDeliveryCount, 0);
+});
+
+test('temporary delivery delays and ambiguous failures do not silently change totals', () => {
+  for (const evidenceType of ['delivery-delay', 'ambiguous']) {
+    const result = deliveryProjection([application()], [delivery({ evidenceType })]);
+    assert.equal(result.effectiveSubmissionCount, 1, evidenceType);
+    assert.equal(result.failedDeliveryCount, 0, evidenceType);
+  }
+});
+
+test('unrelated bounce and hiring rejection do not invalidate the submitted application', () => {
+  const result = deliveryProjection([application({ outcome: 'rejected' })], [delivery({ applicationId: 'another-application', attemptId: 'initial:another-application' })]);
+  assert.equal(result.effectiveSubmissionCount, 1);
+  assert.equal(result.failedDeliveryCount, 0);
+});
+
+test('receipt confirmation resolves unknown email receipt', () => {
+  const result = deliveryProjection([application()], [delivery({ id: 'receipt-1', type: 'receipt-confirmed', evidenceType: 'employer-acknowledgement' })]);
+  assert.equal(result.effectiveSubmissionCount, 1);
+  assert.equal(result.receiptUnknownEmailCount, 0);
+});
+
+test('contradictory receipt and failure remain counted and flag conflict in either arrival order', () => {
+  const failure = delivery();
+  const receipt = delivery({ id: 'receipt-1', type: 'receipt-confirmed', evidenceType: 'employer-acknowledgement' });
+  for (const events of [[failure, receipt], [receipt, failure]]) {
+    const result = deliveryProjection([application()], events);
+    assert.equal(result.effectiveSubmissionCount, 1);
+    assert.equal(result.applications[0].conflict, true);
+  }
+});
+
+test('explicit correction supersedes a failure without depending on arrival order', () => {
+  const failure = delivery();
+  const correction = delivery({ id: 'correction-1', type: 'correction', supersedes: failure.id, status: 'receipt-confirmed', evidenceType: 'employer-acknowledgement' });
+  for (const events of [[failure, correction], [correction, failure]]) {
+    const result = deliveryProjection([application()], events);
+    assert.equal(result.effectiveSubmissionCount, 1);
+    assert.equal(result.failedDeliveryCount, 0);
+    assert.equal(result.applications[0].conflict, false);
+    assert.equal(result.receiptUnknownEmailCount, 0);
+  }
+});
+
+test('correcting a mistaken failure to unknown restores the original email send', () => {
+  const result = deliveryProjection([application()], [delivery(), delivery({ id: 'correction-1', type: 'correction', supersedes: 'bounce-1', status: 'unknown', evidenceType: 'ambiguous' })]);
+  assert.equal(result.effectiveSubmissionCount, 1);
+  assert.equal(result.receiptUnknownEmailCount, 1);
+});
+
+test('a failed email followed by confirmed ATS recovery remains one application with two attempts', () => {
+  const retry = delivery({ id: 'retry-1', attemptId: 'replacement-1', type: 'retry-confirmed', channel: 'browser', url: 'https://jobs.ashbyhq.com/example/123', evidenceType: 'browser-confirmation', occurredAt: '2026-09-13T11:00:00Z' });
+  const result = deliveryProjection([application()], [delivery(), retry, retry]);
+  assert.equal(result.applications.length, 1);
+  assert.equal(result.applications[0].attempts.length, 2);
+  assert.equal(result.effectiveSubmissionCount, 1);
+  assert.equal(result.failedDeliveryCount, 0);
+  assert.equal(result.receiptUnknownEmailCount, 0);
+});
+
+test('replayed delivery event IDs cannot duplicate failures', () => {
+  const failure = delivery();
+  const result = deliveryProjection([application()], [failure, { ...failure }, failure]);
+  assert.equal(result.failedDeliveryCount, 1);
+  assert.equal(result.applications[0].attempts.length, 1);
+});
+
+test('legacy unfamiliar discovery rows remain outside the new projection', () => {
+  const result = discoveryProjection([{ id: 'legacy', reviewedCount: 19, qualifiedCount: 2 }, { type: 'unknown-future-record', roundId: 'round-1' }], { roundId: 'round-1' });
+  assert.equal(result.reviewedCount, 0);
+  assert.equal(result.qualifiedCount, 0);
+  assert.equal(result.leads.length, 0);
+});
+
+test('replayed lead event IDs and other rounds do not inflate reviewed counts', () => {
+  const first = lead();
+  const result = discoveryProjection([first, { ...first }, lead({ id: 'other-round', roundId: 'round-2' })], { roundId: 'round-1' });
+  assert.equal(result.reviewedCount, 1);
+  assert.equal(result.qualifiedCount, 1);
+  assert.equal(result.uniqueLeadCount, 1);
+});
+
+test('explicit assessment revision replaces its prior disposition without inflating totals', () => {
+  const original = lead();
+  const revision = lead({ id: 'lead-event-2', supersedes: original.id, disposition: 'closed-stale', observedAt: '2026-09-14T10:00:00Z' });
+  for (const events of [[original, revision], [revision, original]]) {
+    const result = discoveryProjection(events, { roundId: 'round-1' });
+    assert.equal(result.reviewedCount, 1);
+    assert.equal(result.qualifiedCount, 0);
+    assert.equal(result.conflicts.length, 0);
+    assert.equal(result.leads[0].disposition, 'closed-stale');
+  }
+});
+
+test('competing assessment revisions surface a conflict regardless of arrival order', () => {
+  const first = lead();
+  const conflicting = lead({ id: 'lead-event-2', disposition: 'blocked' });
+  for (const events of [[first, conflicting], [conflicting, first]]) {
+    const result = discoveryProjection(events, { roundId: 'round-1' });
+    assert.equal(result.reviewedCount, 1);
+    assert.equal(result.conflicts.length, 1);
+    assert.equal(result.qualifiedCount, 0);
+  }
+});
+
+test('cross-source sightings preserve source reviews while deduplicating the requisition', () => {
+  const result = discoveryProjection([lead({ employerJobId: 'example:123' }), lead({ id: 'linkedin-sighting', sourceId: 'linkedin', url: 'https://linkedin.com/jobs/view/987', employerJobId: 'example:123' })], { roundId: 'round-1' });
+  assert.equal(result.reviewedCount, 2);
+  assert.equal(result.qualifiedCount, 2);
+  assert.equal(result.uniqueLeadCount, 1);
+  assert.equal(result.leads.length, 2);
+});
+
+test('distinct employer requisitions remain separate even for the same company and role', () => {
+  const result = discoveryProjection([lead({ employerJobId: 'example:123' }), lead({ id: 'second-role', url: 'https://example.com/jobs/456', employerJobId: 'example:456' })], { roundId: 'round-1' });
+  assert.equal(result.reviewedCount, 2);
+  assert.equal(result.uniqueLeadCount, 2);
+});
+
+test('competing corrections cannot silently choose failure over an unknown disposition', () => {
+  const original = delivery();
+  const unknown = delivery({id:'clear-bounce',type:'correction',supersedes:original.id,status:'unknown'});
+  const failed = delivery({id:'keep-bounce',type:'correction',supersedes:original.id,status:'delivery-failed'});
+  const result = deliveryProjection([application()], [original, unknown, failed]);
+  assert.equal(result.applications[0].conflict, true);
+  assert.equal(result.effectiveSubmissionCount, 1);
+});
+
+test('verified requisition aliases with the same assessment count as one lead without conflict', () => {
+  const result = discoveryProjection([lead({employerJobId:'REQ-1'}),lead({id:'alias',url:'https://ats.example.com/REQ-1',employerJobId:'REQ-1'})], {roundId:'round-1'});
+  assert.equal(result.reviewedCount,1);
+  assert.equal(result.qualifiedCount,1);
+  assert.equal(result.conflicts.length,0);
+});
+
+test('a later verified requisition ID enriches a URL-only lead without inflating counts', () => {
+  const first = lead();
+  const enriched = lead({ id:'enriched',employerJobId:'REQ-1',supersedes:first.id });
+  const result = discoveryProjection([first,enriched],{roundId:'round-1'});
+  assert.equal(result.reviewedCount,1);
+  assert.equal(result.uniqueLeadCount,1);
+  assert.equal(result.leads[0].employerJobId,'REQ-1');
+});
+
+test('conflicting retry copies project identically in either arrival order', () => {
+  const email = delivery({ id: 'retry-email', type: 'retry-confirmed', attemptId: 'replacement', channel: 'email', evidenceType: 'sent-email' });
+  const browser = { ...email, id: 'retry-browser', channel: 'browser', evidenceType: 'browser-confirmation' };
+  const forward = deliveryProjection([application()], [delivery(), email, browser]);
+  assert.deepEqual(forward, deliveryProjection([application()], [browser, email, delivery()]));
+  assert.equal(forward.applications[0].conflict, true);
+});
+
+test('company formatting does not split verified requisitions or create assessment conflicts', () => {
+  const original = lead({ company: 'Example, Inc.', employerJobId: 'REQ-1' });
+  const alias = lead({ id: 'alias', company: 'Example Inc', employerJobId: 'req-1', url: 'https://ats.example/jobs/1' });
+  const sameSource = discoveryProjection([original, alias]);
+  assert.equal(sameSource.reviewedCount, 1);
+  assert.equal(sameSource.qualifiedCount, 1);
+  const crossSource = discoveryProjection([original, { ...alias, sourceId: 'linkedin' }]);
+  assert.equal(crossSource.reviewedCount, 2);
+  assert.equal(crossSource.uniqueLeadCount, 1);
+});
+
+test('URL-only sightings discard tracking while retaining distinct requisition parameters', () => {
+  const original = lead({ url: 'https://example.com/careers?jobId=123&trackingId=one' });
+  const repeat = lead({ id: 'repeat', url: 'https://example.com/careers?trackingId=two&jobId=123' });
+  assert.equal(discoveryProjection([original, repeat]).reviewedCount, 1);
+  assert.equal(discoveryProjection([original, { ...repeat, sourceId: 'linkedin' }]).uniqueLeadCount, 1);
+  assert.equal(discoveryProjection([original, { ...repeat, url: 'https://example.com/careers?jobId=456' }]).uniqueLeadCount, 2);
+});
+
+test('a revision can enrich but cannot remove a verified requisition identity', async () => {
+  const { validateLeadReferences } = await import('../scripts/application-accounting.mjs');
+  const original = lead({ employerJobId: 'REQ-1' });
+  const weakened = lead({ id: 'weakened', supersedes: original.id });
+  assert.throws(() => validateLeadReferences(weakened, [original]), /same round, source and requisition/);
+  const urlOnly = lead();
+  const enriched = lead({ id: 'enriched', employerJobId: 'REQ-1', supersedes: urlOnly.id });
+  assert.doesNotThrow(() => validateLeadReferences(enriched, [urlOnly]));
+});
+
+test('prepared retry confirmation preserves evidence without reauthorizing its transmission', async () => {
+  const { validateDeliveryReferences } = await import('../scripts/application-accounting.mjs');
+  const receipt = delivery({ id: 'receipt', type: 'receipt-confirmed', evidenceType: 'employer-acknowledgement' });
+  const retry = delivery({ id: 'retry', type: 'retry-confirmed', attemptId: 'replacement', channel: 'browser', evidenceType: 'browser-confirmation' });
+  const evidence = [delivery(), receipt];
+  assert.throws(() => validateDeliveryReferences(retry, [application()], evidence), /verified failure/);
+  assert.doesNotThrow(() => validateDeliveryReferences(retry, [application()], evidence, { preparedRetry: true }));
+  assert.throws(() => validateDeliveryReferences({ ...retry, id: 'another' }, [application()], [...evidence, retry], { preparedRetry: true }), /attemptId already exists/);
+});
+
+for (const parameter of ['id', 'career_job_req_id']) {
+  test(`URL-only discovery preserves distinct ${parameter} requisition values`, () => {
+    const first = lead({ url: `https://example.com/careers?${parameter}=123&trackingId=one` });
+    const repeat = lead({ id: 'repeat', url: `https://example.com/careers?trackingId=two&${parameter}=123` });
+    const different = lead({ id: 'different', url: `https://example.com/careers?${parameter}=456&trackingId=three` });
+    const result = discoveryProjection([first, repeat, different]);
+    assert.equal(result.reviewedCount, 2);
+    assert.equal(result.qualifiedCount, 2);
+    assert.equal(result.uniqueLeadCount, 2);
+    assert.equal(result.conflicts.length, 0);
+  });
+}
+
+test('a distinct requisition at a shared URL cannot undo explicit identity enrichment', async () => {
+  const { validateLeadReferences } = await import('../scripts/application-accounting.mjs');
+  const original = lead({ id: 'url-observation', url: 'https://example.com/careers' });
+  const enriched = lead({ ...original, id: 'verified-requisition', employerJobId: 'REQ-1', supersedes: original.id });
+  const another = lead({ ...original, id: 'other-requisition', employerJobId: 'REQ-2' });
+  assert.doesNotThrow(() => validateLeadReferences(enriched, [original]));
+  assert.doesNotThrow(() => validateLeadReferences(another, [original, enriched]));
+  for (const events of [[original, enriched, another], [another, enriched, original]]) {
+    const result = discoveryProjection(events);
+    assert.equal(result.reviewedCount, 2);
+    assert.equal(result.qualifiedCount, 2);
+    assert.equal(result.uniqueLeadCount, 2);
+    assert.equal(result.conflicts.length, 0);
+    assert.deepEqual(result.leads.map(item => item.employerJobId).sort(), ['REQ-1', 'REQ-2']);
+  }
+});
+
+test('an explicit correction resolves forked identity enrichment by retaining one verified branch ID', async () => {
+  const { validateLeadReferences } = await import('../scripts/application-accounting.mjs');
+  const original = lead({ id: 'original', url: 'https://example.com/careers' });
+  const first = lead({ ...original, id: 'first-branch', employerJobId: 'REQ-1', supersedes: original.id });
+  const second = lead({ ...original, id: 'second-branch', employerJobId: 'REQ-2', supersedes: original.id });
+  assert.doesNotThrow(() => validateLeadReferences(first, [original]));
+  assert.doesNotThrow(() => validateLeadReferences(second, [original, first]));
+  const prior = [original, first, second];
+  assert.equal(discoveryProjection(prior).conflicts.length, 1);
+  const correction = lead({
+    ...first, id: 'resolved-identity', supersedes: [first.id, second.id],
+    evidence: 'Employer posting confirms REQ-1; the second assessment used an incorrect requisition ID.',
+  });
+  assert.doesNotThrow(() => validateLeadReferences(correction, prior));
+  for (const events of [[...prior, correction], [correction, second, first, original]]) {
+    const result = discoveryProjection(events);
+    assert.equal(result.reviewedCount, 1);
+    assert.equal(result.qualifiedCount, 1);
+    assert.equal(result.uniqueLeadCount, 1);
+    assert.equal(result.conflicts.length, 0);
+    assert.equal(result.leads[0].employerJobId, 'REQ-1');
+  }
+});
+
+test('an identity correction cannot merge unrelated requisitions at the same company and URL', async () => {
+  const { validateLeadReferences } = await import('../scripts/application-accounting.mjs');
+  const first = lead({ id: 'first-requisition', employerJobId: 'REQ-1', url: 'https://example.com/careers' });
+  const second = lead({ ...first, id: 'second-requisition', employerJobId: 'REQ-2' });
+  const correction = lead({ ...first, id: 'invalid-merge', supersedes: [first.id, second.id] });
+  assert.throws(() => validateLeadReferences(correction, [first, second]), /same round, source and requisition/);
+  const result = discoveryProjection([first, second]);
+  assert.equal(result.reviewedCount, 2);
+  assert.equal(result.uniqueLeadCount, 2);
+  assert.equal(result.conflicts.length, 0);
+});
+
+test('forked identity enrichments remain one conflicted assessment in either order', () => {
+  const original = lead();
+  const left = lead({ id: 'left-enrichment', employerJobId: 'REQ-1', supersedes: original.id });
+  const right = lead({ id: 'right-enrichment', employerJobId: 'REQ-2', supersedes: original.id });
+  for (const events of [[original, left, right], [right, left, original]]) {
+    const result = discoveryProjection(events);
+    assert.equal(result.reviewedCount, 1);
+    assert.equal(result.qualifiedCount, 0);
+    assert.equal(result.conflicts.length, 1);
+  }
+});

package/job-application-agent/tests/job-application.test.mjs

@@ -542,12 +542,17 @@ test('CLI emits bounded source coverage without private evidence or attribution'
   assert.equal(started.code, 0, started.stderr);
   const roundId = JSON.parse(started.stdout).roundId;
   const sourceId = 'community-0123456789abcdef';
+  for(let i=0;i<8;i++) {
+    const result = await runCli(script,['round','lead','--stdin'],{roundId,sourceId,url:`https://fixture.example/jobs/${i}`,company:`Fixture ${i}`,disposition:i<2?'qualified':'closed-stale',observedAt:'2026-08-01T00:00:00Z',evidence:'Private lead assessment'},env);
+    assert.equal(result.code,0,result.stderr);
+  }
   const report = await runCli(script, ['round', 'source', '--stdin'], { roundId, sourceId, status: 'searched', reviewedCount: 8, qualifiedCount: 2, evidence: 'Private search query and candidate context', applicationIds: [] }, env);
   assert.equal(report.code, 0, report.stderr);
   const event = captured.find((body) => body.event === 'source_checked');
   assert.ok(event, JSON.stringify(captured));
   assert.deepEqual(event.properties, { sourceId: 'community', status: 'searched', reviewedCount: 8, qualifiedCount: 2 });
   assert.equal(JSON.stringify(captured).includes('Private search query'), false);
+  assert.equal(JSON.stringify(captured).includes('Private lead assessment'), false);
   assert.equal(JSON.stringify(captured).includes(roundId), false);
   assert.equal(JSON.stringify(captured).includes(sourceId), false);
 });

package/job-application-agent/tests/review-cadence.test.mjs

@@ -0,0 +1,66 @@
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+import { buildReview } from '../scripts/job-application.mjs';
+
+const now = new Date('2026-09-14T12:00:00Z');
+const applications = (count, submittedAt = '2026-09-14T10:00:00Z') => Array.from({ length: count }, (_, index) => ({
+  id: `application-${index}`, company: `Company ${index}`, role: 'Engineer',
+  url: `https://example.test/jobs/${index}`, source: 'email', status: 'submitted', submittedAt,
+}));
+const failure = {
+  version: 1, id: 'late-bounce', applicationId: 'application-0', attemptId: 'initial:application-0',
+  type: 'delivery-failed', occurredAt: '2026-09-14T11:00:00Z',
+  evidenceType: 'final-delivery-failure', evidence: 'Final failure matched to the original application email.',
+};
+
+test('late failure does not delay hygiene review after ten more canonical submissions', () => {
+  const entries = applications(20);
+  const acknowledgements = [{ uniqueSubmissionCount: 10, maturedApplicationCount: 0 }];
+  const review = buildReview(entries, [], acknowledgements, now, [failure]);
+  assert.equal(review.effectiveSubmissionCount, 19);
+  assert.equal(review.submittedSinceLastReview, 10);
+  assert.equal(review.reviewDue, true);
+  assert.ok(review.reviewReasons.includes('submission-hygiene'));
+});
+
+test('late failure does not delay mature review while conversion still uses effective applications', () => {
+  const entries = applications(40, '2026-01-01T10:00:00Z');
+  const acknowledgements = [{ uniqueSubmissionCount: 40, maturedApplicationCount: 20 }];
+  const outcomes = [{ id: 'application-1', status: 'interview', occurredAt: '2026-02-01T10:00:00Z' }];
+  const review = buildReview(entries, outcomes, acknowledgements, now, [failure]);
+  assert.equal(review.maturedApplications, 39);
+  assert.equal(review.conversionRates.interview, 2.6);
+  assert.equal(review.reviewDue, true);
+  assert.deepEqual(review.reviewReasons, ['outcome-effectiveness']);
+});
+
+test('review acknowledgement checkpoints recorded canonical counts after delivery failure', async (t) => {
+  const dir = await mkdtemp(join(tmpdir(), 'review-cadence-'));
+  t.after(() => rm(dir, { recursive: true, force: true }));
+  const entries = applications(20, '2026-01-01T10:00:00Z');
+  // A duplicate row must not inflate either checkpoint.
+  entries.push({ ...entries[1], id: 'duplicate-row' });
+  await writeFile(join(dir, 'applications.ndjson'), entries.map(JSON.stringify).join('\n') + '\n');
+  await writeFile(join(dir, 'delivery.ndjson'), JSON.stringify(failure) + '\n');
+  await writeFile(join(dir, 'telemetry.json'), JSON.stringify({ enabled: false, disclosed: true }));
+  const env = {
+    ...process.env, JOB_APPLICATION_AGENT_STATE_DIR: dir,
+    JOB_APPLICATION_AGENT_CLOUD_CONFIG: join(dir, 'absent.json'),
+    JOB_APPLICATION_AGENT_SOURCE_COMMUNITY_URL: 'http://127.0.0.1:9',
+  };
+  const script = fileURLToPath(new URL('../scripts/job-application.mjs', import.meta.url));
+  const ack = JSON.parse(execFileSync(process.execPath, [script, 'ledger', 'review-ack', '--stdin'], {
+    env, encoding: 'utf8', input: JSON.stringify({ reviewedAt: now.toISOString() }),
+  }));
+  assert.equal(ack.uniqueSubmissionCount, 20);
+  assert.equal(ack.maturedApplicationCount, 20);
+  const stored = JSON.parse((await readFile(join(dir, 'reviews.ndjson'), 'utf8')).trim());
+  assert.equal(stored.uniqueSubmissionCount, 20);
+  assert.equal(stored.maturedApplicationCount, 20);
+});