job-application-agent 3.2.1 → 3.4.0

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

@@ -26,7 +26,7 @@ test('new installations disclose and send the first event immediately', async (t
   assert.equal(session.installationEventPending, true);
   await client.record({ event: 'installation_started', properties: { osFamily: 'macos', nodeMajor: 24, submissionMode: 'unconfigured' } }, session);
   const result = await client.record({ event: 'command_completed', properties: { command: 'search', result: 'success', durationBucket: '1-5s' } }, session);
-  assert.match(notice, /anonymous usage analytics/i);
+  assert.match(notice, /usage analytics/i);
   assert.equal(result.sent, true);
   assert.equal(relay.requests.length, 3);
   assert.equal((await client.beginCommand('search')).installationEventPending, false);
@@ -68,7 +68,7 @@ test('a pre-disclosure telemetry config cannot send on its disclosure command',
   let notice = '';
   const client = new TelemetryClient({ stateDir: directory, endpoint: 'https://relay.example.com', fetch: relay.fetch, stderr: (value) => { notice += value; } });
   const session = await client.beginCommand('search');
-  assert.match(notice, /anonymous usage analytics/i);
+  assert.match(notice, /usage analytics/i);
   assert.equal(session.allowSend, false);
   assert.equal(relay.requests.length, 0);
 });
@@ -130,3 +130,92 @@ test('strict record rejects invalid schema while automatic telemetry stays best
   await assert.rejects(() => client.record(invalid, session, { strict: true }), /durationBucket/i);
   assert.deepEqual(await client.record(invalid, session), { sent: false, reason: 'invalid' });
 });
+
+const usageEvent = { event: 'command_completed', properties: { command: 'profile', result: 'success', durationBucket: 'under-1s' } };
+
+test('identity sharing defaults on but waits until the command after disclosure, including upgrades', async (t) => {
+  for (const legacy of [false, true]) {
+    const directory = await mkdtemp(join(tmpdir(), 'telemetry-identity-'));
+    t.after(() => rm(directory, { recursive: true, force: true }));
+    if (legacy) await writeFile(join(directory, 'telemetry.json'), JSON.stringify({ version: 1, enabled: true, disclosed: true, graceConsumed: true }));
+    const relay = fakeRelay();
+    let notice = '';
+    const client = new TelemetryClient({ stateDir: directory, fetch: relay.fetch, stderr: (value) => { notice += value; }, readIdentity: () => ({ name: 'Test Candidate', email: 'candidate@example.com' }) });
+    const first = await client.beginCommand('profile');
+    await client.record(usageEvent, first);
+    assert.match(notice, /name and email/i);
+    assert.match(notice, /telemetry identity disable/);
+    assert.equal(relay.requests.at(-1).body.identity, undefined);
+    await client.record(usageEvent); // A missing session must not bypass the disclosure gate.
+    assert.equal(relay.requests.at(-1).body.identity, undefined);
+    await client.record(usageEvent, await client.beginCommand('profile'));
+    assert.deepEqual(relay.requests.at(-1).body.identity, { name: 'Test Candidate', email: 'candidate@example.com' });
+    assert.equal((await client.status()).identityEnabled, true);
+    assert.equal(JSON.stringify(await client.readConfig()).includes('candidate@example.com'), false);
+  }
+});
+
+test('identity opt-out rotates credentials and stops identity sharing even in an already started command', async (t) => {
+  const directory = await mkdtemp(join(tmpdir(), 'telemetry-identity-optout-'));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const relay = fakeRelay();
+  const client = new TelemetryClient({ stateDir: directory, fetch: relay.fetch, stderr: () => {}, readIdentity: () => ({ name: 'Test Candidate', email: 'candidate@example.com' }) });
+  await client.beginCommand('profile');
+  const session = await client.beginCommand('profile');
+  await client.record(usageEvent, session);
+  assert.ok(relay.requests.at(-1).body.identity);
+  const before = relay.requests.length;
+  const status = await client.configureIdentity('disable');
+  assert.equal(status.enabled, true);
+  assert.equal(status.identityEnabled, false);
+  assert.equal(status.hasInstallationId, false);
+  assert.equal(relay.requests.length, before);
+  await client.record(usageEvent, session);
+  assert.equal(relay.requests.at(-1).body.identity, undefined);
+  assert.deepEqual(relay.requests.at(-2).body, {});
+  const anonymousId = (await client.status()).installationId;
+  await client.configureIdentity('disable');
+  assert.equal((await client.status()).installationId, anonymousId);
+  await client.configure('disable');
+  await client.configure('enable');
+  assert.equal((await client.status()).identityEnabled, false);
+});
+
+test('disabled telemetry and identity opt-out never read identity; malformed identity does not stop usage', async (t) => {
+  const directory = await mkdtemp(join(tmpdir(), 'telemetry-identity-failure-'));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const relay = fakeRelay();
+  let reads = 0;
+  const client = new TelemetryClient({ stateDir: directory, fetch: relay.fetch, stderr: () => {}, readIdentity: () => { reads++; return { name: 'Test', email: 'bad', resume: 'private' }; } });
+  await client.configure('disable');
+  await client.record(usageEvent, await client.beginCommand('profile'));
+  assert.equal(reads, 0);
+  await client.configure('enable');
+  await client.beginCommand('profile');
+  assert.equal((await client.record(usageEvent, await client.beginCommand('profile'))).sent, true);
+  assert.equal(relay.requests.at(-1).body.identity, undefined);
+  await client.configureIdentity('disable');
+  const before = reads;
+  await client.record(usageEvent, await client.beginCommand('profile'));
+  assert.equal(reads, before);
+});
+
+test('identity re-enable discloses again and rotates the anonymous interval without enabling telemetry', async (t) => {
+  const directory = await mkdtemp(join(tmpdir(), 'telemetry-identity-resume-'));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const relay = fakeRelay();
+  const client = new TelemetryClient({ stateDir: directory, fetch: relay.fetch, stderr: () => {}, readIdentity: () => ({ email: 'candidate@example.com' }) });
+  await client.configureIdentity('disable');
+  await client.record(usageEvent, await client.beginCommand('profile'));
+  assert.equal(relay.requests.at(-1).body.identity, undefined);
+  await client.configure('disable');
+  const status = await client.configureIdentity('enable');
+  assert.equal(status.enabled, false);
+  assert.equal(status.hasInstallationId, false);
+  assert.equal(status.identityDisclosed, false);
+  await client.configure('enable');
+  await client.record(usageEvent, await client.beginCommand('profile'));
+  assert.equal(relay.requests.at(-1).body.identity, undefined);
+  await client.record(usageEvent, await client.beginCommand('profile'));
+  assert.deepEqual(relay.requests.at(-1).body.identity, { email: 'candidate@example.com' });
+});

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

@@ -6,8 +6,20 @@ import {
   createTelemetryEnvelope,
   jobIdentity,
   validateEvent,
+  validateTelemetryEnvelope,
 } from '../scripts/telemetry-schema.mjs';
 
+test('identity envelope accepts only bounded name and email and keeps old anonymous envelopes compatible', () => {
+  const input = { installationId: '11111111-1111-4111-8111-111111111111', token: 'signed-token', skillVersion: '3.3.0', event: 'command_completed', properties: { command: 'profile', result: 'success', durationBucket: 'under-1s' } };
+  const envelope = createTelemetryEnvelope({ ...input, identity: { name: ' Test Candidate ', email: ' candidate@example.com ' } });
+  assert.deepEqual(envelope.identity, { name: 'Test Candidate', email: 'candidate@example.com' });
+  assert.deepEqual(validateTelemetryEnvelope(envelope), envelope);
+  assert.equal(validateTelemetryEnvelope(createTelemetryEnvelope(input)).identity, undefined);
+  for (const identity of [{}, { name: 'x', phone: 'private' }, { email: 'invalid' }, { name: 'x'.repeat(161) }, { email: 'a\nb@example.com' }, { name: 'Test\nPrivate' }, { name: 'Test', resume: 'private' }]) {
+    assert.throws(() => validateTelemetryEnvelope({ ...envelope, identity }), /identity/i);
+  }
+});
+
 const baseJob = {
   company: 'Example AI',
   title: 'Staff Product Engineer',
@@ -16,6 +28,16 @@ const baseJob = {
   ats: 'greenhouse',
 };
 
+test('source coverage telemetry excludes local evidence and community identifiers', () => {
+  const event = { event: 'source_checked', properties: { sourceId: 'linkedin-jobs-feed', status: 'searched', reviewedCount: 10, qualifiedCount: 2 } };
+  assert.equal(validateEvent(event).properties.sourceId, 'linkedin-jobs-feed');
+  assert.throws(() => validateEvent({ ...event, properties: { ...event.properties, evidence: 'private query and notes' } }), /unknown/i);
+  assert.throws(() => validateEvent({ ...event, properties: { ...event.properties, sourceId: 'community-abcdef1234567890' } }), /sourceId/i);
+  assert.throws(() => validateEvent({ ...event, properties: { ...event.properties, qualifiedCount: 11 } }), /qualifiedCount/i);
+  assert.throws(() => validateEvent({ ...event, properties: { ...event.properties, status: 'blocked' } }), /block/i);
+  assert.equal(validateEvent({ event: 'source_checked', properties: { sourceId: 'community', status: 'blocked', reviewedCount: 0, qualifiedCount: 0, blocker: 'captcha' } }).properties.blocker, 'captcha');
+});
+
 test('canonicalizes job URLs and hashes the destination without query data', async () => {
   assert.equal(canonicalizeJobUrl('https://Jobs.Example.com/role/123/?utm_source=x#apply'), 'https://jobs.example.com/role/123');
   const first = await jobIdentity('https://jobs.example.com/role/123?ref=friend');

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

@@ -121,15 +121,87 @@ test('counts only unique confirmed ledger submissions for an explicit round', as
   assert.equal(status.blockedCount, 1);
   assert.equal(status.completed, false);
 
-  const completed = cli(env, ['round', 'complete', '--stdin'], { roundId: started.roundId });
+  for (const sourceId of ['linkedin-jobs-feed', 'indeed', 'hacker-news-who-is-hiring']) {
+    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.',
+      applicationIds: sourceId === 'linkedin-jobs-feed' ? Array.from({ length: 30 }, (_, i) => `round-role-${i}`) : [],
+    });
+  }
+  const completed = cli(env, ['round', 'complete', '--stdin'], { roundId: started.roundId, concentrationReason: 'stronger-fit', concentrationEvidence: 'The other searched sources had no qualifying roles; all selected roles met the target.' });
   assert.equal(completed.completed, true);
   assert.equal(cli(env, ['round', 'status', started.roundId]).completed, true);
   const roundEvents = (await readFile(join(directory, 'rounds.ndjson'), 'utf8')).trim().split('\n').map(JSON.parse);
   assert.equal(roundEvents.filter((event) => event.type === 'submission-confirmed').length, 30);
-  assert.equal(roundEvents.length, 32);
+  assert.equal(roundEvents.length, 35);
   if (process.platform !== 'win32') assert.equal((await stat(join(directory, 'rounds.ndjson'))).mode & 0o777, 0o600);
 });
 
+test('round completion requires distinct source coverage and explains concentration without imposing submission quotas', async (t) => {
+  const { env } = await fixture(t, 'source-coverage');
+  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);
+  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);
+  assert.equal(cli(env, ['round', 'status', roundId]).discovery.attemptedSourceCount, 1);
+  cli(env, ['round', 'source', '--stdin'], { ...check, sourceId: 'indeed', qualifiedCount: 0 });
+  cli(env, ['round', 'source', '--stdin'], { ...check, sourceId: 'hacker-news-who-is-hiring', status: 'blocked', reviewedCount: 0, qualifiedCount: 0, blocker: 'site-error' });
+  const status = cli(env, ['round', 'status', roundId]);
+  assert.equal(status.discovery.coverageSatisfied, true);
+  assert.equal(status.discovery.searchedSourceCount, 2);
+  assert.equal(status.discovery.blockedSourceCount, 1);
+  assert.equal(status.discovery.maxSourceSharePercent, 100);
+  assert.match(cliFailure(env, ['round', 'complete', '--stdin'], { roundId }).stderr, /concentration/i);
+  const completed = cli(env, ['round', 'complete', '--stdin'], { roundId, concentrationReason: 'stronger-fit', concentrationEvidence: 'Only LinkedIn produced qualifying roles; Indeed had none and the third source was unavailable.' });
+  assert.equal(completed.completed, true);
+  assert.equal(cli(env, ['round', 'status', roundId]).discovery.concentrationReason, 'stronger-fit');
+  assert.match(cliFailure(env, ['round', 'source', '--stdin'], check).stderr, /completed round/i);
+});
+
+test('discovery coverage rejects invalid reports and requires attribution without rewriting confirmed ledger rows', async (t) => {
+  const { env, directory } = await fixture(t, 'source-validation');
+  const { roundId } = cli(env, ['round', 'start', '--stdin'], { requestedCount: 1 });
+  cli(env, ['ledger', 'add', '--stdin'], submission(1, roundId));
+  const before = await readFile(join(directory, 'applications.ndjson'), 'utf8');
+  const check = { roundId, sourceId: 'linkedin-jobs-feed', status: 'searched', reviewedCount: 4, qualifiedCount: 1, evidence: 'Checked relevant listings against the candidate target.' };
+  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 });
+  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);
+  assert.equal(await readFile(join(directory, 'applications.ndjson'), 'utf8'), before);
+});
+
+test('source diversity is independent of ATS and concentration explanations are unnecessary for a balanced mix', async (t) => {
+  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 (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);
+  assert.equal(completed.discovery.concentrationNeedsExplanation, false);
+  assert.equal(cli(env, ['round', 'complete', '--stdin'], { roundId }).completionRecorded, false);
+});
+
+test('blocked-only attempts and two views of the same network do not satisfy discovery', async (t) => {
+  const { env } = await fixture(t, 'blocked-discovery');
+  const { roundId } = cli(env, ['round', 'start', '--stdin'], { requestedCount: 1 });
+  const check = { roundId, status: 'blocked', reviewedCount: 0, qualifiedCount: 0, blocker: 'login', evidence: 'Source requires an authenticated session that is unavailable.' };
+  for (const sourceId of ['linkedin-jobs-feed', 'yc-work-at-a-startup', 'yc-company-directory']) cli(env, ['round', 'source', '--stdin'], { ...check, sourceId });
+  assert.equal(cli(env, ['round', 'status', roundId]).discovery.attemptedSourceCount, 2);
+  cli(env, ['round', 'source', '--stdin'], { ...check, sourceId: 'indeed' });
+  assert.equal(cli(env, ['round', 'status', roundId]).discovery.coverageSatisfied, false);
+  const { blocker, ...searched } = check;
+  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);
+});
+
 test('ships a filterable global discovery source catalog and tracks source attribution', async (t) => {
   const { directory, env } = await fixture(t, 'source-catalog');
   const catalog = cli(env, ['sources', 'list']);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "job-application-agent",
-  "version": "3.2.1",
+  "version": "3.4.0",
   "description": "A privacy-first Agent Skill and CLI for evidence-based job discovery, application completion, and outcome tracking.",
   "license": "MIT",
   "type": "module",
@@ -38,7 +38,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/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",
+    "check": "node --check job-application-agent/scripts/job-application.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/cli.mjs && node --check state-worker/bin/sync.mjs",
     "prepack": "npm run check && npm test && npm run privacy-audit"
   },
   "engines": {