job-application-agent 3.4.1 → 3.5.0

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);
+});

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

@@ -71,6 +71,11 @@ function submission(index, roundId, overrides = {}) {
   };
 }
 
+function recordLeads(env, roundId, sourceId, entries, otherCount = 0) {
+  for (const app of entries) cli(env, ['round','lead','--stdin'], { roundId, sourceId, applicationId: app.id, url: app.url, employerJobId: app.employerJobId, company: app.company, role: app.role, disposition:'qualified', observedAt:app.submittedAt, evidence:'Synthetic role meets the target requirements.' });
+  for (let i=0;i<otherCount;i++) cli(env, ['round','lead','--stdin'], { roundId, sourceId, url:`https://other.fixture.example/${sourceId}/${i}`, company:`Other ${i}`, disposition:'no-relevant-opening', observedAt:'2026-08-01T00:00:00Z', evidence:'No target role on this careers page.' });
+}
+
 test('persists a scoped autonomy grant and revokes future routine transmissions', async (t) => {
   const { directory, env } = await fixture(t, 'autonomy');
 
@@ -122,6 +127,7 @@ test('counts only unique confirmed ledger submissions for an explicit round', as
   assert.equal(status.completed, false);
 
   for (const sourceId of ['linkedin-jobs-feed', 'indeed', 'hacker-news-who-is-hiring']) {
+    recordLeads(env, started.roundId, sourceId, sourceId === 'linkedin-jobs-feed' ? Array.from({ length:30 },(_,i)=>submission(i,started.roundId)) : [], sourceId === 'linkedin-jobs-feed' ? 0 : 30);
     cli(env, ['round', 'source', '--stdin'], {
       roundId: started.roundId, sourceId, status: 'searched', reviewedCount: 30, qualifiedCount: sourceId === 'linkedin-jobs-feed' ? 30 : 0,
       evidence: 'Reviewed matching postings against the unchanged target; other leads did not qualify.',
@@ -142,6 +148,8 @@ test('round completion requires distinct source coverage and explains concentrat
   const { roundId } = cli(env, ['round', 'start', '--stdin'], { requestedCount: 2 });
   for (const i of [1, 2]) cli(env, ['ledger', 'add', '--stdin'], submission(i, roundId, { discoverySourceId: 'linkedin-jobs-feed' }));
   assert.match(cliFailure(env, ['round', 'complete', '--stdin'], { roundId }).stderr, /3 distinct discovery sources/i);
+  recordLeads(env,roundId,'linkedin-jobs-feed',[submission(1,roundId),submission(2,roundId)],8);
+  recordLeads(env,roundId,'indeed',[],10);
   const check = { roundId, sourceId: 'linkedin-jobs-feed', status: 'searched', reviewedCount: 10, qualifiedCount: 2, evidence: 'Reviewed ten relevant postings using the target constraints.' };
   cli(env, ['round', 'source', '--stdin'], check);
   cli(env, ['round', 'source', '--stdin'], check);
@@ -169,7 +177,10 @@ test('discovery coverage rejects invalid reports and requires attribution withou
   for (const bad of [{ sourceId: 'imaginary-board' }, { qualifiedCount: 5 }, { status: 'blocked' }, { applicationIds: ['not-in-round'] }, { evidence: '' }, { privateProfile: 'forbidden' }]) {
     assert.equal(cliFailure(env, ['round', 'source', '--stdin'], { ...check, ...bad }).status, 1);
   }
-  for (const sourceId of ['linkedin-jobs-feed', 'indeed', 'hacker-news-who-is-hiring']) cli(env, ['round', 'source', '--stdin'], { ...check, sourceId });
+  for (const sourceId of ['linkedin-jobs-feed', 'indeed', 'hacker-news-who-is-hiring']) {
+    recordLeads(env,roundId,sourceId,[submission(1,roundId)],3);
+    cli(env, ['round', 'source', '--stdin'], { ...check, sourceId });
+  }
   assert.match(cliFailure(env, ['round', 'complete', '--stdin'], { roundId }).stderr, /attribution/i);
   cli(env, ['round', 'source', '--stdin'], { ...check, applicationIds: ['round-role-1'] });
   assert.equal(cli(env, ['round', 'status', roundId]).discovery.unattributedCount, 0);
@@ -180,7 +191,11 @@ test('source diversity is independent of ATS and concentration explanations are
   const { env } = await fixture(t, 'balanced-discovery');
   const { roundId } = cli(env, ['round', 'start', '--stdin'], { requestedCount: 5 });
   const ids = ['linkedin-jobs-feed', 'indeed', 'hacker-news-who-is-hiring'];
-  for (const sourceId of ids) cli(env, ['round', 'source', '--stdin'], { roundId, sourceId, status: 'searched', reviewedCount: 3, qualifiedCount: 2, evidence: 'Reviewed relevant postings and verified target fit.' });
+  for (const sourceId of ids) {
+    const entries=Array.from({length:5},(_,i)=>submission(i+1,roundId)).filter((_,i)=>ids[i%3]===sourceId);
+    recordLeads(env,roundId,sourceId,entries,1);
+    cli(env, ['round', 'source', '--stdin'], { roundId, sourceId, status: 'searched', evidence: 'Reviewed relevant postings and verified target fit.' });
+  }
   for (let i = 1; i <= 5; i++) cli(env, ['ledger', 'add', '--stdin'], submission(i, roundId, { discoverySourceId: ids[(i - 1) % 3], applicationChannel: 'ashby' }));
   const completed = cli(env, ['round', 'complete', '--stdin'], { roundId });
   assert.equal(completed.discovery.maxSourceSharePercent, 40);
@@ -197,6 +212,7 @@ test('blocked-only attempts and two views of the same network do not satisfy dis
   cli(env, ['round', 'source', '--stdin'], { ...check, sourceId: 'indeed' });
   assert.equal(cli(env, ['round', 'status', roundId]).discovery.coverageSatisfied, false);
   const { blocker, ...searched } = check;
+  recordLeads(env,roundId,'indeed',[submission(1,roundId)]);
   cli(env, ['round', 'source', '--stdin'], { ...searched, sourceId: 'indeed', status: 'searched', reviewedCount: 1, qualifiedCount: 1 });
   cli(env, ['round', 'source', '--stdin'], { ...check, sourceId: 'indeed' });
   assert.equal(cli(env, ['round', 'status', roundId]).discovery.coverageSatisfied, true);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "job-application-agent",
-  "version": "3.4.1",
+  "version": "3.5.0",
   "description": "A privacy-first Agent Skill and CLI for evidence-based job discovery, application completion, and outcome tracking.",
   "license": "MIT",
   "type": "module",
@@ -19,9 +19,15 @@
     "skill",
     "job-search",
     "job-application",
-    "career"
+    "career",
+    "privacy",
+    "claude",
+    "cursor",
+    "codex",
+    "resume",
+    "browser-automation"
   ],
-  "homepage": "https://github.com/vaibhavarora14/job-application-agent#readme",
+  "homepage": "https://jobappagent.com",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vaibhavarora14/job-application-agent.git"
@@ -38,7 +44,7 @@
     "check:native-artifacts": "node scripts/ci/validate-native-artifacts.mjs",
     "privacy-audit": "node --test job-application-agent/tests/privacy-audit.test.mjs",
     "smoke:package": "node scripts/smoke-package.mjs",
-    "check": "node --check job-application-agent/scripts/job-application.mjs && node --check job-application-agent/scripts/cloud-state-client.mjs && node --check job-application-agent/scripts/secret-store.mjs && node --check job-application-agent/scripts/source-community-client.mjs && node --check job-application-agent/scripts/source-community-schema.mjs && node --check job-application-agent/scripts/telemetry-client.mjs && node --check job-application-agent/scripts/telemetry-schema.mjs && node --check job-application-agent/scripts/version.mjs && node --check telemetry-worker/src/worker.mjs && node --check telemetry-worker/src/public-stats.mjs && node --check telemetry-worker/public/dashboard.js && node --check installer/src/cli.mjs && node --check installer/src/installer.mjs && node --check installer/src/runner.mjs && node --check installer/src/scheduler.mjs && node --check scripts/ci/classify-paths.mjs && node --check scripts/ci/validate-native-artifacts.mjs && node --check bin/job-application-agent.mjs && node --check state-worker/src/worker.mjs && node --check state-worker/src/backup.mjs && node --check state-worker/src/cli.mjs && node --check state-worker/bin/sync.mjs",
+    "check": "node --check job-application-agent/scripts/job-application.mjs && node --check job-application-agent/scripts/cloud-state-client.mjs && node --check job-application-agent/scripts/secret-store.mjs && node --check job-application-agent/scripts/source-community-client.mjs && node --check job-application-agent/scripts/source-community-schema.mjs && node --check job-application-agent/scripts/telemetry-client.mjs && node --check job-application-agent/scripts/telemetry-schema.mjs && node --check job-application-agent/scripts/version.mjs && node --check telemetry-worker/src/worker.mjs && node --check telemetry-worker/src/public-stats.mjs && node --check telemetry-worker/public/dashboard.js && node --check installer/src/cli.mjs && node --check installer/src/installer.mjs && node --check installer/src/runner.mjs && node --check installer/src/scheduler.mjs && node --check scripts/ci/classify-paths.mjs && node --check scripts/ci/validate-native-artifacts.mjs && node --check bin/job-application-agent.mjs && node --check state-worker/src/worker.mjs && node --check state-worker/src/backup.mjs && node --check state-worker/src/cli.mjs && node --check state-worker/bin/sync.mjs && node --check job-application-agent/scripts/application-accounting.mjs",
     "prepack": "npm run check && npm test && npm run privacy-audit"
   },
   "engines": {