job-application-agent 3.5.0 → 3.6.0

package/job-application-agent/tests/attention-resume-submit.test.mjs

@@ -0,0 +1,119 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  ASHBY_ADAPTER,
+  buildSubmitProbePlan,
+  detectAbsoluteBlockers,
+  detectConfirmation,
+  resolveAtsAdapter,
+} from "../scripts/ats/submit-adapters.mjs";
+import {
+  RESUME_EXIT,
+  decideResumeSubmit,
+  resumeSubmitChecklist,
+} from "../scripts/attention-resume-submit.mjs";
+
+const binding = {
+  version: 1,
+  attentionId: "attention-1",
+  jobUrl: "https://jobs.ashbyhq.com/livekit/application",
+  browserProfilePath: "/tmp/jaa-chrome",
+  display: ":99",
+  vncPort: 5900,
+  createdAt: "2026-09-16T00:00:00.000Z",
+};
+
+test("resolveAtsAdapter picks Ashby for ashbyhq hosts", () => {
+  assert.equal(resolveAtsAdapter("https://jobs.ashbyhq.com/x/application").id, "ashby");
+  assert.equal(resolveAtsAdapter("https://boards.greenhouse.io/x").id, "generic");
+  assert.ok(ASHBY_ADAPTER.submitSelectors.length >= 2);
+});
+
+test("detectAbsoluteBlockers and confirmation helpers", () => {
+  assert.equal(detectAbsoluteBlockers({ pageText: "Please complete the reCAPTCHA" }).blocked, true);
+  assert.equal(detectConfirmation({
+    pageUrl: "https://jobs.ashbyhq.com/x/application-submitted",
+  }).confirmed, true);
+  assert.equal(detectConfirmation({
+    pageUrl: "https://jobs.ashbyhq.com/x/application",
+    pageText: "Thank you for applying",
+  }).confirmed, true);
+});
+
+test("decideResumeSubmit: ready to submit when clear", () => {
+  const decision = decideResumeSubmit({
+    binding,
+    snapshot: {
+      pageUrl: "https://jobs.ashbyhq.com/livekit/application",
+      submitEnabled: true,
+      leaseHeld: true,
+    },
+  });
+  assert.equal(decision.action, "ready_to_submit");
+  assert.equal(decision.exitCode, RESUME_EXIT.READY_TO_SUBMIT);
+  assert.match(decision.message, /submit if possible/i);
+});
+
+test("decideResumeSubmit: still blocked on captcha", () => {
+  const decision = decideResumeSubmit({
+    binding,
+    snapshot: {
+      pageUrl: "https://jobs.ashbyhq.com/livekit/application",
+      pageText: "hCaptcha challenge",
+      leaseHeld: true,
+    },
+  });
+  assert.equal(decision.action, "still_blocked");
+  assert.equal(decision.exitCode, RESUME_EXIT.STILL_BLOCKED);
+});
+
+test("decideResumeSubmit: tab drift and confirmation", () => {
+  const drift = decideResumeSubmit({
+    binding,
+    snapshot: {
+      pageUrl: "https://jobs.ashbyhq.com/livekit",
+      leaseHeld: true,
+    },
+  });
+  assert.equal(drift.action, "tab_drift");
+  assert.equal(drift.exitCode, RESUME_EXIT.TAB_OR_BINDING);
+
+  const confirmed = decideResumeSubmit({
+    binding,
+    snapshot: {
+      pageUrl: "https://jobs.ashbyhq.com/livekit/application",
+      matchedConfirmationSelectors: ["text=/thank you/i"],
+      leaseHeld: true,
+    },
+  });
+  assert.equal(confirmed.action, "submitted_confirmed");
+  assert.equal(confirmed.exitCode, RESUME_EXIT.SUBMITTED);
+});
+
+test("decideResumeSubmit: missing binding and ambiguous submit", () => {
+  assert.equal(decideResumeSubmit({
+    binding: null,
+    snapshot: { pageUrl: "https://jobs.ashbyhq.com/livekit/application" },
+  }).exitCode, RESUME_EXIT.TAB_OR_BINDING);
+
+  const ambiguous = decideResumeSubmit({
+    binding,
+    snapshot: {
+      pageUrl: "https://jobs.ashbyhq.com/livekit/application",
+      submitAlreadyClicked: true,
+      leaseHeld: true,
+    },
+  });
+  assert.equal(ambiguous.action, "submit_ambiguous");
+  assert.equal(ambiguous.exitCode, RESUME_EXIT.AWAITING_CONFIRM);
+});
+
+test("buildSubmitProbePlan and checklist are actionable", () => {
+  const plan = buildSubmitProbePlan("https://jobs.ashbyhq.com/x/application");
+  assert.equal(plan.adapterId, "ashby");
+  assert.ok(plan.submitSelectors.includes('button[type="submit"]'));
+  const lines = resumeSubmitChecklist();
+  assert.ok(lines.some((l) => /DISPLAY=:99/i.test(l)));
+  assert.ok(lines.some((l) => /intent-confirm|ledger add/i.test(l)));
+});

package/job-application-agent/tests/attention-runner-poll.test.mjs

@@ -0,0 +1,135 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  EXIT,
+  buildSignalPollUrl,
+  interpretPoll,
+  parseArgs,
+  pollAttentionSignal,
+  resolvePollConfig,
+} from "../scripts/attention-runner-poll.mjs";
+
+test("runner poll interprets resume/skip/abort with stable exit codes", () => {
+  assert.equal(interpretPoll({ resumeRequested: true, signal: "resume_requested" }).exitCode, EXIT.RESUME);
+  assert.equal(interpretPoll({ skipped: true, signal: "skipped" }).exitCode, EXIT.SKIPPED);
+  assert.equal(interpretPoll({ aborted: true, signal: "aborted" }).exitCode, EXIT.ABORTED);
+  assert.equal(interpretPoll({ signal: null, pending: false }).done, false);
+  assert.match(interpretPoll({ resumeRequested: true }).message, /visible confirmation/i);
+});
+
+test("resolvePollConfig derives site origin from notify URL", () => {
+  const cfg = resolvePollConfig({
+    ATTENTION_NOTIFY_SECRET: "secret",
+    ATTENTION_NOTIFY_URL: "https://jobappagent.com/api/internal/attention-notify",
+  });
+  assert.equal(cfg.siteUrl, "https://jobappagent.com");
+  assert.equal(
+    buildSignalPollUrl(cfg.siteUrl, "attention-1"),
+    "https://jobappagent.com/api/internal/attention-signals/attention-1",
+  );
+});
+
+test("parseArgs reads attention id, interval, timeout, once", () => {
+  const args = parseArgs(["--attention-id", "attention-x", "--interval", "3", "--timeout", "30", "--once"]);
+  assert.equal(args.attentionId, "attention-x");
+  assert.equal(args.intervalSec, 3);
+  assert.equal(args.timeoutSec, 30);
+  assert.equal(args.once, true);
+});
+
+test("pollAttentionSignal returns resume exit code and next-action message", async () => {
+  let calls = 0;
+  const result = await pollAttentionSignal({
+    attentionId: "attention-1",
+    siteUrl: "https://jobappagent.com",
+    secret: "test-secret",
+    intervalSec: 1,
+    timeoutSec: 10,
+    log: () => {},
+    sleep: async () => {},
+    fetchImpl: async () => {
+      calls += 1;
+      if (calls === 1) {
+        return Response.json({
+          attentionId: "attention-1",
+          signal: null,
+          pending: false,
+          resumeRequested: false,
+          skipped: false,
+          aborted: false,
+        });
+      }
+      return Response.json({
+        attentionId: "attention-1",
+        signal: "resume_requested",
+        pending: true,
+        resumeRequested: true,
+        skipped: false,
+        aborted: false,
+        updatedAt: "2026-09-16T00:00:00.000Z",
+      });
+    },
+  });
+  assert.equal(result.ok, true);
+  assert.equal(result.exitCode, EXIT.RESUME);
+  assert.equal(result.action, "resume");
+  assert.match(result.message, /renew cloud lease/i);
+});
+
+test("pollAttentionSignal fails closed without secret or on 401", async () => {
+  const missing = await pollAttentionSignal({
+    attentionId: "attention-1",
+    siteUrl: "https://jobappagent.com",
+    secret: "",
+    log: () => {},
+  });
+  assert.equal(missing.exitCode, EXIT.ERROR);
+
+  const unauthorized = await pollAttentionSignal({
+    attentionId: "attention-1",
+    siteUrl: "https://jobappagent.com",
+    secret: "bad",
+    once: true,
+    log: () => {},
+    fetchImpl: async () => new Response("nope", { status: 401 }),
+  });
+  assert.equal(unauthorized.exitCode, EXIT.ERROR);
+  assert.match(unauthorized.error, /unauthorized/i);
+});
+
+test("pollAttentionSignal exits skipped and aborted", async () => {
+  const skipped = await pollAttentionSignal({
+    attentionId: "attention-1",
+    siteUrl: "https://jobappagent.com",
+    secret: "s",
+    once: true,
+    log: () => {},
+    fetchImpl: async () => Response.json({
+      attentionId: "attention-1",
+      signal: "skipped",
+      pending: true,
+      resumeRequested: false,
+      skipped: true,
+      aborted: false,
+    }),
+  });
+  assert.equal(skipped.exitCode, EXIT.SKIPPED);
+
+  const aborted = await pollAttentionSignal({
+    attentionId: "attention-1",
+    siteUrl: "https://jobappagent.com",
+    secret: "s",
+    once: true,
+    log: () => {},
+    fetchImpl: async () => Response.json({
+      attentionId: "attention-1",
+      signal: "aborted",
+      pending: true,
+      resumeRequested: false,
+      skipped: false,
+      aborted: true,
+    }),
+  });
+  assert.equal(aborted.exitCode, EXIT.ABORTED);
+});

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

@@ -0,0 +1,22 @@
+import { initialOutreach, mutateOutreach } from '../../scripts/outreach-domain.mjs';
+export const now = '2026-09-16T10:00:00.000Z';
+export function assessment(id = 'opportunity-1', extra = {}) {
+  return { operationId: `assess-${id}`, id, company: { name: 'Example', domain: 'example.org', aliases: [] },
+    role: 'Staff Product Engineer', channel: 'linkedin', recipient: { account: 'https://www.linkedin.com/in/example-recruiter', aliases: [] },
+    source: { kind: 'hiring-post', url: 'https://example.org/jobs/1' },
+    qualification: { active: true, companyVerified: true, eligible: true, fit: true, affiliation: true, hiringInvolvement: true },
+    gateEvidence: { active: ['role'], companyVerified: ['role'], eligible: ['role'], fit: ['role', 'experience'], affiliation: ['role'], hiringInvolvement: ['role'] },
+    evidence: [{ id: 'role', kind: 'role', source: 'https://example.org/jobs/1', observedAt: now, text: 'Active eligible role; recruiter is hiring for this team.' },
+      { id: 'experience', kind: 'candidate', source: 'canonical-resume', observedAt: now, text: 'Verified product engineering experience.' }],
+    ranking: { hiringSignal: 4, responsibility: 3, fit: 3, freshness: 2, relationship: 0 }, ...extra };
+}
+export function fixture() {
+  let state = initialOutreach();
+  const run = (action, input) => { const result = mutateOutreach(state, action, input, { now, actor: 'test-host' }); state = result.state; return result.result; };
+  run('policy-enable', { operationId: 'enable', timezone: 'Asia/Kolkata' });
+  run('assess', assessment());
+  run('draft', { operationId: 'draft-1', id: 'opportunity-1', text: 'Your product engineering role fits my experience. Would a brief conversation be useful?', claimRefs: ['experience'], purpose: 'initial' });
+  return { run, get state() { return state; } };
+}
+export const handoff = (extra = {}) => ({ operationId: 'handoff-1', id: 'opportunity-1', draftRevision: 1, qualificationRevision: 1,
+  selectedByUser: true, recheckedAt: now, history: { kind: 'user-reported', noPriorPitch: true, checkedAt: now }, ...extra });

package/job-application-agent/tests/novnc-display-guard.test.mjs

@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import test from "node:test";
+
+import {
+  evaluateNovncDisplayGuard,
+  inspectNovncTargetText,
+  NOVNC_GUARD_EXIT,
+} from "../scripts/novnc-display-guard.mjs";
+
+test("inspectNovncTargetText finds fill vs forbidden ports", () => {
+  const good = inspectNovncTargetText("ExecStart=/usr/bin/websockify --web=/usr/share/novnc 6080 localhost:5900");
+  assert.equal(good.websockifyTargets[0].port, 5900);
+
+  const bad = inspectNovncTargetText("ExecStart=websockify 6080 localhost:5901");
+  assert.equal(bad.websockifyTargets[0].port, 5901);
+  assert.ok(bad.forbiddenPortMentions.length >= 1);
+});
+
+test("evaluateNovncDisplayGuard fails closed on 5901", () => {
+  const fail = evaluateNovncDisplayGuard({
+    text: "websockify 6080 127.0.0.1:5901",
+  });
+  assert.equal(fail.ok, false);
+  assert.ok(fail.errors.some((e) => /5901|TigerVNC/i.test(e)));
+
+  const ok = evaluateNovncDisplayGuard({
+    text: "websockify 6080 localhost:5900\nEnvironment=DISPLAY=:99",
+  });
+  assert.equal(ok.ok, true);
+  assert.equal(ok.targetPort, 5900);
+});
+
+test("evaluateNovncDisplayGuard accepts explicit target port", () => {
+  assert.equal(evaluateNovncDisplayGuard({ targetPort: 5900 }).ok, true);
+  assert.equal(evaluateNovncDisplayGuard({ targetPort: 5901 }).ok, false);
+});
+
+test("example novnc.service targets localhost:5900", async () => {
+  const path = fileURLToPath(new URL("../references/agent-box/novnc.service.example", import.meta.url));
+  const text = await readFile(path, "utf8");
+  const result = evaluateNovncDisplayGuard({ text });
+  assert.equal(result.ok, true);
+  assert.equal(result.targetPort, 5900);
+  assert.match(text, /localhost:5900/);
+  assert.match(text, /ExecStart=.*localhost:5900/);
+  assert.doesNotMatch(text.replace(/#.*$/gm, ""), /5901/);
+  assert.equal(NOVNC_GUARD_EXIT.FAIL, 1);
+});

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', () => {