job-application-agent 3.4.1 → 3.5.0

package/job-application-agent/scripts/cloud-state-client.mjs

@@ -1,3 +1,4 @@
+import { ACCOUNTING_CAPABILITY, stableJson, validateDelivery, validateLead } from './application-accounting.mjs';
 import { createHash, randomUUID } from 'node:crypto';
 import { appendFile, chmod, mkdir, readFile, rename, stat, writeFile } from 'node:fs/promises';
 import { homedir, platform } from 'node:os';
@@ -8,6 +9,7 @@ export const CLOUD_STREAM_FILES = Object.freeze({
   outcomes: 'outcomes.ndjson',
   rounds: 'rounds.ndjson',
   discovery: 'discovery.ndjson',
+  delivery: 'delivery.ndjson',
   attention: 'attention.ndjson',
   reviews: 'reviews.ndjson',
   friction: 'friction.ndjson',
@@ -93,6 +95,7 @@ export async function enableCloudUpdateGuard({ home = homedir(), agentHome = pro
   catch (error) { if (error.code === 'ENOENT') return { guarded: false, reason: 'managed-install-not-found' }; throw error; }
   const required = new Set(config.requiredCapabilities ?? []);
   required.add('cloud-state-v2');
+  required.add(ACCOUNTING_CAPABILITY);
   await privateWrite(path, `${JSON.stringify({ ...config, requiredCapabilities: [...required].sort() }, null, 2)}\n`);
   return { guarded: true, capability: 'cloud-state-v2' };
 }
@@ -159,6 +162,23 @@ export class CloudStateClient {
     return { configured: true, url: config.url, configuredClient: { id: config.clientId ?? null, name: config.clientName ?? null, token: tokenSuffix(config.token) }, pendingLocalWrites: pending.length, ...remote };
   }
 
+  async requireAccounting() {
+    const config = await this.config(true);
+    if (!config) return;
+    const backend = hash(`${config.url}:${config.token}`);
+    try {
+      const status = await this.status();
+      if (!status.configured) return;
+      if (!status.capabilities?.includes(ACCOUNTING_CAPABILITY)) throw new Error('Private backend upgrade required: application-accounting-v1 is missing.');
+      await ensurePrivateDirectory(this.stateDir);
+      await privateWrite(join(this.stateDir, 'cloud-accounting-capability.json'), JSON.stringify({ supported: true, backend }));
+    } catch (error) {
+      if (!/^Cloud state unavailable:/.test(error.message)) throw error;
+      try { if (JSON.parse(await readFile(join(this.stateDir, 'cloud-accounting-capability.json'), 'utf8')).backend === backend) return; } catch {}
+      throw error;
+    }
+  }
+
   async getDocument(name) {
     const response = await this.request(`/v2/documents/${encodeURIComponent(name)}`);
     return response.json();
@@ -199,7 +219,7 @@ export class CloudStateClient {
     if (forbidden) throw new Error(`Cloud record contains forbidden field: ${forbidden}`);
     const payload = {
       recordKey: String(recordKey ?? value?.id ?? value?.roundId ?? randomUUID()),
-      idempotencyKey: String(idempotencyKey ?? `${stream}:${hash(JSON.stringify(value))}`),
+      idempotencyKey: String(idempotencyKey ?? `${stream}:${hash(stableJson(value))}`),
       occurredAt: occurredAt ?? value?.occurredAt ?? value?.submittedAt ?? new Date().toISOString(),
       provenance,
       value,
@@ -227,8 +247,20 @@ export class CloudStateClient {
   }
 
   async pendingWrites() {
-    try { return (await readFile(join(this.stateDir, 'cloud-pending.ndjson'), 'utf8')).split('\n').filter(Boolean).map(JSON.parse); }
-    catch (error) { if (error.code === 'ENOENT') return []; throw error; }
+    const events = await readNdjson(join(this.stateDir, 'cloud-pending.ndjson'));
+    const receipts = new Set((await readNdjson(join(this.stateDir, 'cloud-pending-receipts.ndjson'))).map(event => event.key));
+    return events.filter(event => !receipts.has(hash(stableJson(event))));
+  }
+
+  async flushAccountingWrites(stream) {
+    if (!['delivery','discovery'].includes(stream)) return;
+    for (const event of (await this.pendingWrites()).filter(event => event.type === 'append-record' && event.stream === stream)) {
+      await this.appendRecord(stream, event.payload.value, { ...event.payload, queueOnFailure: false });
+      const receipt = { key: hash(stableJson(event)) };
+      const path = join(this.stateDir, 'cloud-pending-receipts.ndjson');
+      await appendFile(path, `${JSON.stringify(receipt)}\n`, { mode: 0o600 });
+      await chmod(path, 0o600);
+    }
   }
 
   async putFile(name, bytes, revision) {
@@ -289,9 +321,15 @@ export class CloudStateClient {
   }
 
   async createIntent(value) {
+    await this.requireAccounting();
     return (await this.request('/v2/intents', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(value) })).json();
   }
 
+  async confirmRetry(intentId, delivery, leaseId) {
+    await this.requireAccounting();
+    return (await this.request(`/v2/intents/${encodeURIComponent(intentId)}/confirm`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ delivery, leaseId }) })).json();
+  }
+
   async markIntentSentUnverified(intentId, leaseId) {
     return (await this.request(`/v2/intents/${encodeURIComponent(intentId)}/sent-unverified`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ leaseId }) })).json();
   }
@@ -301,11 +339,23 @@ export class CloudStateClient {
   }
 
   async reconcile({ dryRun = true, provenance = 'local-reconcile' } = {}) {
+    await this.requireAccounting();
     const report = { dryRun, streams: {}, imported: 0, downloaded: 0 };
     for (const [stream, filename] of Object.entries(CLOUD_STREAM_FILES)) {
-      const local = await readNdjson(join(this.stateDir, filename));
+      if (!dryRun) await this.flushAccountingWrites(stream);
+      const normalize = value => stream === 'delivery' ? validateDelivery(value) : stream === 'discovery' && value.version === 1 && value.type === 'lead-reviewed' ? validateLead(value) : value;
+      let local = (await readNdjson(join(this.stateDir, filename))).map(normalize);
       const cloudRecords = await this.listStream(stream);
-      const cloud = cloudRecords.map((record) => record.value);
+      let cloud = cloudRecords.map((record) => normalize(record.value));
+      if (['delivery','discovery'].includes(stream)) {
+        const ids = new Map();
+        for (const value of [...local, ...cloud].filter(v => v.version === 1 && (stream === 'delivery' || v.type === 'lead-reviewed'))) {
+          if (ids.has(value.id) && stableJson(ids.get(value.id)) !== stableJson(value)) throw new Error('Conflicting accounting event ID during cloud reconciliation.');
+          ids.set(value.id, value);
+        }
+        const unique = values => values.filter((value,index) => value.version !== 1 || (stream === 'discovery' && value.type !== 'lead-reviewed') || values.findIndex(other => other.id === value.id && other.version === 1) === index);
+        local = unique(local); cloud = unique(cloud);
+      }
       const localCounts = multiset(local);
       const cloudCounts = multiset(cloud);
       const localOnly = multisetDifference(local, cloudCounts);
@@ -314,7 +364,7 @@ export class CloudStateClient {
       if (!dryRun) {
         const prepared = localOnly.map(({ value, index }) => ({
           recordKey: String(value?.id ?? value?.roundId ?? value?.applicationId ?? `${stream}-${index}`),
-          idempotencyKey: `reconcile:${hash(JSON.stringify(value))}:${index}`,
+          idempotencyKey: value.version === 1 && (stream === 'delivery' || (stream === 'discovery' && value.type === 'lead-reviewed')) ? `accounting:${value.id}` : `reconcile:${hash(stableJson(value))}:${index}`,
           occurredAt: value?.occurredAt ?? value?.submittedAt ?? new Date().toISOString(),
           provenance,
           value,
@@ -353,7 +403,7 @@ async function readNdjson(path) {
 }
 
 function key(value) {
-  return JSON.stringify(value);
+  return stableJson(value);
 }
 
 function multiset(values) {

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.1';
+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);
+  });
+}