job-application-agent 3.7.0 → 3.7.2

package/job-application-agent/scripts/outreach-round.mjs

@@ -0,0 +1,267 @@
+import { appendFile, chmod, mkdir, open, readFile, unlink } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { deliveryProjection } from './application-accounting.mjs';
+import { CloudStateClient, defaultCloudConfigPath } from './cloud-state-client.mjs';
+import { OUTREACH_CAPABILITY, readOutreach } from './outreach-domain.mjs';
+import { withLocalOutreach } from './outreach-store.mjs';
+
+export const OUTREACH_ROUND_CHANNEL = 'outreach';
+
+export function companyCountKey(value) {
+  return String(value ?? '').normalize('NFKC').toLowerCase().replace(/[^\p{L}\p{N}]+/gu, '');
+}
+
+export function hasActiveSentVerified(item) {
+  if (!item || item.cleared) return false;
+  const attempts = Array.isArray(item.attempts) ? item.attempts : [];
+  if (attempts.length > 0) return attempts.some((attempt) => attempt.delivery === 'sent-verified');
+  return item.delivery === 'sent-verified';
+}
+
+export function invalidatedOutreachIds(items = []) {
+  return items.filter((item) => item?.id && !item.cleared && !hasActiveSentVerified(item)).map((item) => item.id);
+}
+
+export function outreachConfirmationEvents(roundEvents, roundId) {
+  return roundEvents.filter((event) => event.type === 'submission-confirmed' && event.roundId === roundId && typeof event.outreachId === 'string' && event.outreachId && event.channel === OUTREACH_ROUND_CHANNEL);
+}
+
+export function countedApplyCompanies(applications, delivery) {
+  const companies = new Set();
+  applications.forEach((entry, index) => {
+    if (delivery.applications[index]?.counted) companies.add(companyCountKey(entry.company));
+  });
+  return companies;
+}
+
+export function sentVerifiedFromOutreachItems(items = []) {
+  return items.flatMap((item) => {
+    if (!hasActiveSentVerified(item)) return [];
+    const company = item.content?.assessment?.company?.name;
+    if (!company) return [];
+    return [{
+      id: item.id,
+      company,
+      role: item.content?.assessment?.role ?? null,
+      companyKey: companyCountKey(company),
+    }];
+  });
+}
+
+export function sentVerifiedFromOutreachState(state, now = new Date().toISOString()) {
+  if (!state?.opportunities) return [];
+  return sentVerifiedFromOutreachItems(Object.keys(state.opportunities).map((id) => readOutreach(state, 'show', { id }, now)));
+}
+
+export function resolveOutreachRoundId(roundEvents, { outreachId, roundId = null } = {}) {
+  const attached = roundEvents.find((event) => event.type === 'submission-confirmed' && event.outreachId === outreachId && event.channel === OUTREACH_ROUND_CHANNEL);
+  if (attached) {
+    if (roundId && attached.roundId !== roundId) {
+      throw new Error(`Outreach ${outreachId} is already attached to another round.`);
+    }
+    return attached.roundId;
+  }
+  if (roundId) return roundId;
+  const completed = new Set(roundEvents.filter((event) => event.type === 'completed').map((event) => event.roundId));
+  const open = roundEvents.filter((event) => event.type === 'started' && !completed.has(event.roundId));
+  return open.at(-1)?.roundId ?? null;
+}
+
+export function projectOutreachRoundCounts({ applications, delivery, roundEvents, sentVerified = [], roundId, invalidatedIds = [] }) {
+  const applyConfirmationCount = delivery.effectiveSubmissionCount;
+  const applyCompanies = countedApplyCompanies(applications, delivery);
+  const confirmations = outreachConfirmationEvents(roundEvents, roundId);
+  const invalidated = new Set(invalidatedIds);
+  const countedCompanies = new Set(applyCompanies);
+  const countedOutreachIds = [];
+  for (const event of confirmations) {
+    if (invalidated.has(event.outreachId)) continue;
+    const companyKey = companyCountKey(event.company);
+    if (countedCompanies.has(companyKey)) continue;
+    countedCompanies.add(companyKey);
+    countedOutreachIds.push(event.outreachId);
+  }
+  const outreachConfirmationCount = countedOutreachIds.length;
+  return {
+    applyConfirmationCount,
+    outreachConfirmationCount,
+    confirmedCount: applyConfirmationCount + outreachConfirmationCount,
+    countedOutreachIds,
+  };
+}
+
+function alreadyCountedOutreachCompany(confirmations, companyKey) {
+  return confirmations.some((event) => companyCountKey(event.company) === companyKey);
+}
+
+function confirmationItem(event) {
+  if (!event?.company) return undefined;
+  return { id: event.outreachId, company: event.company, companyKey: companyCountKey(event.company) };
+}
+
+function shouldCountOutreach({ sentVerified, applications, delivery, confirmations, outreachId }) {
+  const recorded = confirmations.find((event) => event.outreachId === outreachId);
+  if (recorded) {
+    return { count: false, reason: 'already-recorded', item: sentVerified.find((entry) => entry.id === outreachId) ?? confirmationItem(recorded) };
+  }
+  const item = sentVerified.find((entry) => entry.id === outreachId);
+  if (!item) return { count: false, reason: 'not-sent-verified' };
+  if (countedApplyCompanies(applications, delivery).has(item.companyKey)) return { count: false, reason: 'already-applied', item };
+  if (alreadyCountedOutreachCompany(confirmations, item.companyKey)) return { count: false, reason: 'already-counted-outreach', item };
+  return { count: true, item };
+}
+
+async function jsonLines(file) {
+  try {
+    return (await readFile(file, 'utf8')).split('\n').filter(Boolean).map((line, index) => {
+      try { return JSON.parse(line); } catch { throw new Error(`Invalid JSON on line ${index + 1} of ${basename(file)}.`); }
+    });
+  } catch (error) {
+    if (error.code === 'ENOENT') return [];
+    throw error;
+  }
+}
+
+async function withFileLock(directory, name, action) {
+  await mkdir(directory, { recursive: true, mode: 0o700 });
+  await chmod(directory, 0o700);
+  const lockPath = join(directory, `.${name}.lock`);
+  let handle;
+  for (let attempt = 0; attempt < 100; attempt += 1) {
+    try {
+      handle = await open(lockPath, 'wx', 0o600);
+      break;
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+  }
+  if (!handle) throw new Error(`Could not acquire ${name} ledger lock.`);
+  try { return await action(); }
+  finally {
+    await handle.close();
+    await unlink(lockPath).catch((error) => { if (error.code !== 'ENOENT') throw error; });
+  }
+}
+
+async function snapshotItemsFromCache(directory) {
+  try {
+    const cache = JSON.parse(await readFile(join(directory, 'outreach-cloud-cache.json'), 'utf8'));
+    return Array.isArray(cache?.snapshot?.items) ? cache.snapshot.items : [];
+  } catch (error) {
+    if (error.code === 'ENOENT') return [];
+    throw error;
+  }
+}
+
+function isOutreachMigrationRequired(error) {
+  return /\(409\): Outreach backend migration required/i.test(error.message) || /Outreach backend migration required/i.test(error.message);
+}
+
+function authoritativeSnapshotError(cause) {
+  const error = new Error('Outreach snapshot is unavailable; attachment requires authoritative state.');
+  if (cause) error.cause = cause;
+  return error;
+}
+
+export async function loadOutreachSnapshotItems(directory, cloudClient, { allowCache = true } = {}) {
+  const cloud = cloudClient ?? new CloudStateClient({ stateDir: directory, configPath: process.env.JOB_APPLICATION_AGENT_CLOUD_CONFIG ?? defaultCloudConfigPath() });
+  if (await cloud.configured()) {
+    try {
+      if (typeof cloud.status === 'function') {
+        const status = await cloud.status();
+        if (!status.capabilities?.includes(OUTREACH_CAPABILITY)) return [];
+      }
+      const snapshot = await (await cloud.request('/v2/outreach/snapshot')).json();
+      return Array.isArray(snapshot.items) ? snapshot.items : [];
+    } catch (error) {
+      if (isOutreachMigrationRequired(error)) return [];
+      if (!/^Cloud state unavailable:/.test(error.message)) throw error;
+      if (!allowCache) throw authoritativeSnapshotError(error);
+    }
+    if (!allowCache) throw authoritativeSnapshotError();
+    return snapshotItemsFromCache(directory);
+  }
+  try {
+    return await withLocalOutreach(directory, (state) => ({
+      result: Object.keys(state.opportunities).map((id) => readOutreach(state, 'show', { id })),
+    }));
+  } catch (error) {
+    if (error.code === 'ENOENT') return [];
+    const wrapped = new Error(`Outreach store is unavailable: ${error.message}`);
+    wrapped.cause = error;
+    throw wrapped;
+  }
+}
+
+export async function loadSentVerifiedOutreach(directory, cloudClient, options) {
+  return sentVerifiedFromOutreachItems(await loadOutreachSnapshotItems(directory, cloudClient, options));
+}
+
+export async function loadOutreachRoundView(directory, cloudClient, options) {
+  const items = await loadOutreachSnapshotItems(directory, cloudClient, options);
+  return {
+    sentVerified: sentVerifiedFromOutreachItems(items),
+    invalidatedIds: invalidatedOutreachIds(items),
+  };
+}
+
+export async function confirmOutreachTowardRound({
+  directory,
+  outreachId,
+  roundId = null,
+  cloudClient = null,
+  requireRoundId = false,
+  occurredAt = new Date().toISOString(),
+} = {}) {
+  const id = String(outreachId ?? '').trim();
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,99}$/.test(id)) throw new Error('Invalid opaque outreach ID.');
+  const cloud = cloudClient ?? new CloudStateClient({ stateDir: directory, configPath: process.env.JOB_APPLICATION_AGENT_CLOUD_CONFIG ?? defaultCloudConfigPath() });
+  return withFileLock(directory, 'rounds', async () => {
+    if (await cloud.configured()) {
+      try {
+        await cloud.reconcile({ dryRun: false, provenance: 'outreach-round-attach', streams: ['rounds'] });
+      } catch (error) {
+        if (!/^Cloud state unavailable:/.test(error.message)) throw error;
+      }
+    }
+    const roundEvents = await jsonLines(join(directory, 'rounds.ndjson'));
+    const targetRoundId = resolveOutreachRoundId(roundEvents, { outreachId: id, roundId });
+    if (!targetRoundId) return { counted: false, reason: requireRoundId ? 'round-not-found' : 'no-active-round', outreachId: id, roundId: null };
+    const started = roundEvents.find((event) => event.type === 'started' && event.roundId === targetRoundId);
+    if (!started) throw new Error('Application round was not found.');
+    if (roundEvents.some((event) => event.type === 'completed' && event.roundId === targetRoundId)) {
+      const existing = outreachConfirmationEvents(roundEvents, targetRoundId).some((event) => event.outreachId === id);
+      return { counted: existing, reason: existing ? 'already-recorded' : 'round-completed', outreachId: id, roundId: targetRoundId };
+    }
+    const applications = (await jsonLines(join(directory, 'applications.ndjson'))).filter((entry) => entry.roundId === targetRoundId && entry.status === 'submitted');
+    const delivery = deliveryProjection(applications, await jsonLines(join(directory, 'delivery.ndjson')));
+    const sentVerified = await loadSentVerifiedOutreach(directory, cloud, { allowCache: false });
+    const confirmations = outreachConfirmationEvents(roundEvents, targetRoundId);
+    const decision = shouldCountOutreach({ sentVerified, applications, delivery, confirmations, outreachId: id });
+    if (!decision.count) {
+      return { counted: decision.reason === 'already-recorded', reason: decision.reason, outreachId: id, roundId: targetRoundId, company: decision.item?.company ?? null };
+    }
+    const event = {
+      type: 'submission-confirmed',
+      roundId: targetRoundId,
+      outreachId: id,
+      channel: OUTREACH_ROUND_CHANNEL,
+      company: decision.item.company,
+      ...(decision.item.role ? { role: decision.item.role } : {}),
+      occurredAt,
+    };
+    const file = join(directory, 'rounds.ndjson');
+    await appendFile(file, `${JSON.stringify(event)}\n`, { mode: 0o600 });
+    await chmod(file, 0o600);
+    if (await cloud.configured()) {
+      await cloud.appendRecord('rounds', event, {
+        recordKey: targetRoundId,
+        idempotencyKey: `round-confirmation:${targetRoundId}:outreach:${id}`,
+        occurredAt,
+        queueOnFailure: true,
+      });
+    }
+    return { counted: true, reason: 'recorded', outreachId: id, roundId: targetRoundId, company: decision.item.company };
+  });
+}

package/job-application-agent/scripts/version.mjs

@@ -1 +1 @@
-export const SKILL_VERSION = '3.7.0';
+export const SKILL_VERSION = '3.7.2';

package/job-application-agent/tests/cloud-state-client.test.mjs

@@ -86,6 +86,18 @@ sqliteTest('reconcile includes the owner-only discovery review ledger', async ()
   assert.deepEqual((await ctx.client.listStream('discovery'))[0].value, lead);
 });
 
+sqliteTest('targeted reconcile only syncs the requested stream', async () => {
+  const ctx = await setup();
+  await writeFile(join(ctx.stateDir, 'applications.ndjson'), `${JSON.stringify({ id: 'app-1', company: 'A', submittedAt: '2026-01-01T00:00:00.000Z' })}\n`);
+  await writeFile(join(ctx.stateDir, 'rounds.ndjson'), `${JSON.stringify({ type: 'started', roundId: 'round-1', requestedCount: 1, occurredAt: '2026-01-01T00:00:00.000Z' })}\n`);
+  const report = await ctx.client.reconcile({ dryRun: false, streams: ['rounds'] });
+  assert.equal(report.imported, 1);
+  assert.ok(report.streams.rounds);
+  assert.equal(report.streams.applications, undefined);
+  assert.equal((await ctx.bindings.DB.prepare("SELECT COUNT(*) AS count FROM records WHERE stream = 'applications'").first()).count, 0);
+  assert.equal((await ctx.bindings.DB.prepare("SELECT COUNT(*) AS count FROM records WHERE stream = 'rounds'").first()).count, 1);
+});
+
 sqliteTest('resume download verifies checksum and creates a private path cache', async () => {
   const ctx = await setup();
   const bytes = Buffer.from('%PDF-1.7\ncloud-resume-fixture');

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

@@ -7,7 +7,7 @@ import test from 'node:test';
 import { fileURLToPath } from 'node:url';
 import { createServer } from 'node:http';
 
-import { buildReview, commandCategory, durationBucket, migrateProfile, profileStatus, scoreJob, telemetryErrorCode, telemetryJobAssessed, validateLedgerEntry, validateProfile, validateSubmissionTelemetry } from '../scripts/job-application.mjs';
+import { buildReview, commandCategory, durationBucket, migrateProfile, profileStatus, scoreJob, telemetryErrorCode, telemetryJobAssessed, validateLedgerCheckCandidate, validateLedgerEntry, validateProfile, validateSubmissionTelemetry } from '../scripts/job-application.mjs';
 
 const target = {
   name: 'Test Candidate',
@@ -347,6 +347,164 @@ test('warns on same-company role matches and serializes concurrent duplicate sub
   assert.equal(possible.possibleDuplicate, true);
 });
 
+test('accepts any one ledger check identifier set and never hard-matches company+role', () => {
+  assert.deepEqual(validateLedgerCheckCandidate({ url: 'https://jobs.example.com/123' }), { url: 'https://jobs.example.com/123' });
+  assert.deepEqual(validateLedgerCheckCandidate({ id: 'example-role-1' }), { id: 'example-role-1' });
+  assert.deepEqual(validateLedgerCheckCandidate({ employerJobId: 'example:123', company: 'Example' }), {
+    employerJobId: 'example:123', company: 'Example',
+  });
+  assert.deepEqual(validateLedgerCheckCandidate({ company: 'Example', role: 'Senior Product Engineer' }), {
+    company: 'Example', role: 'Senior Product Engineer',
+  });
+  const identifierError = /ledger check requires at least one identifier set: url, id, employerJobId\+company, or company\+role/;
+  assert.throws(() => validateLedgerCheckCandidate({}), identifierError);
+  assert.throws(() => validateLedgerCheckCandidate({ company: 'Example' }), identifierError);
+  assert.throws(() => validateLedgerCheckCandidate({ role: 'Senior Product Engineer' }), identifierError);
+  assert.throws(() => validateLedgerCheckCandidate({ employerJobId: 'example:123' }), identifierError);
+  try {
+    validateLedgerCheckCandidate({});
+  } catch (error) {
+    assert.match(error.message, identifierError);
+    assert.doesNotMatch(error.message, /candidate\.url must/);
+  }
+  assert.throws(() => validateLedgerCheckCandidate({ url: 'not-a-url' }), /Invalid URL|invalid/i);
+  assert.throws(() => validateLedgerCheckCandidate({ id: 'example-role-1', url: 123 }), /candidate\.url must/);
+  assert.throws(() => validateLedgerCheckCandidate({ id: 'example-role-1', url: null }), /candidate\.url must/);
+});
+
+test('looks up ledger rows without requiring a URL on check', async (t) => {
+  const directory = await mkdtemp(join(tmpdir(), 'public-job-agent-check-lookup-'));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const script = fileURLToPath(new URL('../scripts/job-application.mjs', import.meta.url));
+  await writeFile(join(directory, 'telemetry.json'), JSON.stringify({ version: 1, enabled: false, disclosed: true, graceConsumed: true, installationEventPending: false }));
+  const storedUrl = 'https://jobs.example.com/123';
+  await writeFile(join(directory, 'applications.ndjson'), `${JSON.stringify({
+    id: 'example-role-1', company: 'Example', role: 'Senior Product Engineer', url: storedUrl, source: 'company', score: 88,
+    status: 'submitted', submittedAt: '2026-01-15T10:00:00Z', approval: 'STANDING AUTHORIZATION', answers: {}, employerJobId: 'example:123',
+  })}\n`);
+  const env = isolatedCliEnv(directory);
+
+  const byUrl = JSON.parse(execFileSync(process.execPath, [script, 'ledger', 'check', '--stdin'], {
+    input: JSON.stringify({ url: 'https://jobs.example.com/123?utm_source=board' }), env, encoding: 'utf8',
+  }));
+  assert.equal(byUrl.duplicate, true);
+  assert.equal(byUrl.reason, 'url');
+
+  const byId = JSON.parse(execFileSync(process.execPath, [script, 'ledger', 'check', '--stdin'], {
+    input: JSON.stringify({ id: 'example-role-1' }), env, encoding: 'utf8',
+  }));
+  assert.equal(byId.duplicate, true);
+  assert.equal(byId.possibleDuplicate, false);
+  assert.equal(byId.reason, 'id');
+  assert.equal(byId.match.url, storedUrl);
+
+  const byEmployerJob = JSON.parse(execFileSync(process.execPath, [script, 'ledger', 'check', '--stdin'], {
+    input: JSON.stringify({ employerJobId: 'example:123', company: 'Example' }), env, encoding: 'utf8',
+  }));
+  assert.equal(byEmployerJob.duplicate, true);
+  assert.equal(byEmployerJob.possibleDuplicate, false);
+  assert.equal(byEmployerJob.reason, 'employer-job-id');
+
+  const newerUrl = 'https://jobs.example.com/123-new';
+  await writeFile(join(directory, 'applications.ndjson'), `${JSON.stringify({
+    id: 'example-role-1', company: 'Example', role: 'Senior Product Engineer', url: storedUrl, source: 'company', score: 88,
+    status: 'submitted', submittedAt: '2026-01-15T10:00:00Z', approval: 'STANDING AUTHORIZATION', answers: {}, employerJobId: 'example:123',
+  })}\n${JSON.stringify({
+    id: 'example-role-1b', company: 'Example', role: 'Senior Product Engineer', url: newerUrl, source: 'company', score: 88,
+    status: 'submitted', submittedAt: '2026-02-01T10:00:00Z', approval: 'STANDING AUTHORIZATION', answers: {},
+  })}\n`);
+
+  const byCompanyRole = JSON.parse(execFileSync(process.execPath, [script, 'ledger', 'check', '--stdin'], {
+    input: JSON.stringify({ company: 'Example', role: 'Senior Product Engineer' }), env, encoding: 'utf8',
+  }));
+  assert.equal(byCompanyRole.duplicate, false);
+  assert.equal(byCompanyRole.possibleDuplicate, true);
+  assert.equal(byCompanyRole.reason, 'company-role');
+  assert.equal(byCompanyRole.match.url, newerUrl);
+  assert.equal(byCompanyRole.match.id, 'example-role-1b');
+
+  const seniorUrl = 'https://jobs.example.com/senior';
+  const staffUrl = 'https://jobs.example.com/staff';
+  await writeFile(join(directory, 'applications.ndjson'), `${JSON.stringify({
+    id: 'example-senior', company: 'Example', role: 'Senior Software Engineer', url: seniorUrl, source: 'company', score: 88,
+    status: 'submitted', submittedAt: '2026-01-10T10:00:00Z', approval: 'STANDING AUTHORIZATION', answers: {},
+  })}\n${JSON.stringify({
+    id: 'example-staff', company: 'Example', role: 'Staff Software Engineer', url: staffUrl, source: 'company', score: 90,
+    status: 'submitted', submittedAt: '2026-02-10T10:00:00Z', approval: 'STANDING AUTHORIZATION', answers: {},
+  })}\n`);
+  const exactSenior = JSON.parse(execFileSync(process.execPath, [script, 'ledger', 'check', '--stdin'], {
+    input: JSON.stringify({ company: 'Example', role: 'Senior Software Engineer' }), env, encoding: 'utf8',
+  }));
+  assert.equal(exactSenior.possibleDuplicate, true);
+  assert.equal(exactSenior.match.id, 'example-senior');
+  assert.equal(exactSenior.match.url, seniorUrl);
+
+  await writeFile(join(directory, 'applications.ndjson'), `${JSON.stringify({
+    id: 'example-backend', company: 'Example', role: 'Backend Engineer', url: 'https://jobs.example.com/backend', source: 'company', score: 84,
+    status: 'submitted', submittedAt: '2026-01-05T10:00:00Z', approval: 'STANDING AUTHORIZATION', answers: {},
+  })}\n${JSON.stringify({
+    id: 'example-frontend', company: 'Example', role: 'Frontend Engineer', url: 'https://jobs.example.com/frontend', source: 'company', score: 85,
+    status: 'submitted', submittedAt: '2026-03-01T10:00:00Z', approval: 'STANDING AUTHORIZATION', answers: {},
+  })}\n`);
+  const ambiguousEngineer = JSON.parse(execFileSync(process.execPath, [script, 'ledger', 'check', '--stdin'], {
+    input: JSON.stringify({ company: 'Example', role: 'Engineer' }), env, encoding: 'utf8',
+  }));
+  assert.equal(ambiguousEngineer.duplicate, false);
+  assert.equal(ambiguousEngineer.possibleDuplicate, true);
+  assert.equal(ambiguousEngineer.reason, 'company-role');
+  assert.equal(ambiguousEngineer.match, null);
+
+  const identifierError = /ledger check requires at least one identifier set: url, id, employerJobId\+company, or company\+role/;
+  for (const input of [{}, { company: 'Example' }, { role: 'Senior Product Engineer' }]) {
+    const failed = await runCli(script, ['ledger', 'check', '--stdin'], input, env);
+    assert.equal(failed.code, 1);
+    assert.match(failed.stderr, identifierError);
+    assert.doesNotMatch(failed.stderr, /candidate\.url must/);
+  }
+
+  const malformedUrl = await runCli(script, ['ledger', 'check', '--stdin'], { id: 'example-role-1', url: 123 }, env);
+  assert.equal(malformedUrl.code, 1);
+  assert.match(malformedUrl.stderr, /candidate\.url must/);
+
+  assert.equal(byId.sameCompany, true);
+  assert.equal(byId.companyApplications.length, 1);
+  assert.equal(byId.companyApplications[0].id, 'example-role-1');
+
+  const invalidUrl = await runCli(script, ['ledger', 'check', '--stdin'], { url: 'not-a-url' }, env);
+  assert.equal(invalidUrl.code, 1);
+  assert.match(invalidUrl.stderr, /Invalid URL|invalid/i);
+
+  const missingAddUrl = await runCli(script, ['ledger', 'add', '--stdin'], {
+    id: 'example-role-2', company: 'Example', role: 'Staff Engineer', source: 'company', score: 80,
+    status: 'submitted', submittedAt: '2026-01-16T10:00:00Z', approval: 'STANDING AUTHORIZATION', answers: {},
+  }, env);
+  assert.equal(missingAddUrl.code, 1);
+  assert.match(missingAddUrl.stderr, /entry\.url must/);
+});
+
+test('records mail and looks up company+role in separate CLI processes', async (t) => {
+  const directory = await mkdtemp(join(tmpdir(), 'public-job-agent-outcome-then-check-'));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const script = fileURLToPath(new URL('../scripts/job-application.mjs', import.meta.url));
+  await writeFile(join(directory, 'telemetry.json'), JSON.stringify({ version: 1, enabled: false, disclosed: true, graceConsumed: true, installationEventPending: false }));
+  const storedUrl = 'https://jobs.example.com/apollo-1';
+  await writeFile(join(directory, 'applications.ndjson'), `${JSON.stringify({
+    id: 'apollo-role-1', company: 'Apollo', role: 'Staff Engineer', url: storedUrl, source: 'company', score: 90,
+    status: 'submitted', submittedAt: '2026-01-15T10:00:00Z', approval: 'STANDING AUTHORIZATION', answers: {},
+  })}\n`);
+  const env = isolatedCliEnv(directory);
+  const outcome = JSON.parse(execFileSync(process.execPath, [script, 'ledger', 'outcome', '--stdin'], {
+    input: JSON.stringify({ id: 'apollo-role-1', status: 'rejected', occurredAt: '2026-01-20T09:00:00Z' }), env, encoding: 'utf8',
+  }));
+  assert.equal(outcome.recorded, true);
+  const check = JSON.parse(execFileSync(process.execPath, [script, 'ledger', 'check', '--stdin'], {
+    input: JSON.stringify({ company: 'Apollo', role: 'Staff Engineer' }), env, encoding: 'utf8',
+  }));
+  assert.equal(check.duplicate, false);
+  assert.equal(check.possibleDuplicate, true);
+  assert.equal(check.match.url, storedUrl);
+});
+
 test('records structured outcomes idempotently without duplicate rows', async (t) => {
   const directory = await mkdtemp(join(tmpdir(), 'public-job-agent-outcomes-'));
   t.after(() => rm(directory, { recursive: true, force: true }));