job-application-agent 3.4.2 → 3.6.0

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

@@ -0,0 +1,73 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { outreachCache, runOutreach } from '../scripts/outreach-cli.mjs';
+import { migrateLegacyStateDir, legacyMacStateDir, resolveStateDir } from '../scripts/secret-store.mjs';
+const exec = promisify(execFile);
+const cli = fileURLToPath(new URL('../scripts/job-application.mjs', import.meta.url));
+
+test('CLI outreach success and errors bypass telemetry, identity, and community network paths', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'outreach-cli-'));
+  try {
+    const trap = join(dir, 'network-trap.mjs');
+    await writeFile(trap, "import { appendFileSync } from 'node:fs'; globalThis.fetch = async () => { appendFileSync(process.env.NETWORK_MARKER, 'called'); throw new Error('NETWORK_TRAP'); };\n");
+    const run = args => exec(process.execPath, ['--import', pathToFileURL(trap).href, cli, 'outreach', ...args], { env: { ...process.env, NETWORK_MARKER: join(dir, 'network-called'), JOB_APPLICATION_AGENT_STATE_DIR: dir, JOB_APPLICATION_AGENT_CLOUD_CONFIG: join(dir, 'absent.json') } });
+    const result = await run(['policy', 'status']);
+    assert.equal(JSON.parse(result.stdout).enabled, false);
+    await assert.rejects(run(['invented']), error => !error.stderr.includes('NETWORK_TRAP') && /outreach/i.test(error.stderr));
+    for (const name of ['telemetry.json', 'source-sharing.json', 'telemetry-identity.json']) await assert.rejects(readFile(join(dir, name)), { code: 'ENOENT' });
+    await assert.rejects(readFile(join(dir, 'network-called')), { code: 'ENOENT' });
+  } finally { await rm(dir, { recursive: true, force: true }); }
+});
+
+test('late snapshots cannot undo mutation invalidation or a newer clear snapshot', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'outreach-cache-race-'));
+  try {
+    const { generation } = await outreachCache(dir, 'synthetic-binding', 'read');
+    await outreachCache(dir, 'synthetic-binding', 'invalidate');
+    const rejected = await outreachCache(dir, 'synthetic-binding', 'write', { generation, snapshot: { revision: 1, privateText: 'old' } });
+    assert.equal(rejected.snapshot, undefined);
+    await outreachCache(dir, 'synthetic-binding', 'write', { generation: rejected.generation, snapshot: { revision: 3, cleared: true } });
+    const current = await outreachCache(dir, 'synthetic-binding', 'write', { generation: rejected.generation, snapshot: { revision: 2, privateText: 'old' } });
+    assert.equal(current.snapshot, undefined);
+    assert.equal(current.generation, rejected.generation + 1);
+    assert.equal(JSON.stringify(current).includes('old'), false);
+  } finally { await rm(dir, { recursive: true, force: true }); }
+});
+
+
+test('outreach first-run migrates legacy state before creating its database', async () => {
+  const home = await mkdtemp(join(tmpdir(), 'outreach-legacy-'));
+  try {
+    const options = { home, env: {}, plat: 'darwin' };
+    const legacy = legacyMacStateDir(home), destination = resolveStateDir(options);
+    await mkdir(legacy, { recursive: true });
+    await writeFile(join(legacy, 'applications.ndjson'), '{"id":"legacy"}\n');
+    await runOutreach(['policy', 'status'], { stateDirectory: destination,
+      cloudClient: { config: async () => null }, migrate: directory => migrateLegacyStateDir(directory, options) });
+    assert.equal(await readFile(join(destination, 'applications.ndjson'), 'utf8'), '{"id":"legacy"}\n');
+  } finally { await rm(home, { recursive: true, force: true }); }
+});
+
+test('a lower authoritative revision removes pre-restore sensitive cache before offline use', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'outreach-restored-cache-'));
+  try {
+    const binding = 'same-worker-and-token';
+    const { generation } = await outreachCache(dir, binding, 'read');
+    await outreachCache(dir, binding, 'write', { generation, snapshot: { revision: 50, privateText: 'pre-restore' } });
+    await outreachCache(dir, binding, 'write', { generation, snapshot: { revision: 3, items: [], policy: { recoveryBlocked: true } } });
+    const cache = await outreachCache(dir, binding, 'read');
+    assert.equal(cache.snapshot, undefined);
+    assert.equal((await readFile(join(dir, 'outreach-cloud-cache.json'), 'utf8')).includes('pre-restore'), false);
+    // A delayed pre-restore response cannot refill the invalidated cache.
+    await outreachCache(dir, binding, 'write', { generation, snapshot: { revision: 51, privateText: 'pre-restore' } });
+    assert.equal((await outreachCache(dir, binding, 'read')).snapshot, undefined);
+    await outreachCache(dir, binding, 'write', { generation: cache.generation, snapshot: { revision: 3, items: [] } });
+    assert.deepEqual((await outreachCache(dir, binding, 'read')).snapshot.items, []);
+  } finally { await rm(dir, { recursive: true, force: true }); }
+});

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

@@ -0,0 +1,178 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { initialOutreach, mutateOutreach, readOutreach, businessDate } from '../scripts/outreach-domain.mjs';
+
+import { assessment, fixture, handoff, now } from './fixtures/outreach.mjs';
+
+test('qualified hiring posts can be drafted and handed off without an application or transmission', () => {
+  const f = fixture();
+  const result = f.run('handoff', handoff());
+  assert.equal(result.delivery, 'pending-handoff');
+  assert.match(result.copyableText, /product engineering/);
+  assert.equal(readOutreach(f.state, 'review', {}, now).sentVerified, 0);
+  assert.deepEqual(f.run('handoff', handoff()), result);
+  assert.throws(() => f.run('handoff', handoff({ draftRevision: 2 })), /operation.*content/i);
+});
+test('false qualification and missing candidate claim references block handoff or draft', () => {
+  const f = fixture();
+  assert.throws(() => f.run('draft', { operationId: 'bad', id: 'opportunity-1', text: 'Hello', claimRefs: ['invented'], purpose: 'initial' }), /claim/i);
+  f.run('assess', assessment('opportunity-1', { operationId: 'reassess', qualification: { active: true, companyVerified: true, eligible: false, fit: true, affiliation: true, hiringInvolvement: true } }));
+  assert.throws(() => f.run('handoff', handoff({ qualificationRevision: 2 })), /qualification/i);
+});
+test('company reservation blocks other channels and does not expire after uncertain handoff', () => {
+  const f = fixture(); f.run('handoff', handoff());
+  f.run('record', { operationId: 'uncertain', id: 'opportunity-1', type: 'uncertain', attemptId: 'handoff-1', occurredAt: now, evidence: 'User cannot confirm sending.' });
+  f.run('assess', assessment('second', { channel: 'x', recipient: { account: 'https://x.com/example_hiring', aliases: [] } }));
+  f.run('draft', { operationId: 'draft-2', id: 'second', text: 'Hello', claimRefs: [], purpose: 'initial' });
+  assert.throws(() => f.run('handoff', handoff({ operationId: 'handoff-2', id: 'second' })), /reserved|contact/i);
+});
+test('clear removes sensitive material, retains suppression, and refuses resurrection', () => {
+  const f = fixture(); f.run('handoff', handoff());
+  f.run('clear', { operationId: 'clear', ids: ['opportunity-1'] });
+  const serialized = JSON.stringify(f.state);
+  for (const privateText of ['example.org', 'example-recruiter', 'canonical-resume', 'brief conversation']) assert.equal(serialized.includes(privateText), false);
+  assert.throws(() => f.run('assess', assessment('opportunity-1', { operationId: 'resurrect' })), /cleared/i);
+  assert.equal(f.run('handoff', handoff()).cleared, true);
+});
+test('business dates use local calendar weekdays across weekends', () => {
+  assert.equal(businessDate('2026-09-18T23:30:00Z', 'Asia/Kolkata', 7), '2026-09-29');
+});
+
+test('ranking does not exclude qualified contacts and aliases identify the same recipient', () => {
+  const f = fixture();
+  f.run('assess', assessment('opportunity-1', { operationId: 'low-rank', ranking: { hiringSignal: 0, responsibility: 0, fit: 0, freshness: 0, relationship: 0 } }));
+  f.run('draft', { operationId: 'new-draft', id: 'opportunity-1', text: 'Hello', claimRefs: [], purpose: 'initial' });
+  assert.equal(f.run('handoff', handoff({ draftRevision: 2, qualificationRevision: 2 })).score, 0);
+  f.run('assess', assessment('other-company', { company: { name: 'Second', domain: 'second.example', aliases: [] }, recipient: { account: 'https://linkedin.com/in/EXAMPLE-RECRUITER/?tracking=1', aliases: [] } }));
+  f.run('draft', { operationId: 'other-draft', id: 'other-company', text: 'Hello', claimRefs: [], purpose: 'initial' });
+  assert.throws(() => f.run('handoff', handoff({ operationId: 'other-handoff', id: 'other-company' })), /reserved/);
+});
+
+test('follow-up depends on actual send dates, and replies cancel it', () => {
+  const f = fixture(); f.run('handoff', handoff());
+  f.run('record', { operationId: 'sent', id: 'opportunity-1', attemptId: 'handoff-1', type: 'sent-user-reported', occurredAt: now, evidence: 'User reports manual send.' });
+  assert.equal(readOutreach(f.state, 'show', { id: 'opportunity-1' }, '2026-09-24T10:00:00Z').followupDue, false);
+  assert.equal(readOutreach(f.state, 'show', { id: 'opportunity-1' }, '2026-09-25T10:00:00Z').followupDue, true);
+  f.run('draft', { operationId: 'followup-draft', id: 'opportunity-1', text: 'Following up on the role.', claimRefs: [], purpose: 'follow-up' });
+  assert.equal(readOutreach(f.state, 'show', { id: 'opportunity-1' }, '2026-10-20T10:00:00Z').noResponse, false);
+  f.run('record', { operationId: 'reply', id: 'opportunity-1', type: 'screen-proposed', occurredAt: now, evidence: 'Recruiter proposed a discussion.' });
+  assert.equal(readOutreach(f.state, 'show', { id: 'opportunity-1' }, '2026-10-20T10:00:00Z').followupDue, false);
+  assert.equal(readOutreach(f.state, 'review', {}, now).outcomes['screen-scheduled'], 0);
+  assert.throws(() => f.run('record', { operationId: 'bad-schedule', id: 'opportunity-1', type: 'screen-scheduled', occurredAt: now, evidence: 'They mentioned a discussion.' }), /object/);
+});
+
+test('conflicting delivery evidence requires explicit correction; not-sent release can be corrected safely', () => {
+  const f = fixture(); f.run('handoff', handoff());
+  const record = (operationId, type, extra = {}) => f.run('record', { operationId, id: 'opportunity-1', attemptId: 'handoff-1', type, occurredAt: now, evidence: 'Synthetic observation.', ...extra });
+  record('uncertain', 'uncertain');
+  assert.equal(record('sent', 'sent-user-reported').delivery, 'conflict');
+  assert.equal(record('fixed', 'not-sent', { supersedes: ['uncertain', 'sent'] }).delivery, 'not-sent');
+  assert.equal(Object.keys(f.state.reservations).length, 0);
+  assert.equal(f.run('handoff', handoff()).copyableText, undefined);
+  record('later-proof', 'sent-verified', { supersedes: ['fixed'], messageRef: 'message-1' });
+  assert.equal(Object.keys(f.state.reservations).length, 1);
+  assert.equal(readOutreach(f.state, 'show', { id: 'opportunity-1' }, now).delivery, 'sent-verified');
+});
+
+test('linked applications must match both company and role', () => {
+  const f = fixture();
+  const input = assessment('applied', { applicationId: 'app-1', source: { kind: 'application', url: 'https://example.org/jobs/1' } });
+  assert.throws(() => mutateOutreach(f.state, 'assess', input, { now, applications: [{ id: 'app-1', company: 'Wrong Company', role: input.role, status: 'submitted' }] }), /company/i);
+  const result = mutateOutreach(f.state, 'assess', input, { now, applications: [{ id: 'app-1', company: 'Example', role: input.role, status: 'submitted' }] });
+  assert.equal(result.result.eligible, true);
+});
+
+test('common fabricated application and commitment claims are rejected; disabled grants stop handoff', () => {
+  const f = fixture();
+  for (const [index, text] of ['I applied for this role.', 'I am available immediately.', 'I built AI agents.'].entries()) {
+    assert.throws(() => f.run('draft', { operationId: `invalid-${index}`, id: 'opportunity-1', text, claimRefs: [], purpose: 'initial' }), /claim|commitment|evidence/);
+  }
+  f.run('policy-disable', { operationId: 'disable' });
+  assert.throws(() => f.run('handoff', handoff()), /disabled/);
+});
+
+test('recipient and company suppression cannot be overridden by an exception', () => {
+  const f = fixture();
+  f.run('suppress', { operationId: 'stop', id: 'opportunity-1', scope: 'company', reason: 'Candidate requested no contact.' });
+  assert.throws(() => f.run('handoff', handoff({ exception: { approvedByUser: true, reason: 'Attempted bypass.' } })), /suppressed/);
+});
+
+test('company suppression cancels due suggestions for other opportunities', () => {
+  const f = fixture(); f.run('handoff', handoff());
+  f.run('record', { operationId: 'sent', id: 'opportunity-1', attemptId: 'handoff-1', type: 'sent-user-reported', occurredAt: now, evidence: 'User reports sending.' });
+  f.run('assess', assessment('other'));
+  f.run('suppress', { operationId: 'stop-other', id: 'other', scope: 'company', reason: 'Company-wide stop.' });
+  assert.equal(readOutreach(f.state, 'show', { id: 'opportunity-1' }, '2026-10-01T10:00:00Z').followupDue, false);
+});
+
+test('one follow-up can close as no response only after it was sent', () => {
+  const f = fixture(); f.run('handoff', handoff());
+  f.run('record', { operationId: 'initial-sent', id: 'opportunity-1', type: 'sent-user-reported', attemptId: 'handoff-1', occurredAt: now, evidence: 'User reports sending.' });
+  f.run('draft', { operationId: 'followup', id: 'opportunity-1', text: 'Following up on the role.', claimRefs: [], purpose: 'follow-up' });
+  const later = '2026-09-25T10:00:00Z';
+  let state = mutateOutreach(f.state, 'handoff', handoff({ operationId: 'followup-handoff', draftRevision: 2, recheckedAt: later, history: { kind: 'verified', noPriorPitch: false, checkedAt: later } }), { now: later }).state;
+  assert.equal(readOutreach(state, 'show', { id: 'opportunity-1' }, '2026-10-20T10:00:00Z').noResponse, false);
+  state = mutateOutreach(state, 'record', { operationId: 'followup-sent', id: 'opportunity-1', type: 'sent-user-reported', attemptId: 'followup-handoff', occurredAt: later, evidence: 'User reports follow-up.' }, { now: later }).state;
+  assert.equal(readOutreach(state, 'show', { id: 'opportunity-1' }, '2026-10-06T10:00:00Z').noResponse, true);
+  assert.equal(readOutreach(state, 'show', { id: 'opportunity-1' }, '2026-10-06T10:00:00Z').followupDue, false);
+});
+
+test('progression corrections cannot supersede delivery evidence and bypass an unresolved reservation', () => {
+  const f = fixture(); f.run('handoff', handoff());
+  f.run('record', { operationId: 'sent', id: 'opportunity-1', type: 'sent-user-reported', attemptId: 'handoff-1', occurredAt: now, evidence: 'User reports sending.' });
+  assert.throws(() => f.run('record', { operationId: 'bad-correction', id: 'opportunity-1', type: 'replied', supersedes: ['sent'], occurredAt: now, evidence: 'Wrong category.' }), /category|delivery/i);
+  f.run('record', { operationId: 'uncertain-correction', id: 'opportunity-1', type: 'uncertain', attemptId: 'handoff-1', supersedes: ['sent'], occurredAt: now, evidence: 'Send could not be verified.' });
+  f.run('assess', assessment('second'));
+  f.run('draft', { operationId: 'second-draft', id: 'second', text: 'Hello', claimRefs: [], purpose: 'initial' });
+  assert.throws(() => f.run('handoff', handoff({ operationId: 'second-handoff', id: 'second', exception: { approvedByUser: true, reason: 'Try another contact.' } })), /unresolved/);
+});
+
+test('valid opaque IDs may match Object.prototype property names', () => {
+  const f = fixture();
+  assert.throws(() => f.run('clear', { operationId: 'bad-clear', ids: ['constructor'] }), /not found/);
+  assert.equal(Object.hasOwn(f.state.reservations, 'clear-constructor'), false);
+  f.run('assess', assessment('constructor', { operationId: 'toString' }));
+  f.run('draft', { operationId: 'constructor', id: 'constructor', text: 'Hello', claimRefs: [], purpose: 'initial' });
+  assert.equal(readOutreach(f.state, 'show', { id: 'constructor' }, now).content.drafts.length, 1);
+  assert.equal(readOutreach(f.state, 'show', { id: 'constructor' }, now).cleared, false);
+  assert.equal(f.run('draft', { operationId: 'constructor', id: 'constructor', text: 'Hello', claimRefs: [], purpose: 'initial' }).cleared, false);
+});
+
+test('clearing another opportunity cannot overwrite a pending handoff reservation', () => {
+  const f = fixture();
+  f.run('handoff', handoff({ operationId: 'clear-other' }));
+  f.run('assess', assessment('other', { company: { name: 'Other', domain: 'other.org', aliases: [] }, recipient: { account: 'https://x.com/other', aliases: [] }, channel: 'x' }));
+  f.run('clear', { operationId: 'clear-op', ids: ['other'] });
+  assert.equal(f.state.reservations['clear-other'].pending, true);
+  f.run('assess', assessment('retry'));
+  f.run('draft', { operationId: 'retry-draft', id: 'retry', text: 'Hello', claimRefs: [], purpose: 'initial' });
+  assert.throws(() => f.run('handoff', handoff({ operationId: 'retry-handoff', id: 'retry' })), /unresolved/);
+});
+
+test('correcting rejection removes only its derived suppression', () => {
+  const f = fixture();
+  f.run('record', { operationId: 'rejection', id: 'opportunity-1', type: 'rejected', occurredAt: now, evidence: 'Mistaken rejection.' });
+  assert.equal(readOutreach(f.state, 'show', { id: 'opportunity-1' }, now).suppressed, true);
+  f.run('record', { operationId: 'correction', id: 'opportunity-1', type: 'replied', supersedes: ['rejection'], occurredAt: now, evidence: 'Actually a reply.' });
+  assert.equal(readOutreach(f.state, 'show', { id: 'opportunity-1' }, now).suppressed, false);
+  f.run('suppress', { operationId: 'explicit', id: 'opportunity-1', scope: 'recipient', reason: 'User requests stop.' });
+  f.run('record', { operationId: 'correction-2', id: 'opportunity-1', type: 'referred', supersedes: ['correction'], occurredAt: now, evidence: 'Referral completed.' });
+  assert.equal(readOutreach(f.state, 'show', { id: 'opportunity-1' }, now).suppressed, true);
+});
+
+test('company suppression does not suppress a recipient at an unrelated company', () => {
+  const f = fixture();
+  f.run('suppress', { operationId: 'stop-company', id: 'opportunity-1', scope: 'company', reason: 'Stop this company.' });
+  f.run('assess', assessment('new-company', { company: { name: 'Other', domain: 'other.org', aliases: [] } }));
+  assert.equal(readOutreach(f.state, 'show', { id: 'new-company' }, now).suppressed, false);
+});
+
+test('handoff retries recheck current linked application outcomes', () => {
+  const f = fixture();
+  const context = { now, applications: [{ id: 'app-1', company: 'Example', role: 'Staff Product Engineer', status: 'submitted' }] };
+  let state = mutateOutreach(f.state, 'assess', assessment('opportunity-1', { operationId: 'linked', applicationId: 'app-1' }), context).state;
+  state = mutateOutreach(state, 'draft', { operationId: 'linked-draft', id: 'opportunity-1', text: 'Hello', claimRefs: [], purpose: 'initial' }, context).state;
+  const input = handoff({ qualificationRevision: 2, draftRevision: 2 });
+  state = mutateOutreach(state, 'handoff', input, context).state;
+  assert.throws(() => mutateOutreach(state, 'handoff', input, { ...context, outcomes: [{ id: 'app-1', status: 'rejected' }] }), /hiring outcome/);
+});

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

@@ -11,6 +11,8 @@ const forbiddenProperties = [
   'agentResponse', 'jobDescription', 'formQuestion', 'draftedAnswer', 'note', 'password', 'mfa',
   'captcha', 'legalAnswer', 'demographicAnswer', 'browserData', 'ipAddress', 'requestHeaders',
   'userAgent', 'rawError',
+  'recipient', 'recipientAccount', 'message', 'sentText', 'claimRefs', 'evidence',
+  'outreachId', 'opportunityId', 'companyFingerprint', 'recipientFingerprint',
 ];
 
 test('privacy audit rejects every prohibited free-form or identity property', () => {

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/session-binding.test.mjs

@@ -0,0 +1,102 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import {
+  FILL_DISPLAY,
+  FILL_VNC_PORT,
+  FORBIDDEN_VNC_PORT,
+  assertSameTab,
+  createSessionBinding,
+  extractSessionBindingFields,
+  readSessionBindingFile,
+  sessionBindingPath,
+  validateSessionBinding,
+  writeSessionBindingFile,
+} from "../scripts/session-binding.mjs";
+
+test("validateSessionBinding requires fill display and VNC 5900", () => {
+  const ok = validateSessionBinding({
+    attentionId: "attention-1",
+    jobUrl: "https://jobs.ashbyhq.com/acme/application",
+    browserProfilePath: "/tmp/jaa-chrome",
+  });
+  assert.equal(ok.ok, true);
+  assert.equal(ok.binding.display, FILL_DISPLAY);
+  assert.equal(ok.binding.vncPort, FILL_VNC_PORT);
+
+  const badPort = validateSessionBinding({
+    attentionId: "attention-1",
+    jobUrl: "https://jobs.example.com/a",
+    browserProfilePath: "/tmp/p",
+    vncPort: FORBIDDEN_VNC_PORT,
+  });
+  assert.equal(badPort.ok, false);
+  assert.match(badPort.error, /5901/);
+
+  const badDisplay = validateSessionBinding({
+    attentionId: "attention-1",
+    jobUrl: "https://jobs.example.com/a",
+    browserProfilePath: "/tmp/p",
+    display: ":1",
+  });
+  assert.equal(badDisplay.ok, false);
+  assert.match(badDisplay.error, /forbidden|display/i);
+});
+
+test("assertSameTab detects drift and accepts same application path", () => {
+  const same = assertSameTab(
+    "https://jobs.ashbyhq.com/acme/job/123",
+    "https://jobs.ashbyhq.com/acme/job/123?utm_source=x",
+  );
+  assert.equal(same.ok, true);
+
+  const drift = assertSameTab(
+    "https://jobs.ashbyhq.com/acme/job/123",
+    "https://jobs.ashbyhq.com/acme",
+  );
+  assert.equal(drift.ok, false);
+  assert.equal(drift.reason, "tab_drift");
+
+  const hintFail = assertSameTab(
+    "https://jobs.ashbyhq.com/acme/job/123",
+    "https://jobs.ashbyhq.com/acme/job/123",
+    { urlContains: "/application" },
+  );
+  assert.equal(hintFail.ok, false);
+});
+
+test("write/read session binding stays local under state dir", async (t) => {
+  const dir = await mkdtemp(join(tmpdir(), "jaa-binding-"));
+  t.after(() => rm(dir, { recursive: true, force: true }));
+
+  const binding = createSessionBinding({
+    attentionId: "attention-abc",
+    jobUrl: "https://jobs.ashbyhq.com/acme/application",
+    browserProfilePath: "/home/runner/.jaa-chrome-fill",
+    applicationId: "app-1",
+    roundId: "round-1",
+    tabHint: { urlContains: "/application" },
+  });
+  const path = sessionBindingPath(dir, binding.attentionId);
+  await writeSessionBindingFile(path, binding);
+  const loaded = await readSessionBindingFile(path);
+  assert.equal(loaded.attentionId, "attention-abc");
+  assert.equal(loaded.vncPort, 5900);
+  const raw = JSON.parse(await readFile(path, "utf8"));
+  assert.equal(raw.browserProfilePath, "/home/runner/.jaa-chrome-fill");
+});
+
+test("extractSessionBindingFields pulls local-only keys", () => {
+  const fields = extractSessionBindingFields({
+    url: "https://example.com",
+    browserProfilePath: "/tmp/p",
+    display: ":99",
+    vncPort: 5900,
+  });
+  assert.equal(fields.browserProfilePath, "/tmp/p");
+  assert.equal(fields.display, ":99");
+  assert.equal(extractSessionBindingFields({ url: "https://example.com" }), null);
+});

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

@@ -19,14 +19,39 @@ test('documents durable autonomy, resumable rounds, attention and friction contr
   const skill = await readFile(new URL('../SKILL.md', import.meta.url), 'utf8');
   const autonomy = await readFile(new URL('../references/AUTONOMY.md', import.meta.url), 'utf8');
   const runs = await readFile(new URL('../references/RUNS.md', import.meta.url), 'utf8');
+  const agentBox = await readFile(new URL('../references/agent-box/README.md', import.meta.url), 'utf8');
 
   assert.match(skill, /autonomy status/);
   assert.match(skill, /round status/);
   assert.match(skill, /attention list/);
   assert.match(skill, /friction record/);
+  assert.match(skill, /attention-runner-poll/);
+  assert.match(skill, /attention-resume-submit/);
+  assert.match(skill, /session-binding/);
+  assert.match(skill, /DISPLAY=:99/);
+  assert.match(skill, /5900/);
   assert.match(autonomy, /never.*merge.*publish/i);
   assert.match(autonomy, /CAPTCHA/i);
   assert.match(runs, /visible.*confirmation/i);
   assert.match(runs, /discoverySource/);
   assert.match(runs, /applicationChannel/);
+  assert.match(runs, /Resume → submit/);
+  assert.match(runs, /attention-runner-poll/);
+  assert.match(runs, /submit if possible/i);
+  assert.match(agentBox, /localhost:5900/);
+  assert.match(agentBox, /5901/);
+  assert.match(agentBox, /DISPLAY=:99/);
+});
+
+test('documents Free.ai as optional LLM assist only', async () => {
+  const skill = await readFile(new URL('../SKILL.md', import.meta.url), 'utf8');
+  const freeAi = await readFile(new URL('../references/FREE_AI.md', import.meta.url), 'utf8');
+
+  assert.match(skill, /FREE_AI\.md/);
+  assert.match(skill, /does not call Free\.ai/i);
+  assert.match(freeAi, /https:\/\/api\.free\.ai\/v1/);
+  assert.match(freeAi, /FREE_AI_API_KEY/);
+  assert.match(freeAi, /qwen7b/);
+  assert.match(freeAi, /not the hosted/i);
+  assert.match(freeAi, /does not read `FREE_AI_API_KEY`/i);
 });

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);
@@ -723,7 +739,18 @@ test('replays and prioritizes an owner-only attention queue', async (t) => {
     stage: 'submission',
     blocker: 'captcha',
     requiredActions: ['complete-captcha'],
-  });
+    browserProfilePath: join(directory, 'chrome-fill'),
+    display: ':99',
+    vncPort: 5900,
+    tabHint: { urlContains: '/captcha' },
+  });
+
+  assert.ok(captcha.sessionBinding?.binding?.browserProfilePath);
+  assert.equal(captcha.sessionBinding.binding.vncPort, 5900);
+  assert.equal(captcha.sessionBinding.binding.display, ':99');
+  const attentionRaw = await readFile(join(directory, 'attention.ndjson'), 'utf8');
+  assert.doesNotMatch(attentionRaw, /browserProfilePath/);
+  assert.ok((await readFile(captcha.sessionBinding.path, 'utf8')).includes('chrome-fill'));
 
   const before = cli(env, ['attention', 'list']);
   assert.deepEqual(before.items.map((item) => item.id), [captcha.id, judgment.id]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "job-application-agent",
-  "version": "3.4.2",
+  "version": "3.6.0",
   "description": "A privacy-first Agent Skill and CLI for evidence-based job discovery, application completion, and outcome tracking.",
   "license": "MIT",
   "type": "module",
@@ -42,9 +42,9 @@
   "scripts": {
     "test": "node --test",
     "check:native-artifacts": "node scripts/ci/validate-native-artifacts.mjs",
-    "privacy-audit": "node --test job-application-agent/tests/privacy-audit.test.mjs",
+    "privacy-audit": "node --test job-application-agent/tests/privacy-audit.test.mjs job-application-agent/tests/outreach-cli.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/attention-runner-poll.mjs && node --check job-application-agent/scripts/attention-resume-submit.mjs && node --check job-application-agent/scripts/session-binding.mjs && node --check job-application-agent/scripts/novnc-display-guard.mjs && node --check job-application-agent/scripts/ats/submit-adapters.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 && node --check job-application-agent/scripts/outreach-domain.mjs && node --check job-application-agent/scripts/outreach-store.mjs && node --check job-application-agent/scripts/outreach-cli.mjs && node --check state-worker/src/outreach.mjs && node --check job-application-agent/scripts/ats/answer-inject.mjs && node --check job-application-agent/scripts/attention-questions.mjs && node --check job-application-agent/scripts/captcha-vendor.mjs",
     "prepack": "npm run check && npm test && npm run privacy-audit"
   },
   "engines": {
@@ -52,5 +52,8 @@
   },
   "devDependencies": {
     "yaml": "2.9.0"
+  },
+  "dependencies": {
+    "sql.js": "1.13.0"
   }
 }