job-application-agent 3.4.2 → 3.6.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,
@@ -341,8 +391,12 @@ export class CloudStateClient {
     for (const item of status.documents ?? []) documents[item.name] = await this.getDocument(item.name);
     const streams = {};
     for (const stream of Object.keys(CLOUD_STREAM_FILES)) streams[stream] = await this.listStream(stream);
+    const outreach = status.capabilities?.includes('outreach-tracking-v1') ? {
+      snapshot: await (await this.request('/v2/outreach/snapshot')).json(),
+      deletionManifest: await (await this.request('/v2/outreach/deletions')).json(),
+    } : undefined;
     const output = path ?? join(this.stateDir, `cloud-export-${new Date().toISOString().replaceAll(':', '-')}.json`);
-    await privateWrite(output, `${JSON.stringify({ version: 1, exportedAt: new Date().toISOString(), backend: status.backend, documents, streams, files: status.files ?? [] })}\n`);
+    await privateWrite(output, `${JSON.stringify({ version: 1, exportedAt: new Date().toISOString(), backend: status.backend, documents, streams, files: status.files ?? [], ...(outreach ? { outreach } : {}) })}\n`);
     return { path: output, documents: Object.keys(documents).length, records: Object.values(streams).reduce((sum, rows) => sum + rows.length, 0) };
   }
 }
@@ -353,7 +407,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,12 +7,25 @@ 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';
 import { TelemetryClient } from './telemetry-client.mjs';
 import { jobIdentity } from './telemetry-schema.mjs';
 import { CloudStateClient, defaultCloudConfigPath, enableCloudUpdateGuard, saveCloudConfig } from './cloud-state-client.mjs';
+import {
+  SESSION_BINDING_ATTENTION_KEYS,
+  createSessionBinding,
+  extractSessionBindingFields,
+  sessionBindingPath,
+  writeSessionBindingFile,
+} from './session-binding.mjs';
+import {
+  detectAiAssistanceDiscouraged,
+  extractNarrativeQuestionsFromText,
+  normalizeAttentionQuestions,
+} from './attention-questions.mjs';
 
 const SOURCES = new Set(['linkedin', 'greenhouse', 'lever', 'ashby', 'workable', 'comeet', 'workday', 'rippling', 'smartrecruiters', 'google-form', 'company', 'email', 'other']);
 const DISCOVERY_SOURCES = new Set(['direct-company', 'linkedin', 'x', 'yc', 'hacker-news', 'job-board', 'email', 'user-supplied', 'web-search', 'other']);
@@ -506,12 +519,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 +533,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 +545,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 +555,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 +570,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 +610,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 +1098,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 +1124,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 +1188,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 +1202,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 +1211,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 +1250,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,12 +1301,75 @@ 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 };
 }
 
+async function attentionNotifyHook(event, context = {}) {
+  const notifyUrl = process.env.ATTENTION_NOTIFY_URL?.trim();
+  const notifySecret = process.env.ATTENTION_NOTIFY_SECRET?.trim();
+  if (!notifyUrl || !notifySecret) return { attempted: false, reason: 'notify_unconfigured' };
+
+  let email = '';
+  try { email = String(storedProfileRaw()?.email ?? '').trim().toLowerCase(); } catch { email = ''; }
+  if (!email) {
+    console.error('[attention-notify] profile email missing; skip notify fail-closed');
+    return { attempted: true, ok: false, error: 'profile_email_missing' };
+  }
+
+  const company = String(context.company ?? '').trim() || 'Company';
+  const role = String(context.role ?? '').trim() || 'Role';
+  try {
+    const response = await fetch(notifyUrl, {
+      method: 'POST',
+      headers: {
+        authorization: `Bearer ${notifySecret}`,
+        'content-type': 'application/json',
+      },
+      body: JSON.stringify({
+        attentionId: event.id,
+        email,
+        company,
+        role,
+        url: event.url,
+        stage: event.stage,
+        blocker: event.blocker,
+        requiredActions: event.requiredActions,
+        questions: event.questions ?? [],
+        aiAssistanceDiscouraged: Boolean(event.aiAssistanceDiscouraged),
+        postingText: context.postingText ?? '',
+      }),
+    });
+    const body = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      console.error(`[attention-notify] site notify failed (${response.status}): ${body?.error ?? 'unknown'}`);
+      return { attempted: true, ok: false, error: body?.error ?? 'notify_failed', status: response.status };
+    }
+    return { attempted: true, ok: true, magicLinkUrl: body?.magicLinkUrl ?? null, emailId: body?.emailId ?? null };
+  } catch (error) {
+    console.error(`[attention-notify] site notify request failed: ${error instanceof Error ? error.message : 'unknown'}`);
+    return { attempted: true, ok: false, error: 'notify_request_failed' };
+  }
+}
+
 async function attentionAdd(input) {
   const value = object(input, 'attention item');
-  const allowed = new Set(['roundId', 'applicationId', 'url', 'stage', 'blocker', 'requiredActions', 'createdAt']);
+  const allowed = new Set([
+    'roundId', 'applicationId', 'url', 'stage', 'blocker', 'requiredActions', 'createdAt', 'company', 'role',
+    // P1.5 judgment packaging (prompts only — never candidate responses).
+    'questions', 'postingText', 'aiAssistanceDiscouraged',
+    // Local-only session binding hooks — never appended to the cloud attention event.
+    ...SESSION_BINDING_ATTENTION_KEYS,
+  ]);
   for (const key of Object.keys(value)) if (!allowed.has(key)) throw new Error(`Unknown attention property: ${key}.`);
   const stage = string(value.stage, 'attention.stage', 40).toLowerCase();
   const blocker = string(value.blocker, 'attention.blocker', 60).toLowerCase();
@@ -1230,19 +1377,62 @@ async function attentionAdd(input) {
   if (!ATTENTION_BLOCKERS.has(blocker)) throw new Error('attention.blocker is invalid.');
   const requiredActions = stringArray(value.requiredActions, 'attention.requiredActions', true).map((item) => item.toLowerCase());
   if (requiredActions.length > 8 || requiredActions.some((item) => !REQUIRED_ACTIONS.has(item))) throw new Error('attention.requiredActions must contain only documented actions.');
+  const applicationId = string(value.applicationId, 'attention.applicationId', 180);
+  let company = typeof value.company === 'string' ? value.company.trim() : '';
+  let role = typeof value.role === 'string' ? value.role.trim() : '';
+  if (!company || !role) {
+    try {
+      const apps = await jsonLines(join(await ensureStateDir(), 'applications.ndjson'));
+      const match = apps.find((entry) => entry.id === applicationId);
+      if (match) {
+        company = company || String(match.company ?? '').trim();
+        role = role || String(match.role ?? match.title ?? '').trim();
+      }
+    } catch { /* best-effort context for notify only */ }
+  }
+  const postingText = typeof value.postingText === 'string' ? value.postingText.slice(0, 20_000) : '';
+  let questions = normalizeAttentionQuestions(value.questions);
+  if (!questions.length && postingText && requiredActions.includes('provide-judgment')) {
+    questions = extractNarrativeQuestionsFromText(postingText);
+  }
+  const aiAssistanceDiscouraged = value.aiAssistanceDiscouraged === true
+    || detectAiAssistanceDiscouraged(postingText);
+  const localBindingFields = extractSessionBindingFields(value);
   const event = {
     type: 'opened',
     id: `attention-${randomUUID()}`,
     roundId: string(value.roundId, 'attention.roundId', 180),
-    applicationId: string(value.applicationId, 'attention.applicationId', 180),
+    applicationId,
     url: string(value.url, 'attention.url', 2048),
     stage,
     blocker,
     requiredActions: [...new Set(requiredActions)],
+    // Prompts only — never store candidate responses on the attention queue.
+    ...(questions.length ? { questions } : {}),
+    ...(aiAssistanceDiscouraged ? { aiAssistanceDiscouraged: true } : {}),
     createdAt: isoDate(value.createdAt, 'attention.createdAt'),
   };
   await appendPrivateEvent('attention', event);
-  return event;
+
+  let sessionBinding = null;
+  if (localBindingFields) {
+    const binding = createSessionBinding({
+      attentionId: event.id,
+      jobUrl: event.url,
+      applicationId: event.applicationId,
+      roundId: event.roundId,
+      createdAt: event.createdAt,
+      questions: event.questions,
+      aiAssistanceDiscouraged: event.aiAssistanceDiscouraged,
+      ...localBindingFields,
+    });
+    const path = sessionBindingPath(await ensureStateDir(), event.id);
+    sessionBinding = { path, binding: await writeSessionBindingFile(path, binding) };
+  }
+
+  const notify = await attentionNotifyHook(event, { company, role, postingText });
+  const base = sessionBinding ? { ...event, sessionBinding } : event;
+  return notify.attempted ? { ...base, notify } : base;
 }
 
 async function attentionResolve(input) {
@@ -1251,6 +1441,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 +1458,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 +1472,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 +1498,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 +1604,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 +1612,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 +1752,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 +1777,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: {
@@ -1624,6 +1834,12 @@ async function recordInstallationStart(telemetry, session) {
 
 async function main(args) {
   const [area, action, value] = args;
+  // Outreach is private-only, including errors: never initialize telemetry or
+  // community clients, flush their queues, or run generic reconciliation here.
+  if (area === 'outreach') {
+    const { runOutreach } = await import('./outreach-cli.mjs');
+    return print(await runOutreach(args.slice(1)));
+  }
   const telemetry = new TelemetryClient({ stateDir: stateDir(), readIdentity: () => {
     const profile = storedProfileRaw();
     // Only explicit saved fields; no resume parsing, conversation scraping, or full profile payload.