job-application-agent 3.4.2 → 3.5.0

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

@@ -7,6 +7,7 @@ import { platform } from 'node:os';
 import { basename, join, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 
+import { ACCOUNTING_CAPABILITY, accountingApplicationKey, canonicalUrl, deliveryProjection, discoveryProjection, validateDelivery, validateDeliveryReferences, validateLead, validateLeadReferences, stableJson } from './application-accounting.mjs';
 import { createSecretStore, migrateLegacyStateDir, resolveStateDir } from './secret-store.mjs';
 import { SourceCommunityClient } from './source-community-client.mjs';
 import { normalizeCommunityJob, normalizeCommunitySource } from './source-community-schema.mjs';
@@ -506,12 +507,7 @@ function rolesLikelySame(left, right) {
   return shared / Math.min(leftTokens.size, rightTokens.size) >= 0.75;
 }
 
-function canonicalApplicationKey(entry, fallback = '') {
-  if (entry.employerJobId) return `job:${normalizedText(entry.company)}:${String(entry.employerJobId).toLowerCase()}`;
-  if (entry.company && entry.role) return `legacy-role:${normalizedText(entry.company)}:${normalizedText(entry.role)}`;
-  if (entry.url) return `url:${normalizeUrl(entry.url)}`;
-  return `id:${entry.id ?? fallback}`;
-}
+const canonicalApplicationKey = accountingApplicationKey;
 
 function businessDaysBetween(startValue, endValue) {
   const start = new Date(startValue);
@@ -525,8 +521,10 @@ function businessDaysBetween(startValue, endValue) {
   return days;
 }
 
-export function buildReview(entries, outcomeEntries = [], acknowledgements = [], now = new Date()) {
+export function buildReview(entries, outcomeEntries = [], acknowledgements = [], now = new Date(), deliveryEvents = []) {
   const submissions = entries.filter((entry) => !Number.isNaN(Date.parse(entry.submittedAt)));
+  const delivery = deliveryProjection(submissions, deliveryEvents);
+  const effectiveKeys = new Set(submissions.filter((entry, i) => delivery.applications[i].counted).map(canonicalApplicationKey));
   const explicitOutcomes = outcomeEntries.length > 0;
   const outcomes = explicitOutcomes ? outcomeEntries : entries.filter((entry) => ['interview', 'rejected', 'offer', 'withdrawn'].includes(entry.status));
   const groups = new Map();
@@ -535,7 +533,8 @@ export function buildReview(entries, outcomeEntries = [], acknowledgements = [],
     if (!groups.has(key)) groups.set(key, []);
     groups.get(key).push(entry);
   });
-  const canonical = [...groups.values()].map((group) => [...group].sort((a, b) => Date.parse(a.submittedAt) - Date.parse(b.submittedAt))[0]);
+  const recordedCanonical = [...groups.values()].map(group => [...group].sort((a, b) => Date.parse(a.submittedAt) - Date.parse(b.submittedAt))[0]);
+  const canonical = [...groups].filter(([key]) => effectiveKeys.has(key)).map(([,group]) => [...group].sort((a, b) => Date.parse(a.submittedAt) - Date.parse(b.submittedAt))[0]);
   const outcomesById = new Map();
   for (const outcome of outcomes) {
     if (!outcomesById.has(outcome.id)) outcomesById.set(outcome.id, []);
@@ -544,7 +543,7 @@ export function buildReview(entries, outcomeEntries = [], acknowledgements = [],
   const canonicalOutcomes = [];
   const matureCanonicalOutcomes = [];
   const canonicalInterviewDetails = [];
-  for (const group of groups.values()) {
+  for (const [groupKey, group] of groups) {
     const candidates = explicitOutcomes
       ? group.flatMap((entry) => outcomesById.get(entry.id) ?? [])
       : group.filter((entry) => ['interview', 'rejected', 'offer', 'withdrawn'].includes(entry.status));
@@ -559,14 +558,15 @@ export function buildReview(entries, outcomeEntries = [], acknowledgements = [],
         source: canonicalApplication.source,
         score: canonicalApplication.score,
       });
-      if (businessDaysBetween(canonicalApplication.submittedAt, now) >= 10) matureCanonicalOutcomes.push(latest);
+      if (effectiveKeys.has(groupKey) && businessDaysBetween(canonicalApplication.submittedAt, now) >= 10) matureCanonicalOutcomes.push(latest);
     }
   }
   const maturedApplications = canonical.filter((entry) => businessDaysBetween(entry.submittedAt, now) >= 10).length;
   const lastAck = acknowledgements.length ? acknowledgements[acknowledgements.length - 1] : {};
-  const submittedSinceLastReview = Math.max(0, canonical.length - (lastAck.uniqueSubmissionCount ?? 0));
+  const recordedMaturedApplicationCount = recordedCanonical.filter(entry => businessDaysBetween(entry.submittedAt, now) >= 10).length;
+  const submittedSinceLastReview = Math.max(0, recordedCanonical.length - (lastAck.uniqueSubmissionCount ?? 0));
   const hygieneDue = submittedSinceLastReview >= 10;
-  const outcomeDue = maturedApplications - (lastAck.maturedApplicationCount ?? 0) >= 20;
+  const outcomeDue = recordedMaturedApplicationCount - (lastAck.maturedApplicationCount ?? 0) >= 20;
   const reviewReasons = [...(hygieneDue ? ['submission-hygiene'] : []), ...(outcomeDue ? ['outcome-effectiveness'] : [])];
   const outcomeCounts = Object.fromEntries(['interview', 'rejected', 'offer', 'withdrawn'].map((status) => [status, canonicalOutcomes.filter((entry) => entry.status === status).length]));
   const matureOutcomeCounts = Object.fromEntries(['interview', 'rejected', 'offer', 'withdrawn'].map((status) => [status, matureCanonicalOutcomes.filter((entry) => entry.status === status).length]));
@@ -598,9 +598,14 @@ export function buildReview(entries, outcomeEntries = [], acknowledgements = [],
     submittedTotal: canonical.length,
     uniqueSubmittedTotal: canonical.length,
     rawSubmissionRows: submissions.length,
-    duplicateSubmissionRows: submissions.length - canonical.length,
+    duplicateSubmissionRows: submissions.length - groups.size,
+    recordedSubmissionCount: groups.size,
+    effectiveSubmissionCount: canonical.length,
+    failedDeliveryCount: delivery.failedDeliveryCount,
+    receiptUnknownEmailCount: delivery.receiptUnknownEmailCount,
     submittedSinceLastReview,
     maturedApplications,
+    recordedMaturedApplicationCount,
     outcomeCounts,
     matureOutcomeCounts,
     reasonCounts,
@@ -1081,7 +1086,7 @@ async function ledgerAdd(entryInput, duplicateOverride, companyReapplyOverride,
         if (entry.roundId) await cloudState.appendRecord('rounds', { type: 'submission-confirmed', roundId: entry.roundId, applicationId: entry.id, occurredAt: entry.submittedAt }, { recordKey: entry.roundId, idempotencyKey: `round-confirmation:${entry.roundId}:${entry.id}`, occurredAt: entry.submittedAt, queueOnFailure: true });
       }
     }
-    return { recorded: storedEntry.id, review: buildReview([...entries, storedEntry]), ...(cloudIntent ? { cloudIntent: cloudIntent.intentId } : {}) };
+    return { recorded: storedEntry.id, review: buildReview([...entries, storedEntry], outcomes, [], new Date(), await jsonLines(join(dir, 'delivery.ndjson'))), ...(cloudIntent ? { cloudIntent: cloudIntent.intentId } : {}) };
   });
 }
 
@@ -1107,6 +1112,63 @@ function isoDate(value, label) {
   return result;
 }
 
+async function appendAccounting(stream, event, { cloudConfirmed = false } = {}) {
+  const file = join(await ensureStateDir(), `${stream}.ndjson`);
+  const previous = await jsonLines(file);
+  const matches = previous.filter(e => e.id === event.id);
+  if (matches.some(e => stableJson(e) !== stableJson(event))) throw new Error('Conflicting accounting event ID.');
+  if (matches.length) return { recorded: false, duplicate: true, event };
+  await appendFile(file, `${JSON.stringify(event)}\n`, { mode: 0o600 });
+  await chmod(file, 0o600);
+  if (!cloudConfirmed && await cloudState.configured()) await cloudState.appendRecord(stream, event, { recordKey: event.id, idempotencyKey: `accounting:${event.id}`, occurredAt: event.occurredAt ?? event.observedAt, queueOnFailure: true });
+  return { recorded: true, duplicate: false, event };
+}
+
+async function recordDelivery(input, retry = false) {
+  const { cloudIntentId, cloudLeaseId, ...raw } = object(input, 'delivery');
+  const event = validateDelivery({ ...raw, ...(retry ? { type: 'retry-confirmed' } : {}) });
+  if (!retry && event.type === 'retry-confirmed') throw new Error('Use ledger retry for replacement transmissions.');
+  return withStateLock('applications', () => withStateLock('delivery', async dir => {
+    const applications = await jsonLines(join(dir, 'applications.ndjson'));
+    const events = await jsonLines(join(dir, 'delivery.ndjson'));
+    const cloudRetry = retry && await cloudState.configured();
+    if (cloudRetry && !events.some(e => e.id === event.id) && (!cloudIntentId || !cloudLeaseId || event.attemptId !== cloudIntentId)) throw new Error('Cloud retry requires its intent and live lease; attemptId must equal cloudIntentId.');
+    // Cloud transmission eligibility was checked at intent preparation. The
+    // Worker verifies that intent before we persist the observed transmission.
+    validateDeliveryReferences(event, applications, events, { preparedRetry: cloudRetry });
+    let cloudConfirmed = false;
+    if (cloudRetry && !events.some(e => e.id === event.id)) {
+      await cloudState.confirmRetry(cloudIntentId, event, cloudLeaseId);
+      cloudConfirmed = true;
+    }
+    const result = await appendAccounting('delivery', event, { cloudConfirmed });
+    return { ...result, delivery: deliveryProjection(applications, [...events, event]) };
+  }));
+}
+async function deliveryHistory(applicationId) {
+  const dir = await ensureStateDir();
+  const apps = (await jsonLines(join(dir, 'applications.ndjson'))).filter(a => !applicationId || a.id === applicationId);
+  const events = (await jsonLines(join(dir, 'delivery.ndjson'))).filter(e => !applicationId || e.applicationId === applicationId);
+  return { ...deliveryProjection(apps, events), events };
+}
+async function recordLead(input) {
+  const event = validateLead(input);
+  knownDiscoverySourceId(event.sourceId, 'lead.sourceId');
+  return withStateLock('rounds', async dir => {
+    const round = await roundStatus(event.roundId);
+    const events = await jsonLines(join(dir, 'discovery.ndjson'));
+    if (round.completed && !event.supersedes && !events.some(e => e.id === event.id)) throw new Error('Completed rounds accept only corrections to existing leads.');
+    validateLeadReferences(event, events);
+    return appendAccounting('discovery', event);
+  });
+}
+async function leadHistory(roundId) {
+  const dir = await ensureStateDir();
+  const id = roundId ?? (await roundStatus()).roundId;
+  const history = (await jsonLines(join(dir, 'discovery.ndjson'))).filter(e => e.roundId === id);
+  return { ...discoveryProjection(history, { roundId: id }), history };
+}
+
 async function roundStart(input) {
   const value = object(input, 'round');
   const allowed = new Set(['requestedCount', 'startedAt']);
@@ -1114,6 +1176,7 @@ async function roundStart(input) {
   const event = {
     type: 'started',
     roundId: `round-${new Date().toISOString().slice(0, 10)}-${randomUUID()}`,
+    discoveryPolicyVersion: 2,
     requestedCount: integer(value.requestedCount, 'round.requestedCount', 1, 1000),
     occurredAt: isoDate(value.startedAt, 'round.startedAt'),
   };
@@ -1127,7 +1190,7 @@ function discoveryGroup(id) {
   return id;
 }
 
-function discoverySummary(events, applications, completion) {
+function discoverySummary(events, applications, completion, audit = null) {
   const latest = new Map();
   const searchedIds = new Set();
   const attribution = new Map();
@@ -1136,7 +1199,10 @@ function discoverySummary(events, applications, completion) {
     if (event.status === 'searched') searchedIds.add(event.sourceId);
     for (const id of event.applicationIds ?? []) attribution.set(id, event.sourceId);
   }
-  const sources = [...latest.values()];
+  const sources = [...latest.values()].map(report => {
+    const leads = audit?.leads.filter(lead => lead.sourceId === report.sourceId) ?? [];
+    return audit ? { ...report, reviewedCount: leads.length, qualifiedCount: leads.filter(lead => !lead.conflict && lead.disposition === 'qualified').length, accounting: 'per-lead' } : { ...report, accounting: 'legacy-unverified' };
+  });
   const eligible = sources.filter((item) => !['recruiter-inbound', 'user-supplied-leads'].includes(item.sourceId));
   const attempted = new Set(eligible.map((item) => discoveryGroup(item.sourceId)));
   const searched = new Set(eligible.filter((item) => searchedIds.has(item.sourceId)).map((item) => discoveryGroup(item.sourceId)));
@@ -1172,17 +1238,23 @@ async function roundSource(input) {
   const sourceId = knownDiscoverySourceId(value.sourceId, 'coverage.sourceId');
   const status = string(value.status, 'coverage.status', 20);
   if (!['searched', 'blocked'].includes(status)) throw new Error('coverage.status must be searched or blocked.');
-  const reviewedCount = integer(value.reviewedCount, 'coverage.reviewedCount', 0, 10000);
-  const qualifiedCount = integer(value.qualifiedCount, 'coverage.qualifiedCount', 0, reviewedCount);
+  const roundId = string(value.roundId, 'coverage.roundId', 180);
   const blocker = value.blocker == null ? null : string(value.blocker, 'coverage.blocker', 40);
-  if (status === 'blocked' && (!SOURCE_BLOCKERS.has(blocker) || reviewedCount !== 0 || qualifiedCount !== 0)) throw new Error('Blocked sources require a documented blocker and zero counts.');
   if (status === 'searched' && blocker != null) throw new Error('Searched sources cannot have a blocker.');
   const evidence = string(value.evidence, 'coverage.evidence', 2000);
   const applicationIds = value.applicationIds == null ? [] : [...new Set(stringArray(value.applicationIds, 'coverage.applicationIds'))];
   if (applicationIds.length > 1000 || (status === 'blocked' && applicationIds.length)) throw new Error('Invalid coverage.applicationIds.');
   const event = await withStateLock('rounds', async (dir) => {
-    const round = await roundStatus(string(value.roundId, 'coverage.roundId', 180));
+    const round = await roundStatus(roundId);
     if (round.completed) throw new Error('Cannot record coverage for a completed round.');
+    const audit = discoveryProjection(await jsonLines(join(dir, 'discovery.ndjson')), { roundId: value.roundId });
+    const leads = audit.leads.filter(lead => lead.sourceId === sourceId);
+    const derivedReviewed = status === 'blocked' ? 0 : leads.length;
+    const derivedQualified = status === 'blocked' ? 0 : leads.filter(lead => !lead.conflict && lead.disposition === 'qualified').length;
+    const reviewedCount = round.discoveryPolicyVersion === 2 ? derivedReviewed : integer(value.reviewedCount, 'coverage.reviewedCount', 0, 10000);
+    const qualifiedCount = round.discoveryPolicyVersion === 2 ? derivedQualified : integer(value.qualifiedCount, 'coverage.qualifiedCount', 0, reviewedCount);
+    if (round.discoveryPolicyVersion === 2 && ((value.reviewedCount != null && value.reviewedCount !== reviewedCount) || (value.qualifiedCount != null && value.qualifiedCount !== qualifiedCount))) throw new Error('Source count assertions do not match recorded leads.');
+    if (status === 'blocked' && (!SOURCE_BLOCKERS.has(blocker) || reviewedCount !== 0 || qualifiedCount !== 0)) throw new Error('Blocked sources require a documented blocker and zero counts.');
     const applications = await jsonLines(join(dir, 'applications.ndjson'));
     for (const id of applicationIds) {
       const entry = applications.find((item) => item.id === id && item.roundId === round.roundId && item.status === 'submitted');
@@ -1217,6 +1289,16 @@ function replayAttention(events, roundId = null) {
 async function attentionList(roundId = null) {
   const events = await jsonLines(join(await ensureStateDir(), 'attention.ndjson'));
   const items = replayAttention(events, roundId);
+  const dir = await ensureStateDir();
+  const apps = await jsonLines(join(dir, 'applications.ndjson'));
+  const delivery = deliveryProjection(apps, await jsonLines(join(dir, 'delivery.ndjson')));
+  for (const item of delivery.applications.filter(a => a.failed || a.conflict)) {
+    const app = apps.find(a => a.id === item.applicationId);
+    if (roundId && app.roundId !== roundId) continue;
+    items.push({ id: `delivery:${app.id}`, applicationId: app.id, roundId: app.roundId ?? null, url: app.url, stage: 'confirmation', blocker: item.conflict ? 'delivery-conflict' : 'delivery-failed', requiredActions: ['review-delivery'], derived: true });
+  }
+  const discovery = discoveryProjection(await jsonLines(join(dir, 'discovery.ndjson')), { roundId });
+  for (const lead of discovery.leads.filter(l => l.conflict)) items.push({ id: `discovery:${lead.key}`, roundId: lead.roundId, url: lead.url, stage: 'discovery', blocker: 'assessment-conflict', requiredActions: ['review-assessment'], derived: true });
   return { count: items.length, items };
 }
 
@@ -1251,6 +1333,7 @@ async function attentionResolve(input) {
   for (const key of Object.keys(value)) if (!allowed.has(key)) throw new Error(`Unknown attention resolution property: ${key}.`);
   const id = string(value.id, 'attention.id', 180);
   const current = await attentionList();
+  if (current.items.some(item => item.id === id && item.derived)) throw new Error('Resolve accounting attention with a delivery correction, verified recovery, or lead revision.');
   if (!current.items.some((item) => item.id === id)) throw new Error('Attention item is not active.');
   const event = { type: 'resolved', id, resolvedAt: isoDate(value.resolvedAt, 'attention.resolvedAt') };
   await appendPrivateEvent('attention', event);
@@ -1267,7 +1350,11 @@ async function roundStatus(roundId = null) {
   if (!started) throw new Error('Application round was not found.');
   const matching = (await jsonLines(join(dir, 'applications.ndjson'))).filter((entry) => entry.roundId === id && entry.status === 'submitted');
   const applications = [...new Map(matching.map((entry, index) => [canonicalApplicationKey(entry, String(index)), entry])).values()];
-  const confirmedCount = new Set(applications.map((entry, index) => canonicalApplicationKey(entry, String(index)))).size;
+  const delivery = deliveryProjection(matching, await jsonLines(join(dir, 'delivery.ndjson')));
+  const effectiveKeys = new Set(matching.filter((entry,i) => delivery.applications[i].counted).map(canonicalApplicationKey));
+  const effectiveApplications = applications.filter(entry => effectiveKeys.has(canonicalApplicationKey(entry)));
+  const confirmedCount = delivery.effectiveSubmissionCount;
+  const audit = started.discoveryPolicyVersion === 2 ? discoveryProjection(await jsonLines(join(dir, 'discovery.ndjson')), { roundId: id }) : null;
   const attention = await attentionList(id);
   const completion = events.find((event) => event.type === 'completed' && event.roundId === id);
   return {
@@ -1277,7 +1364,16 @@ async function roundStatus(roundId = null) {
     remainingCount: Math.max(0, started.requestedCount - confirmedCount),
     blockedCount: attention.count,
     completed: Boolean(completion),
-    discovery: discoverySummary(events.filter((event) => event.roundId === id), applications, completion),
+    discoveryPolicyVersion: started.discoveryPolicyVersion ?? 1,
+    recordedSubmissionCount: delivery.recordedSubmissionCount,
+    effectiveSubmissionCount: confirmedCount,
+    failedDeliveryCount: delivery.failedDeliveryCount,
+    receiptUnknownEmailCount: delivery.receiptUnknownEmailCount,
+    shortfallCount: Math.max(0, started.requestedCount - confirmedCount),
+    needsRecovery: Boolean(completion) && confirmedCount < started.requestedCount,
+    discovery: { ...discoverySummary(events.filter((event) => event.roundId === id), effectiveApplications, completion, audit),
+      ...(audit ? { reviewedCount: audit.reviewedCount, qualifiedCount: audit.qualifiedCount, uniqueLeadCount: audit.uniqueLeadCount, dispositionCounts: audit.dispositionCounts, conflicts: audit.conflicts,
+        missingLeadApplicationIds: effectiveApplications.filter(app => !audit.leads.some(lead => !lead.conflict && lead.disposition === 'qualified' && lead.applicationId === app.id && lead.sourceId === (app.discoverySourceId ?? events.filter(e => e.type === 'source-checked' && e.applicationIds?.includes(app.id)).at(-1)?.sourceId) && (normalizedText(lead.company) === normalizedText(app.company) && (lead.employerJobId && app.employerJobId ? lead.employerJobId.toLowerCase() === app.employerJobId.toLowerCase() : canonicalUrl(lead.url) === canonicalUrl(app.url))))).map(app => app.id) } : { accounting: 'legacy-unverified' }) },
     startedAt: started.occurredAt,
     ...(completion ? { completedAt: completion.occurredAt } : {}),
   };
@@ -1294,6 +1390,7 @@ async function roundComplete(input) {
     if (status.confirmedCount < status.requestedCount) throw new Error(`Round requires ${status.requestedCount} confirmed submissions before completion.`);
     if (!status.discovery.coverageSatisfied) throw new Error('Round requires attempts across at least 3 distinct discovery sources, including at least one searched source. Record coverage and blockers with round source --stdin.');
     if (status.discovery.unattributedCount) throw new Error('Round requires discovery source attribution for every confirmed submission. Supply missing attribution using round source applicationIds; do not rewrite the ledger.');
+    if (status.discovery.conflicts?.length || status.discovery.missingLeadApplicationIds?.length) throw new Error('Round requires qualified lead records for every submission and resolution of conflicting assessments.');
     let explanation = {};
     if (status.discovery.concentrationNeedsExplanation || value.concentrationReason != null || value.concentrationEvidence != null) {
       if (!CONCENTRATION_REASONS.has(value.concentrationReason)) throw new Error('Source concentration requires a documented concentrationReason and private concentrationEvidence.');
@@ -1399,7 +1496,7 @@ async function ledgerReview() {
   const applications = await jsonLines(join(dir, 'applications.ndjson'));
   const outcomes = await jsonLines(join(dir, 'outcomes.ndjson'));
   const acknowledgements = await jsonLines(join(dir, 'reviews.ndjson'));
-  return buildReview(applications, outcomes, acknowledgements);
+  return buildReview(applications, outcomes, acknowledgements, new Date(), await jsonLines(join(dir, 'delivery.ndjson')));
 }
 
 async function ledgerReviewAcknowledge(input) {
@@ -1407,7 +1504,7 @@ async function ledgerReviewAcknowledge(input) {
   const reviewedAt = string(value.reviewedAt ?? new Date().toISOString(), 'reviewedAt', 80);
   if (Number.isNaN(Date.parse(reviewedAt))) throw new Error('reviewedAt must be an ISO date.');
   const review = await ledgerReview();
-  const event = { reviewedAt, uniqueSubmissionCount: review.uniqueSubmittedTotal, maturedApplicationCount: review.maturedApplications };
+  const event = { reviewedAt, uniqueSubmissionCount: review.recordedSubmissionCount, maturedApplicationCount: review.recordedMaturedApplicationCount };
   await withStateLock('reviews', async (dir) => {
     const file = join(dir, 'reviews.ndjson');
     await appendFile(file, `${JSON.stringify(event)}\n`, { mode: 0o600 });
@@ -1547,6 +1644,9 @@ async function executeCommand([area, action, value], telemetry, session, communi
     const event = await telemetryJobAssessed(job, result);
     if (event) domainEvents.push(event);
   } else if (area === 'ledger' && action === 'check' && value === '--stdin') result = await ledgerCheck(await jsonStdin());
+  else if (area === 'ledger' && action === 'delivery' && value === '--stdin') result = await recordDelivery(await jsonStdin());
+  else if (area === 'ledger' && action === 'retry' && value === '--stdin') result = await recordDelivery(await jsonStdin(), true);
+  else if (area === 'ledger' && action === 'deliveries') result = await deliveryHistory(value);
   else if (area === 'ledger' && action === 'add' && value === '--stdin') {
     const input = await jsonStdin();
     const telemetryDetails = validateSubmissionTelemetry(input.telemetry);
@@ -1569,6 +1669,8 @@ async function executeCommand([area, action, value], telemetry, session, communi
   else if (area === 'autonomy' && action === 'preview' && value == null) result = await autonomyStatus();
   else if (area === 'autonomy' && action === 'revoke' && value == null) result = await autonomyRevoke();
   else if (area === 'round' && action === 'start' && value === '--stdin') result = await roundStart(await jsonStdin());
+  else if (area === 'round' && action === 'lead' && value === '--stdin') result = await recordLead(await jsonStdin());
+  else if (area === 'round' && action === 'leads') result = await leadHistory(value);
   else if (area === 'round' && action === 'source' && value === '--stdin') {
     result = await roundSource(await jsonStdin());
     domainEvents.push({ event: 'source_checked', properties: {

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

@@ -1 +1 @@
-export const SKILL_VERSION = '3.4.2';
+export const SKILL_VERSION = '3.5.0';

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

@@ -0,0 +1,86 @@
+import assert from 'node:assert/strict';
+import { execFileSync, spawnSync } from 'node:child_process';
+import { mkdtemp, writeFile, readFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+const script = fileURLToPath(new URL('../scripts/job-application.mjs', import.meta.url));
+async function fixture(t) {
+  const dir = await mkdtemp(join(tmpdir(), 'accounting-cli-'));
+  t.after(() => rm(dir, { recursive: true, force: true }));
+  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 run = (args, input) => JSON.parse(execFileSync(process.execPath, [script, ...args], { env, encoding: 'utf8', input: JSON.stringify(input) }));
+  const fail = (args, input) => spawnSync(process.execPath, [script, ...args], { env, encoding: 'utf8', input: JSON.stringify(input) });
+  return { dir, run, fail };
+}
+const application = (roundId) => ({ id: 'app', company: 'Example', role: 'Senior Engineer', url: 'https://example.test/jobs/1', source: 'email', discoverySourceId: 'indeed', score: 90, status: 'submitted', submittedAt: '2026-01-01T00:00:00Z', approval: 'STANDING AUTHORIZATION', roundId });
+const failure = { id: 'bounce-1', applicationId: 'app', attemptId: 'initial:app', type: 'delivery-failed', evidenceType: 'final-delivery-failure', evidence: 'Matched final failure for the original recruiting message.', occurredAt: '2026-01-02T00:00:00Z' };
+
+test('late delivery failure corrects completed round and review without rewriting applications', async (t) => {
+  const {dir, run} = await fixture(t);
+  const roundId = 'legacy-round';
+  await writeFile(join(dir, 'rounds.ndjson'), [ { type:'started', roundId, requestedCount:1, occurredAt:'2026-01-01T00:00:00Z'}, {type:'completed',roundId,occurredAt:'2026-01-01T01:00:00Z'} ].map(JSON.stringify).join('\n')+'\n');
+  const raw = JSON.stringify(application(roundId))+'\n';
+  await writeFile(join(dir, 'applications.ndjson'), raw);
+  run(['ledger','delivery','--stdin'], failure);
+  run(['ledger','delivery','--stdin'], failure);
+  const status = run(['round','status',roundId]);
+  assert.equal(status.completed,true);
+  assert.equal(status.confirmedCount,0);
+  assert.equal(status.shortfallCount,1);
+  assert.equal(status.needsRecovery,true);
+  assert.equal(run(['ledger','review']).submittedTotal,0);
+  assert.equal(await readFile(join(dir,'applications.ndjson'),'utf8'),raw);
+  assert.equal((await readFile(join(dir,'delivery.ndjson'),'utf8')).trim().split('\n').length,1);
+});
+
+test('new rounds derive source totals and require qualified lead linkage', async (t) => {
+  const {run,fail} = await fixture(t);
+  const {roundId} = run(['round','start','--stdin'],{requestedCount:1});
+  assert.notEqual(fail(['round','source','--stdin'],{roundId,sourceId:'indeed',status:'searched',reviewedCount:20,qualifiedCount:1,evidence:'Unsupported summary'}).status,0);
+  const lead = { id:'lead-1',roundId,sourceId:'indeed',company:'Example',role:'Senior Engineer',url:'https://example.test/jobs/1',disposition:'qualified',evidence:'Meets the evidenced target requirements.',applicationId:'app',observedAt:'2026-01-01T00:00:00Z' };
+  run(['round','lead','--stdin'],lead);
+  run(['round','lead','--stdin'],lead);
+  for(const sourceId of ['indeed','linkedin-jobs-feed','hacker-news-who-is-hiring']) run(['round','source','--stdin'],{roundId,sourceId,status:'searched',evidence:'Actual synthetic search'});
+  run(['ledger','add','--stdin'],application(roundId));
+  const status=run(['round','status',roundId]);
+  assert.equal(status.discovery.sources.find(s=>s.sourceId==='indeed').reviewedCount,1);
+  assert.equal(run(['round','leads',roundId]).leads.length,1);
+  assert.equal(run(['round','complete','--stdin'],{roundId,concentrationReason:'stronger-fit',concentrationEvidence:'Only this source had a qualified role.'}).completed,true);
+  run(['round','lead','--stdin'],{...lead,id:'revision',supersedes:lead.id,disposition:'closed-stale'});
+  assert.equal(run(['round','status',roundId]).completed,true);
+  assert.equal(run(['round','leads',roundId]).qualifiedCount,0);
+  assert.notEqual(fail(['round','lead','--stdin'],{...lead,id:'new-lead',url:'https://different.example/job'}).status,0);
+});
+
+for (const scenario of [
+  { name: 'different requisition IDs at the same URL', application: { employerJobId: 'req-1' }, lead: { employerJobId: 'req-2' }, matched: false },
+  { name: 'different companies sharing a requisition ID and URL', application: { employerJobId: 'req-1' }, lead: { employerJobId: 'req-1', company: 'Another Company' }, matched: false },
+  { name: 'different companies sharing a URL without requisition IDs', application: {}, lead: { company: 'Another Company' }, matched: false },
+  { name: 'matching company and requisition ID across URL aliases', application: { employerJobId: 'req-1' }, lead: { employerJobId: 'req-1', url: 'https://ats.example.test/alias/1' }, matched: true },
+  { name: 'matching company and URL when only one requisition ID is known', application: { employerJobId: 'req-1' }, lead: {}, matched: true },
+]) {
+  test(`qualified lead attribution checks ${scenario.name}`, async (t) => {
+    const { dir, run, fail } = await fixture(t);
+    const { roundId } = run(['round', 'start', '--stdin'], { requestedCount: 1 });
+    const app = { ...application(roundId), ...scenario.application };
+    await writeFile(join(dir, 'applications.ndjson'), JSON.stringify(app) + '\n');
+    run(['round', 'lead', '--stdin'], {
+      id: 'qualified-lead', roundId, sourceId: 'indeed', company: 'Example', role: app.role,
+      url: app.url, disposition: 'qualified', applicationId: app.id,
+      observedAt: '2026-01-01T00:00:00Z', evidence: 'Synthetic verified requisition assessment.',
+      ...scenario.lead,
+    });
+    for (const sourceId of ['indeed', 'linkedin-jobs-feed', 'hacker-news-who-is-hiring']) {
+      run(['round', 'source', '--stdin'], { roundId, sourceId, status: 'searched', evidence: 'Synthetic search performed.' });
+    }
+    const status = run(['round', 'status', roundId]);
+    assert.deepEqual(status.discovery.missingLeadApplicationIds, scenario.matched ? [] : [app.id]);
+    const completion = fail(['round', 'complete', '--stdin'], {
+      roundId, concentrationReason: 'stronger-fit', concentrationEvidence: 'Only the selected source had a qualifying opening.',
+    });
+    assert.equal(completion.status === 0, scenario.matched, completion.stderr);
+  });
+}

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

@@ -0,0 +1,183 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+
+import { CloudStateClient, readCachedCloudProfile, saveCloudConfig } from '../scripts/cloud-state-client.mjs';
+import { deliveryProjection, discoveryProjection, validateDelivery, validateLead } from '../scripts/application-accounting.mjs';
+import worker, { sha256Hex } from '../../state-worker/src/worker.mjs';
+import { createBackup, restoreBackup } from '../../state-worker/src/backup.mjs';
+import { createMemoryD1, hasNodeSqlite } from '../../state-worker/tests/d1-mock.mjs';
+import { createMemoryR2 } from '../../state-worker/tests/r2-mock.mjs';
+
+const TOKEN = 'accounting-cloud-client-synthetic-token-long-enough';
+const sqliteTest = hasNodeSqlite ? test : test.skip;
+const now = '2026-09-13T10:00:00.000Z';
+const application = { id: 'app', company: 'Example', role: 'Engineer', source: 'email', url: 'https://example.com/jobs/app', status: 'submitted', submittedAt: '2026-09-12T10:00:00.000Z' };
+const failure = validateDelivery({ version: 1, id: 'failure-event', applicationId: 'app', attemptId: 'initial:app', type: 'delivery-failed', occurredAt: now, evidenceType: 'final-delivery-failure', evidence: 'Synthetic final failure matched to the original application email.' });
+const retry = validateDelivery({ version: 1, id: 'retry-event', applicationId: 'app', attemptId: 'recovery-attempt', type: 'retry-confirmed', channel: 'browser', url: 'https://example.com/jobs/app', channelVerifiedAt: now, approval: 'STANDING AUTHORIZATION', evidenceType: 'browser-confirmation', evidence: 'Synthetic visible ATS success.', occurredAt: '2026-09-13T11:00:00.000Z' });
+const qualifiedLead = validateLead({ version: 1, id: 'lead-event', type: 'lead-reviewed', roundId: 'round-1', sourceId: 'direct', url: application.url, company: application.company, role: application.role, disposition: 'qualified', observedAt: now, evidence: 'Synthetic active employer posting matches requirements.' });
+
+async function setup(t) {
+  const root = await mkdtemp(join(tmpdir(), 'job-agent-accounting-cloud-'));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const stateDir = join(root, 'state');
+  const configPath = join(root, 'cloud', 'config.json');
+  await mkdir(stateDir, { recursive: true });
+  const schema = await readFile(new URL('../../state-worker/migrations/0001_private_state.sql', import.meta.url), 'utf8');
+  const DB = createMemoryD1(schema);
+  await DB.prepare('INSERT INTO clients (client_id, name, token_hash, created_at) VALUES (?, ?, ?, ?)')
+    .bind('client-test', 'Synthetic Accounting Client', sha256Hex(TOKEN), now).run();
+  const bindings = { DB, STATE: createMemoryR2(), STATE_TOKEN: 'legacy', LEGACY_WRITES_DISABLED: '1' };
+  const fetchImpl = (input, init) => worker.fetch(new Request(input, init), bindings);
+  await saveCloudConfig({ version: 2, url: 'https://state.example.com', token: TOKEN, clientId: 'client-test' }, { configPath });
+  const client = new CloudStateClient({ stateDir, configPath, fetchImpl });
+  return { root, stateDir, configPath, schema, bindings, fetchImpl, client };
+}
+
+async function writeRows(stateDir, stream, rows) {
+  await writeFile(join(stateDir, `${stream}.ndjson`), `${rows.map(row => JSON.stringify(row)).join('\n')}\n`, { mode: 0o600 });
+}
+
+async function readRows(stateDir, stream) {
+  return (await readFile(join(stateDir, `${stream}.ndjson`), 'utf8')).split('\n').filter(Boolean).map(JSON.parse);
+}
+
+sqliteTest('local and cloud accounting projections agree after repeated bidirectional reconciliation', async t => {
+  const ctx = await setup(t);
+  await writeRows(ctx.stateDir, 'applications', [application]);
+  await writeRows(ctx.stateDir, 'delivery', [failure]);
+  await writeRows(ctx.stateDir, 'discovery', [qualifiedLead]);
+  const originalProjection = deliveryProjection([application], [failure]);
+  assert.equal(originalProjection.effectiveSubmissionCount, 0);
+  await ctx.client.reconcile({ dryRun: false });
+  const correction = validateDelivery({ version: 1, id: 'correction-event', applicationId: 'app', attemptId: 'initial:app', type: 'correction', supersedes: failure.id, status: 'receipt-confirmed', occurredAt: '2026-09-14T10:00:00.000Z', evidenceType: 'employer-acknowledgement', evidence: 'Synthetic employer acknowledgement corrects the matched failure.' });
+  await ctx.client.appendRecord('delivery', correction);
+  const downloaded = await ctx.client.reconcile({ dryRun: false });
+  assert.equal(downloaded.streams.delivery.cloudOnly, 1);
+  const repeated = await ctx.client.reconcile({ dryRun: false });
+  assert.equal(repeated.imported, 0);
+  assert.equal(repeated.downloaded, 0);
+  const localApplications = await readRows(ctx.stateDir, 'applications');
+  const localDelivery = await readRows(ctx.stateDir, 'delivery');
+  const cloudApplications = (await ctx.client.listStream('applications')).map(row => row.value);
+  const cloudDelivery = (await ctx.client.listStream('delivery')).map(row => row.value);
+  assert.equal(cloudDelivery.length, 2);
+  assert.deepEqual(deliveryProjection(localApplications, localDelivery), deliveryProjection(cloudApplications, cloudDelivery));
+  assert.equal(deliveryProjection(localApplications, localDelivery).effectiveSubmissionCount, 1);
+  const localDiscovery = await readRows(ctx.stateDir, 'discovery');
+  const cloudDiscovery = (await ctx.client.listStream('discovery')).map(row => row.value);
+  assert.deepEqual(discoveryProjection(localDiscovery, { roundId: 'round-1' }), discoveryProjection(cloudDiscovery, { roundId: 'round-1' }));
+});
+
+sqliteTest('default reconciliation migrates failed-email recovery history and exports one application with two delivery records', async t => {
+  const ctx = await setup(t);
+  await writeRows(ctx.stateDir, 'applications', [application]);
+  await writeRows(ctx.stateDir, 'delivery', [failure, retry]);
+  const result = await ctx.client.reconcile({ dryRun: false });
+  assert.equal(result.imported, 3);
+  const again = await ctx.client.reconcile({ dryRun: false });
+  assert.equal(again.imported, 0);
+  const exported = await ctx.client.exportTo(join(ctx.root, 'private-export.json'));
+  const archive = JSON.parse(await readFile(exported.path, 'utf8'));
+  assert.equal(archive.streams.applications.length, 1);
+  assert.equal(archive.streams.delivery.length, 2);
+  assert.ok(archive.streams.delivery.every(row => row.provenance === 'local-reconcile'));
+  assert.deepEqual(archive.streams.delivery.map(row => row.value), [failure, retry]);
+  assert.equal(deliveryProjection(archive.streams.applications.map(row => row.value), archive.streams.delivery.map(row => row.value)).effectiveSubmissionCount, 1);
+  if (process.platform !== 'win32') assert.equal((await stat(exported.path)).mode & 0o777, 0o600);
+});
+
+sqliteTest('private backup restores delivery attempts and projection without duplicating a second restore', async t => {
+  const ctx = await setup(t);
+  await writeRows(ctx.stateDir, 'applications', [application]);
+  await writeRows(ctx.stateDir, 'delivery', [failure, retry]);
+  await ctx.client.reconcile({ dryRun: false });
+  const archive = await createBackup(ctx.bindings.DB, now);
+  const restored = createMemoryD1(ctx.schema);
+  assert.equal((await restoreBackup(restored, archive)).records, 3);
+  assert.equal((await restoreBackup(restored, archive)).records, 0);
+  const values = async stream => (await restored.prepare('SELECT payload_json FROM records WHERE stream = ? ORDER BY sequence').bind(stream).all()).results.map(row => JSON.parse(row.payload_json));
+  const restoredApplications = await values('applications');
+  const restoredDelivery = await values('delivery');
+  assert.deepEqual(restoredDelivery, [failure, retry]);
+  assert.deepEqual(deliveryProjection(restoredApplications, restoredDelivery), deliveryProjection([application], [failure, retry]));
+});
+
+sqliteTest('an older backend is rejected before any local-only accounting data uploads', async t => {
+  const ctx = await setup(t);
+  await writeRows(ctx.stateDir, 'applications', [application]);
+  await writeRows(ctx.stateDir, 'delivery', [failure]);
+  const mutations = [];
+  const older = new CloudStateClient({ stateDir: ctx.stateDir, configPath: ctx.configPath, fetchImpl: async (input, init) => {
+    if (new URL(input).pathname === '/v2/status') return Response.json({ apiVersion: 2, backend: 'cloudflare-d1-r2', capabilities: [] });
+    if (init.method && init.method !== 'GET') mutations.push({ input, method: init.method });
+    return ctx.fetchImpl(input, init);
+  } });
+  await assert.rejects(() => older.reconcile({ dryRun: false }), /backend upgrade required.*application-accounting-v1/i);
+  assert.equal(mutations.length, 0);
+  assert.equal((await ctx.bindings.DB.prepare('SELECT COUNT(*) AS count FROM records').first()).count, 0);
+  assert.deepEqual(await readRows(ctx.stateDir, 'delivery'), [failure]);
+});
+
+sqliteTest('cached accounting permits offline research and durable observation queues while blocking transmission intents', async t => {
+  const ctx = await setup(t);
+  await ctx.client.putDocument('profile', { name: 'Synthetic Candidate', roleFamilies: ['engineering'] }, 0);
+  await ctx.client.refreshProfileCache();
+  await writeRows(ctx.stateDir, 'applications', [application]);
+  await ctx.client.reconcile({ dryRun: false });
+  const offline = new CloudStateClient({ stateDir: ctx.stateDir, configPath: ctx.configPath, fetchImpl: async () => { throw new Error('synthetic network outage'); } });
+  await offline.requireAccounting();
+  assert.equal((await readCachedCloudProfile(ctx.stateDir)).name, 'Synthetic Candidate');
+  assert.deepEqual(await readRows(ctx.stateDir, 'applications'), [application]);
+  const queued = await offline.appendRecord('delivery', failure, { queueOnFailure: true });
+  assert.equal(queued.queued, true);
+  const restarted = new CloudStateClient({ stateDir: ctx.stateDir, configPath: ctx.configPath, fetchImpl: offline.fetchImpl });
+  const pending = await restarted.pendingWrites();
+  assert.equal(pending.length, 1);
+  assert.deepEqual(pending[0].payload.value, failure);
+  assert.equal(pending[0].stream, 'delivery');
+  if (process.platform !== 'win32') assert.equal((await stat(join(ctx.stateDir, 'cloud-pending.ndjson'))).mode & 0o777, 0o600);
+  await assert.rejects(() => restarted.createIntent({ applicationId: 'another-app', canonicalUrl: 'https://example.com/jobs/another', leaseId: 'expired-lease' }), /cloud state unavailable/i);
+  assert.equal((await ctx.bindings.DB.prepare('SELECT COUNT(*) AS count FROM application_intents').first()).count, 0);
+  await ctx.client.reconcile({dryRun:false});
+  assert.equal((await ctx.client.pendingWrites()).length,0);
+  assert.equal((await readRows(ctx.stateDir,'delivery')).length,1);
+});
+
+sqliteTest('a delivery replay followed by repeated synchronization preserves one logical evidence event', async t => {
+  const ctx = await setup(t);
+  await writeRows(ctx.stateDir, 'applications', [application]);
+  await writeRows(ctx.stateDir, 'delivery', [failure]);
+  await ctx.client.reconcile({ dryRun: false });
+  await ctx.client.appendRecord('delivery', failure, { idempotencyKey: 'different-network-replay-id' });
+  const sync = await ctx.client.reconcile({ dryRun: false });
+  const repeated = await ctx.client.reconcile({ dryRun: false });
+  assert.equal(sync.imported + sync.downloaded + repeated.imported + repeated.downloaded, 0);
+  assert.equal((await ctx.client.listStream('delivery')).length, 1);
+  assert.equal((await readRows(ctx.stateDir, 'delivery')).length, 1);
+  assert.equal(deliveryProjection([application], await readRows(ctx.stateDir, 'delivery')).failedDeliveryCount, 1);
+});
+
+sqliteTest('cross-client JSON field ordering does not duplicate the same delivery event during synchronization', async t => {
+  const ctx = await setup(t);
+  await writeRows(ctx.stateDir, 'applications', [application]);
+  await ctx.client.reconcile({ dryRun: false });
+  await writeRows(ctx.stateDir, 'delivery', [failure]);
+  const reorderedFailure = Object.fromEntries(Object.entries(failure).reverse());
+  await ctx.client.appendRecord('delivery', reorderedFailure);
+  await ctx.client.reconcile({ dryRun: false });
+  await ctx.client.reconcile({ dryRun: false });
+  assert.equal((await ctx.client.listStream('delivery')).length, 1);
+  assert.equal((await readRows(ctx.stateDir, 'delivery')).length, 1);
+});
+
+sqliteTest('unfamiliar versioned discovery records survive synchronization unchanged', async t => {
+  const ctx = await setup(t);
+  const legacy = {version:7,type:'legacy-discovery-report',id:'legacy',roundId:'old',results:{reviewed:12}};
+  await writeRows(ctx.stateDir,'discovery',[legacy]);
+  await ctx.client.reconcile({dryRun:false});
+  assert.deepEqual((await ctx.client.listStream('discovery'))[0].value,legacy);
+  assert.deepEqual(discoveryProjection(await readRows(ctx.stateDir,'discovery')).leads,[]);
+});