job-application-agent 3.7.1 → 3.7.2

package/job-application-agent/SKILL.md

@@ -37,12 +37,16 @@ copyable text to the candidate for manual sending, and record actual observation
 Do not automate LinkedIn/X access or messaging. Existing application autonomy
 does not enable this module. Outreach commands bypass analytics and community
 transmissions; do not run updater/telemetry/community commands as part of an
-outreach-only workflow. Keep outreach separate from applications and never
-classify a proposed screen as scheduled. No scheduled follow-up is created.
+outreach-only workflow. Keep drafting and sending separate from ATS forms.
+A `sent-verified` outreach counts toward the active application round the same
+way a confirmed apply does, unless that company is already a confirmed apply on
+the same round. Clear does not un-confirm. A later `not-sent` or `failed`
+delivery correction does. Never classify a proposed screen as scheduled. No scheduled
+follow-up is created.
 
 ## Accounting
 
-Read [references/ACCOUNTING.md](references/ACCOUNTING.md) before recording delivery evidence, recovery attempts, or per-lead discovery. For new rounds, record each lead with `round lead --stdin` and derive source totals from those records. Email access is optional: visible browser success counts, verified email sends count with receipt unknown, and matched final delivery failures correct effective totals. Preserve historical events and use explicit corrections for conflicts.
+Read [references/ACCOUNTING.md](references/ACCOUNTING.md) before recording delivery evidence, recovery attempts, or per-lead discovery. For new rounds, record each lead with `round lead --stdin` and derive source totals from those records. Email access is optional: visible browser success counts, verified email sends count with receipt unknown, and matched final delivery failures correct effective totals. A sent-verified outreach counts toward the same round `confirmedCount` unless that company already has a counted apply. Preserve historical events and use explicit corrections for conflicts.
 
 ## Discover and assess
 
@@ -132,7 +136,7 @@ node scripts/job-application.mjs ledger review
 node scripts/job-application.mjs ledger review-ack --stdin
 node scripts/job-application.mjs autonomy grant --stdin
 node scripts/job-application.mjs autonomy status|preview|revoke
-node scripts/job-application.mjs round start|source|complete --stdin
+node scripts/job-application.mjs round start|source|confirm|complete --stdin
 node scripts/job-application.mjs round status [round-id]
 node scripts/job-application.mjs sources list [--stdin]
 node scripts/job-application.mjs sources jobs [--stdin]

package/job-application-agent/references/ACCOUNTING.md

@@ -6,7 +6,7 @@ Browser applications count after visible ATS success. They do not require email
 
 Match a final delivery failure to the actual application attempt using its sent message, recipient, timing and returned failure evidence. Temporary delays, unrelated bounces, and hiring rejections are not delivery failures. A failed notification cannot overturn independent browser confirmation. Never guess an alternate address or automatically resend an uncertain transmission.
 
-`ledger review`, `round status`, and `round complete` share one effective-count projection. They expose `recordedSubmissionCount`, `effectiveSubmissionCount`, `failedDeliveryCount`, and `receiptUnknownEmailCount`. Existing `submittedTotal`/`confirmedCount` fields now reflect effective submissions, not proven email receipt. Conversion denominators exclude failed applications while historical outcomes remain visible. Review cadence and acknowledgement checkpoints use recorded canonical submissions and recorded mature applications, so a late failure does not postpone the next review. Public usage events remain historical activity metrics.
+`ledger review`, `round status`, and `round complete` share one effective-count projection for ledger applications. They expose `recordedSubmissionCount`, `effectiveSubmissionCount`, `failedDeliveryCount`, and `receiptUnknownEmailCount`. Existing `submittedTotal`/`confirmedCount` fields now reflect effective submissions, not proven email receipt. `round status` also adds sent-verified outreach that is attached to the round and not already covered by a counted apply at the same company, exposed as `applyConfirmationCount` plus `outreachConfirmationCount`. Clearing outreach content never drops that attached count. An explicit delivery correction to `not-sent` or `failed` does: the durable confirmation stays on disk, but `confirmedCount` stops counting that send. Conversion denominators exclude failed applications while historical outcomes remain visible. Review cadence and acknowledgement checkpoints use recorded canonical submissions and recorded mature applications, so a late failure does not postpone the next review. Public usage events remain historical activity metrics.
 
 A late failure preserves the original completion event. `shortfallCount` and `needsRecovery` flag the deficit; no run starts or round reopens automatically. Review the derived attention queue before a later authorized recovery.
 

package/job-application-agent/references/ANALYTICS.md

@@ -65,7 +65,7 @@ Company and title values are bounded and rejected when they resemble an email, p
 | `application_paused` | Job hash, ATS, stage, bounded reason |
 | `application_skipped` | Job hash, bounded reason, fit score, eligibility |
 | `application_submitted` | Company, title, job hash/domain, ATS, duration, fields filled, short-answer count, resume-upload Boolean, approval mode |
-| `round_completed` | Requested/submitted/assessed/skipped/paused/error counts, duration bucket; optional attempted/searched/blocked source counts, maximum source share percentage, bounded concentration reason |
+| `round_completed` | Requested/submitted/assessed/skipped/paused/error counts, duration bucket; optional attempted/searched/blocked source counts, maximum source share percentage, bounded concentration reason. `submittedCount` and `assessedCount` are ledger application totals only and never include attached outreach. |
 | `outcome_recorded` | Company, title, job hash/domain, ATS, outcome, days since submission, optional bounded interview quality/failure point |
 | `review_generated` | Canonical unique-submission and outcome counts, review-due Boolean |
 | `skill_error` | Stable error code, workflow stage, ATS/job hash when available, recoverable Boolean |

package/job-application-agent/references/OUTREACH.md

@@ -173,8 +173,15 @@ are explicitly stale. On reconnect, the cache is replaced by authoritative cloud
 data, including clear tombstones. If a lower server revision suggests a restored
 backend or delayed response, the cache is discarded; another online read is
 required before offline inspection is available. Handoffs use atomic database reservations,
-not application submission leases. No operation changes application counts,
-round progress, or the existing application-autonomy grant.
+not application submission leases. Recording `sent-verified` increments the
+active application round (or the round already attached to that opportunity)
+when that company does not already have a counted apply on the same round.
+Auto-attach first does a targeted authenticated reconcile of cloud `rounds`
+events so a second or stale host can see the open round. Apply plus outreach
+at the same company is one confirmation, not two. The existing
+application-autonomy grant is unchanged. Use `round confirm --stdin`
+with `{ "roundId":"round-...","outreachId":"opportunity-..." }` to attach an
+already sent-verified opportunity to an open round.
 
 Outreach commands bypass telemetry, identity transmission, community sharing,
 and their automatic retry paths—including command errors. Only authenticated
@@ -183,11 +190,17 @@ evidence stay in sensitive content storage. Audit rows retain opaque IDs,
 timestamps, coarse transitions, and private keyed fingerprints.
 
 Clear input: `{"operationId":"clear-1","ids":["opportunity-1"]}`.
-Clearing removes sensitive content and blocks resurrection. Minimal outcomes,
-audit history, company/contact fingerprints and suppression remain. Do not
-describe this as deleting every personal-data trace. Disconnected host caches
-and user-managed exports cannot be remotely erased; backups retain old content
-until their existing 30-day expiry.
+Clearing removes sensitive content and blocks resurrection. It never
+un-confirms a counted round attachment: `confirmedCount` stays on the durable
+`submission-confirmed` event and uses the company already stored there.
+A later `not-sent` or `failed` correction of that send is different: the
+attachment event remains, but the projection drops it from `confirmedCount`.
+New attachments require a live outreach snapshot when cloud state is
+configured; cached reads may still power `round status`. Minimal
+outcomes, audit history, company/contact fingerprints and suppression remain.
+Do not describe this as deleting every personal-data trace. Disconnected host
+caches and user-managed exports cannot be remotely erased; backups retain old
+content until their existing 30-day expiry.
 
 Private backups include outreach tables. `cloud export` also includes the
 outreach snapshot and deletion manifest. A manifest must be obtained from the

package/job-application-agent/references/RUNS.md

@@ -14,6 +14,7 @@ Start each batch with an explicit ID:
 node scripts/job-application.mjs round start --stdin
 node scripts/job-application.mjs round source --stdin
 node scripts/job-application.mjs round status [round-id]
+node scripts/job-application.mjs round confirm --stdin
 node scripts/job-application.mjs round complete --stdin
 ```
 
@@ -62,7 +63,7 @@ Coverage reports emit bounded `source_checked` analytics automatically. Only all
 Before completion, audit final email delivery failures through authorized email tools when available; otherwise report delivery not audited and continue. Verified email sends count with receipt unknown. Use `ledger delivery` to record matched failures, never `ledger outcome rejected`. Effective totals exclude failed attempts; completed rounds retain their completion record and expose a recovery shortfall. See [ACCOUNTING.md](ACCOUNTING.md) for safe linked replacement attempts.
 
 
-Count only unique applications with a visible employer/ATS confirmation or a verified sent recruiting email that were also added to the ledger with the same `roundId`. Filled forms, blockers, drafts, unsent email, and ambiguous confirmations never count. `round complete` rejects an under-target round.
+Count unique applications with a visible employer/ATS confirmation or a verified sent recruiting email that were also added to the ledger with the same `roundId`, plus sent-verified outreach attached to that round when the company is not already a counted apply. Filled forms, blockers, drafts, unsent email, user-reported-only outreach, and ambiguous confirmations never count. Apply plus outreach at the same company is one confirmation. `round complete` rejects an under-target round.
 
 Run both company-level and requisition-level duplicate checks before filling and again immediately before transmission. Hard ledger-ID, canonical-URL, employer-job-ID, and requisition duplicates always stop. Same-role aliases require a verified distinct requisition and `NEW REQUISITION CONFIRMED`. A genuinely different role at the same company may proceed automatically only when `companyReapply.decision` is `eligible-after-cooldown`: 15 full days have passed since the latest company application and no outcome has been recorded. `cooldown-active` and `follow-up-present` require explicit candidate approval.
 

package/job-application-agent/references/SCHEMAS.md

@@ -155,7 +155,7 @@ Use `round source --stdin` for per-source search/blocker reports and optional at
 { "requestedCount": 30 }
 ```
 
-`round start --stdin` appends a `started` event to owner-only `rounds.ndjson` and returns a generated `roundId`. Add that ID to every confirmed ledger entry. `round complete --stdin` accepts `{ "roundId": "round-..." }`, plus concentration reason and evidence when required, and appends a completion event only after the target count, source coverage, attribution, and concentration requirements are satisfied.
+`round start --stdin` appends a `started` event to owner-only `rounds.ndjson` and returns a generated `roundId`. Add that ID to every confirmed ledger entry. A `sent-verified` outreach also counts toward `confirmedCount` for the active or attached open round when that company is not already a counted apply on the same round. Once attached, that confirmation stays after `outreach clear`; clear wipes message text and PII only. A later delivery correction to `not-sent` or `failed` stops counting that send. `round confirm` and auto-attach require an authoritative outreach snapshot; they do not mutate from a stale offline cache. `round confirm --stdin` accepts `{ "roundId": "round-...", "outreachId": "opportunity-..." }` (or `outreachIds`) to attach already sent-verified outreach without creating a second ledger application. `round complete --stdin` accepts `{ "roundId": "round-..." }`, plus concentration reason and evidence when required, and appends a completion event only after the target count, source coverage, attribution, and concentration requirements are satisfied. Discovery attribution and lead linkage still apply only to ledger applications.
 
 ## Attention input
 

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

@@ -338,10 +338,17 @@ export class CloudStateClient {
     return (await this.request(`/v2/intents/${encodeURIComponent(intentId)}/confirm`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ application, leaseId, idempotencyKey }) })).json();
   }
 
-  async reconcile({ dryRun = true, provenance = 'local-reconcile' } = {}) {
+  async reconcile({ dryRun = true, provenance = 'local-reconcile', streams = null } = {}) {
     await this.requireAccounting();
     const report = { dryRun, streams: {}, imported: 0, downloaded: 0 };
-    for (const [stream, filename] of Object.entries(CLOUD_STREAM_FILES)) {
+    const selected = streams == null
+      ? Object.entries(CLOUD_STREAM_FILES)
+      : streams.map((stream) => {
+          const filename = CLOUD_STREAM_FILES[stream];
+          if (!filename) throw new Error(`Unknown cloud stream: ${stream}.`);
+          return [stream, filename];
+        });
+    for (const [stream, filename] of selected) {
       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);

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

@@ -26,6 +26,7 @@ import {
   extractNarrativeQuestionsFromText,
   normalizeAttentionQuestions,
 } from './attention-questions.mjs';
+import { confirmOutreachTowardRound, loadOutreachRoundView, loadSentVerifiedOutreach, outreachConfirmationEvents, projectOutreachRoundCounts, resolveOutreachRoundId } from './outreach-round.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']);
@@ -1501,7 +1502,16 @@ async function roundStatus(roundId = null) {
   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 outreachView = await loadOutreachRoundView(dir, cloudState);
+  const outreachCounts = projectOutreachRoundCounts({
+    applications: matching,
+    delivery,
+    roundEvents: events,
+    sentVerified: outreachView.sentVerified,
+    invalidatedIds: outreachView.invalidatedIds,
+    roundId: id,
+  });
+  const confirmedCount = outreachCounts.confirmedCount;
   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);
@@ -1514,7 +1524,9 @@ async function roundStatus(roundId = null) {
     completed: Boolean(completion),
     discoveryPolicyVersion: started.discoveryPolicyVersion ?? 1,
     recordedSubmissionCount: delivery.recordedSubmissionCount,
-    effectiveSubmissionCount: confirmedCount,
+    applyConfirmationCount: outreachCounts.applyConfirmationCount,
+    outreachConfirmationCount: outreachCounts.outreachConfirmationCount,
+    effectiveSubmissionCount: delivery.effectiveSubmissionCount,
     failedDeliveryCount: delivery.failedDeliveryCount,
     receiptUnknownEmailCount: delivery.receiptUnknownEmailCount,
     shortfallCount: Math.max(0, started.requestedCount - confirmedCount),
@@ -1554,6 +1566,44 @@ async function roundComplete(input) {
   return result;
 }
 
+async function roundConfirm(input) {
+  const value = object(input, 'round confirmation');
+  const allowed = new Set(['roundId', 'outreachId', 'outreachIds']);
+  for (const key of Object.keys(value)) if (!allowed.has(key)) throw new Error(`Unknown round confirmation property: ${key}.`);
+  const roundId = string(value.roundId, 'round.roundId', 180);
+  const ids = [];
+  if (value.outreachId != null) ids.push(string(value.outreachId, 'round.outreachId', 100));
+  if (value.outreachIds != null) {
+    if (!Array.isArray(value.outreachIds) || value.outreachIds.length === 0 || value.outreachIds.length > 50) throw new Error('round.outreachIds must be a bounded array of outreach IDs.');
+    for (const [index, id] of value.outreachIds.entries()) ids.push(string(id, `round.outreachIds[${index}]`, 100));
+  }
+  if (!ids.length) throw new Error('round confirm requires outreachId or outreachIds.');
+  const dir = await ensureStateDir();
+  const uniqueIds = [...new Set(ids)];
+  const roundEvents = await jsonLines(join(dir, 'rounds.ndjson'));
+  const sentVerified = new Set((await loadSentVerifiedOutreach(dir, cloudState, { allowCache: false })).map((item) => item.id));
+  for (const outreachId of uniqueIds) {
+    const targetRoundId = resolveOutreachRoundId(roundEvents, { outreachId, roundId });
+    if (!targetRoundId) throw new Error('Application round was not found.');
+    const alreadyAttached = outreachConfirmationEvents(roundEvents, targetRoundId).some((event) => event.outreachId === outreachId);
+    if (!alreadyAttached && !sentVerified.has(outreachId)) throw new Error(`Outreach ${outreachId} is not sent-verified.`);
+  }
+  const confirmations = [];
+  for (const outreachId of uniqueIds) {
+    const result = await confirmOutreachTowardRound({
+      directory: dir,
+      outreachId,
+      roundId,
+      cloudClient: cloudState,
+      requireRoundId: true,
+    });
+    if (result.reason === 'round-not-found') throw new Error('Application round was not found.');
+    if (result.reason === 'not-sent-verified') throw new Error(`Outreach ${outreachId} is not sent-verified.`);
+    confirmations.push(result);
+  }
+  return { ...await roundStatus(roundId), confirmations };
+}
+
 async function frictionRecord(input) {
   const value = object(input, 'friction event');
   const allowed = new Set(['stage', 'ats', 'errorCode', 'reproducible', 'general', 'observedAt']);
@@ -1751,12 +1801,13 @@ function reviewTelemetry(review) {
 }
 
 function roundCompletedTelemetry(round) {
+  const applicationCount = round.applyConfirmationCount ?? round.effectiveSubmissionCount ?? 0;
   return {
     event: 'round_completed',
     properties: {
       requestedCount: round.requestedCount,
-      submittedCount: round.confirmedCount,
-      assessedCount: round.confirmedCount,
+      submittedCount: applicationCount,
+      assessedCount: applicationCount,
       skippedCount: 0,
       pausedCount: round.blockedCount,
       errorCount: 0,
@@ -1828,6 +1879,7 @@ async function executeCommand([area, action, value], telemetry, session, communi
     } });
   }
   else if (area === 'round' && action === 'status') result = await roundStatus(value ?? null);
+  else if (area === 'round' && action === 'confirm' && value === '--stdin') result = await roundConfirm(await jsonStdin());
   else if (area === 'round' && action === 'complete' && value === '--stdin') {
     result = await roundComplete(await jsonStdin());
     if (result.completionRecorded) domainEvents.push(roundCompletedTelemetry(result));
@@ -1853,7 +1905,7 @@ async function executeCommand([area, action, value], telemetry, session, communi
   else if (area === 'attention' && action === 'resolve' && value === '--stdin') result = await attentionResolve(await jsonStdin());
   else if (area === 'friction' && action === 'record' && value === '--stdin') result = await frictionRecord(await jsonStdin());
   else if (area === 'friction' && action === 'list' && value == null) result = await frictionList();
-  else throw new Error('Usage: cloud status|configure --stdin|reconcile [--dry-run]|export [path]|lease-acquire|lease-renew|lease-release|intent-prepare --stdin|intent-sent --stdin|intent-confirm --stdin; profile set|migrate --stdin; profile check|field <name>; resume import <url-or-pdf>|path; score --stdin; ledger check|add|outcome|review-ack --stdin; ledger review; autonomy grant --stdin|status|preview|revoke; round start|source|complete --stdin|status [round-id]; sources list [--stdin]|jobs [--stdin]|suggest --stdin|pending|sync|sharing status|enable|disable|reset; attention add|resolve --stdin|list; friction record --stdin|list; telemetry status|enable|disable|reset|preview --stdin|record --stdin');
+  else throw new Error('Usage: cloud status|configure --stdin|reconcile [--dry-run]|export [path]|lease-acquire|lease-renew|lease-release|intent-prepare --stdin|intent-sent --stdin|intent-confirm --stdin; profile set|migrate --stdin; profile check|field <name>; resume import <url-or-pdf>|path; score --stdin; ledger check|add|outcome|review-ack --stdin; ledger review; autonomy grant --stdin|status|preview|revoke; round start|source|confirm|complete --stdin|status [round-id]; sources list [--stdin]|jobs [--stdin]|suggest --stdin|pending|sync|sharing status|enable|disable|reset; attention add|resolve --stdin|list; friction record --stdin|list; telemetry status|enable|disable|reset|preview --stdin|record --stdin');
   for (const event of domainEvents) await telemetry.record(event, session);
   return result;
 }

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

@@ -5,6 +5,7 @@ import { join } from 'node:path';
 import { CloudStateClient, defaultCloudConfigPath } from './cloud-state-client.mjs';
 import { migrateLegacyStateDir, resolveStateDir } from './secret-store.mjs';
 import { mutateOutreach, readOutreach, OUTREACH_CAPABILITY } from './outreach-domain.mjs';
+import { confirmOutreachTowardRound } from './outreach-round.mjs';
 import { privateOutreachWrite, withLocalOutreach, withOutreachLock } from './outreach-store.mjs';
 
 const READS = new Set(['policy-status', 'list', 'show', 'review']);
@@ -91,5 +92,21 @@ export async function runOutreach(args, { input: suppliedInput, stateDirectory =
     result = await withLocalOutreach(stateDirectory, state => read ? { result: readOutreach(state, action, input) } : mutateOutreach(state, action, input, { ...context, actor: 'local' }));
   }
   if (action === 'policy-enable') await guard();
+  if (action === 'record' && input?.type === 'sent-verified' && result?.delivery === 'sent-verified' && input?.id) {
+    try {
+      result = {
+        ...result,
+        roundConfirmation: await confirmOutreachTowardRound({
+          directory: stateDirectory,
+          outreachId: input.id,
+          cloudClient: cloud,
+          occurredAt: input.occurredAt,
+        }),
+      };
+    } catch {
+      // The outreach observation already committed; attachment is a secondary result.
+      result = { ...result, roundConfirmation: { counted: false, reason: 'attachment-failed', outreachId: input.id } };
+    }
+  }
   return result;
 }

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

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

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

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

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

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

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

@@ -0,0 +1,489 @@
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+import { deliveryProjection } from '../scripts/application-accounting.mjs';
+import { assessment, handoff } from './fixtures/outreach.mjs';
+import {
+  OUTREACH_ROUND_CHANNEL,
+  companyCountKey,
+  confirmOutreachTowardRound,
+  invalidatedOutreachIds,
+  loadSentVerifiedOutreach,
+  projectOutreachRoundCounts,
+  resolveOutreachRoundId,
+  sentVerifiedFromOutreachItems,
+} from '../scripts/outreach-round.mjs';
+
+const script = fileURLToPath(new URL('../scripts/job-application.mjs', import.meta.url));
+
+function application(roundId, company = 'Example') {
+  return {
+    id: `app-${company.toLowerCase().replace(/[^a-z0-9]+/g, '-')}`,
+    company,
+    role: 'Staff Product Engineer',
+    url: `https://jobs.fixture.example/${company.toLowerCase().replace(/[^a-z0-9]+/g, '-')}`,
+    employerJobId: `example:${company}`,
+    source: 'ashby',
+    discoverySource: 'linkedin',
+    applicationChannel: 'ashby',
+    roundId,
+    score: 86,
+    status: 'submitted',
+    submittedAt: '2026-09-14T10:00:00.000Z',
+    approval: 'STANDING AUTHORIZATION',
+    answers: {},
+  };
+}
+
+function verifiedItem(id, company) {
+  return {
+    id,
+    delivery: 'sent-verified',
+    content: { assessment: { company: { name: company }, role: 'Staff Product Engineer' } },
+  };
+}
+
+test('sent-verified outreach increments a round when no apply exists', () => {
+  const delivery = deliveryProjection([], []);
+  const counts = projectOutreachRoundCounts({
+    applications: [],
+    delivery,
+    roundEvents: [{ type: 'submission-confirmed', roundId: 'round-1', outreachId: 'noon', channel: OUTREACH_ROUND_CHANNEL, company: 'Noon' }],
+    sentVerified: sentVerifiedFromOutreachItems([verifiedItem('noon', 'Noon')]),
+    roundId: 'round-1',
+  });
+  assert.equal(counts.applyConfirmationCount, 0);
+  assert.equal(counts.outreachConfirmationCount, 1);
+  assert.equal(counts.confirmedCount, 1);
+});
+
+test('apply plus outreach at the same company counts once', () => {
+  const applications = [application('round-1', 'Tricog')];
+  const delivery = deliveryProjection(applications, []);
+  const counts = projectOutreachRoundCounts({
+    applications,
+    delivery,
+    roundEvents: [{ type: 'submission-confirmed', roundId: 'round-1', outreachId: 'tricog', channel: OUTREACH_ROUND_CHANNEL, company: 'Tricog' }],
+    sentVerified: sentVerifiedFromOutreachItems([verifiedItem('tricog', 'Tricog')]),
+    roundId: 'round-1',
+  });
+  assert.equal(counts.applyConfirmationCount, 1);
+  assert.equal(counts.outreachConfirmationCount, 0);
+  assert.equal(counts.confirmedCount, 1);
+});
+
+test('cleared outreach still counts from the durable confirmation company', () => {
+  const counts = projectOutreachRoundCounts({
+    applications: [],
+    delivery: deliveryProjection([], []),
+    roundEvents: [{ type: 'submission-confirmed', roundId: 'round-1', outreachId: 'noon', channel: OUTREACH_ROUND_CHANNEL, company: 'Noon' }],
+    sentVerified: sentVerifiedFromOutreachItems([{
+      id: 'noon',
+      delivery: 'sent-verified',
+      cleared: true,
+      content: { assessment: { company: { name: 'Noon' }, role: 'Staff Product Engineer' } },
+    }]),
+    roundId: 'round-1',
+  });
+  assert.equal(counts.applyConfirmationCount, 0);
+  assert.equal(counts.outreachConfirmationCount, 1);
+  assert.equal(counts.confirmedCount, 1);
+});
+
+test('linked company names share one count key', () => {
+  assert.equal(companyCountKey('Made Card'), companyCountKey('MadeCard'));
+  const applications = [application('round-1', 'MadeCard')];
+  const delivery = deliveryProjection(applications, []);
+  const counts = projectOutreachRoundCounts({
+    applications,
+    delivery,
+    roundEvents: [{ type: 'submission-confirmed', roundId: 'round-1', outreachId: 'made', channel: OUTREACH_ROUND_CHANNEL, company: 'Made Card' }],
+    sentVerified: sentVerifiedFromOutreachItems([verifiedItem('made', 'Made Card')]),
+    roundId: 'round-1',
+  });
+  assert.equal(counts.applyConfirmationCount, 1);
+  assert.equal(counts.outreachConfirmationCount, 0);
+  assert.equal(counts.confirmedCount, 1);
+});
+
+test('explicit confirm cannot reassign an attached outreach to another round', () => {
+  assert.throws(() => resolveOutreachRoundId([
+    { type: 'started', roundId: 'round-a', requestedCount: 30, occurredAt: '2026-09-14T10:00:00.000Z' },
+    { type: 'submission-confirmed', roundId: 'round-a', outreachId: 'noon', channel: OUTREACH_ROUND_CHANNEL, company: 'Noon' },
+    { type: 'started', roundId: 'round-b', requestedCount: 30, occurredAt: '2026-09-14T11:00:00.000Z' },
+  ], { outreachId: 'noon', roundId: 'round-b' }), /already attached to another round/);
+});
+
+test('apply-only still increments without outreach', () => {
+  const applications = [application('round-1', 'MadeCard')];
+  const delivery = deliveryProjection(applications, []);
+  const counts = projectOutreachRoundCounts({
+    applications,
+    delivery,
+    roundEvents: [],
+    sentVerified: [],
+    roundId: 'round-1',
+  });
+  assert.equal(counts.applyConfirmationCount, 1);
+  assert.equal(counts.outreachConfirmationCount, 0);
+  assert.equal(counts.confirmedCount, 1);
+});
+
+async function fixture(t, label) {
+  const directory = await mkdtemp(join(tmpdir(), `outreach-round-${label}-`));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  await writeFile(join(directory, 'telemetry.json'), JSON.stringify({
+    version: 1,
+    enabled: false,
+    disclosed: true,
+    graceConsumed: true,
+    installationEventPending: false,
+  }));
+  const env = {
+    ...process.env,
+    JOB_APPLICATION_AGENT_STATE_DIR: directory,
+    JOB_APPLICATION_AGENT_CLOUD_CONFIG: join(directory, 'cloud-config.json'),
+    JOB_APPLICATION_AGENT_SOURCE_COMMUNITY_URL: 'http://127.0.0.1:9',
+  };
+  const cli = (args, input) => JSON.parse(execFileSync(process.execPath, [script, ...args], {
+    env,
+    encoding: 'utf8',
+    ...(input === undefined ? {} : { input: JSON.stringify(input) }),
+  }));
+  return { directory, env, cli };
+}
+
+function recordVerifiedOutreach(cli, { id, company, domain }) {
+  cli(['outreach', 'policy', 'enable', '--stdin'], { operationId: `enable-${id}`, timezone: 'Asia/Kolkata' });
+  cli(['outreach', 'assess', '--stdin'], assessment(id, {
+    operationId: `assess-${id}`,
+    company: { name: company, domain, aliases: [] },
+    recipient: { account: `https://www.linkedin.com/in/${id}-recruiter`, aliases: [] },
+  }));
+  cli(['outreach', 'draft', '--stdin'], {
+    operationId: `draft-${id}`,
+    id,
+    text: 'Your product engineering role fits my experience. Would a brief conversation be useful?',
+    claimRefs: ['experience'],
+    purpose: 'initial',
+  });
+  const recheckedAt = new Date().toISOString();
+  cli(['outreach', 'handoff', '--stdin'], handoff({
+    operationId: `handoff-${id}`,
+    id,
+    recheckedAt,
+    history: { kind: 'user-reported', noPriorPitch: true, checkedAt: recheckedAt },
+  }));
+  const occurredAt = new Date().toISOString();
+  return cli(['outreach', 'record', '--stdin'], {
+    operationId: `sent-${id}`,
+    id,
+    attemptId: `handoff-${id}`,
+    type: 'sent-verified',
+    occurredAt,
+    evidence: 'Visible sent message in the conversation.',
+    messageRef: `visible-message-${id}`,
+  });
+}
+
+test('CLI sent-verified outreach increments the active round', async (t) => {
+  const { cli } = await fixture(t, 'outreach-only');
+  const { roundId } = cli(['round', 'start', '--stdin'], { requestedCount: 30 });
+  const recorded = recordVerifiedOutreach(cli, { id: 'noon', company: 'Noon', domain: 'noon.com' });
+  assert.equal(recorded.delivery, 'sent-verified');
+  assert.equal(recorded.roundConfirmation.counted, true);
+  assert.equal(recorded.roundConfirmation.roundId, roundId);
+  const status = cli(['round', 'status', roundId]);
+  assert.equal(status.applyConfirmationCount, 0);
+  assert.equal(status.outreachConfirmationCount, 1);
+  assert.equal(status.confirmedCount, 1);
+  assert.equal(status.effectiveSubmissionCount, 0);
+  const again = cli(['round', 'confirm', '--stdin'], { roundId, outreachId: 'noon' });
+  assert.equal(again.confirmations[0].reason, 'already-recorded');
+  assert.equal(again.confirmedCount, 1);
+});
+
+test('CLI apply plus outreach for the same company counts once', async (t) => {
+  const { cli } = await fixture(t, 'apply-and-outreach');
+  const { roundId } = cli(['round', 'start', '--stdin'], { requestedCount: 30 });
+  cli(['ledger', 'add', '--stdin'], application(roundId, 'Tricog'));
+  const recorded = recordVerifiedOutreach(cli, { id: 'tricog', company: 'Tricog', domain: 'tricog.com' });
+  assert.equal(recorded.roundConfirmation.counted, false);
+  assert.equal(recorded.roundConfirmation.reason, 'already-applied');
+  const status = cli(['round', 'status', roundId]);
+  assert.equal(status.applyConfirmationCount, 1);
+  assert.equal(status.outreachConfirmationCount, 0);
+  assert.equal(status.confirmedCount, 1);
+  assert.equal(status.effectiveSubmissionCount, 1);
+});
+
+test('CLI apply-only still increments the round', async (t) => {
+  const { cli } = await fixture(t, 'apply-only');
+  const { roundId } = cli(['round', 'start', '--stdin'], { requestedCount: 30 });
+  cli(['ledger', 'add', '--stdin'], application(roundId, 'MadeCard'));
+  const status = cli(['round', 'status', roundId]);
+  assert.equal(status.applyConfirmationCount, 1);
+  assert.equal(status.outreachConfirmationCount, 0);
+  assert.equal(status.confirmedCount, 1);
+  assert.equal(status.effectiveSubmissionCount, 1);
+});
+
+test('later progression records do not auto-attach a historical send', async (t) => {
+  const { cli } = await fixture(t, 'reply-does-not-count');
+  const recorded = recordVerifiedOutreach(cli, { id: 'noon', company: 'Noon', domain: 'noon.com' });
+  assert.equal(recorded.roundConfirmation.counted, false);
+  assert.equal(recorded.roundConfirmation.reason, 'no-active-round');
+  const { roundId } = cli(['round', 'start', '--stdin'], { requestedCount: 30 });
+  const reply = cli(['outreach', 'record', '--stdin'], {
+    operationId: 'reply-noon',
+    id: 'noon',
+    type: 'replied',
+    occurredAt: new Date().toISOString(),
+    evidence: 'Recruiter replied in the conversation.',
+    replyTone: 'neutral',
+  });
+  assert.equal(reply.delivery, 'sent-verified');
+  assert.equal(reply.roundConfirmation, undefined);
+  const status = cli(['round', 'status', roundId]);
+  assert.equal(status.outreachConfirmationCount, 0);
+  assert.equal(status.confirmedCount, 0);
+});
+
+test('batch confirm validates every ID before committing any', async (t) => {
+  const { cli } = await fixture(t, 'batch-validate');
+  recordVerifiedOutreach(cli, { id: 'noon', company: 'Noon', domain: 'noon.com' });
+  const { roundId } = cli(['round', 'start', '--stdin'], { requestedCount: 30 });
+  assert.throws(
+    () => cli(['round', 'confirm', '--stdin'], { roundId, outreachIds: ['noon', 'missing'] }),
+    /not sent-verified/,
+  );
+  const status = cli(['round', 'status', roundId]);
+  assert.equal(status.outreachConfirmationCount, 0);
+  assert.equal(status.confirmedCount, 0);
+});
+
+test('CLI delivery correction drops confirmedCount after a counted send', async (t) => {
+  const { cli } = await fixture(t, 'delivery-correction');
+  const { roundId } = cli(['round', 'start', '--stdin'], { requestedCount: 30 });
+  recordVerifiedOutreach(cli, { id: 'noon', company: 'Noon', domain: 'noon.com' });
+  assert.equal(cli(['round', 'status', roundId]).confirmedCount, 1);
+  cli(['outreach', 'record', '--stdin'], {
+    operationId: 'correct-noon',
+    id: 'noon',
+    attemptId: 'handoff-noon',
+    type: 'not-sent',
+    occurredAt: new Date().toISOString(),
+    evidence: 'Visible conversation shows the message was not sent.',
+    supersedes: ['sent-noon'],
+  });
+  const after = cli(['round', 'status', roundId]);
+  assert.equal(after.confirmedCount, 0);
+  assert.equal(after.outreachConfirmationCount, 0);
+});
+
+test('sent-verified confirm then clear leaves confirmedCount unchanged', async (t) => {
+  const { cli } = await fixture(t, 'clear-keeps-count');
+  const { roundId } = cli(['round', 'start', '--stdin'], { requestedCount: 30 });
+  const recorded = recordVerifiedOutreach(cli, { id: 'noon', company: 'Noon', domain: 'noon.com' });
+  assert.equal(recorded.roundConfirmation.counted, true);
+  const before = cli(['round', 'status', roundId]);
+  assert.equal(before.confirmedCount, 1);
+  assert.equal(before.outreachConfirmationCount, 1);
+  cli(['outreach', 'clear', '--stdin'], { operationId: 'clear-noon', ids: ['noon'] });
+  const after = cli(['round', 'status', roundId]);
+  assert.equal(after.confirmedCount, before.confirmedCount);
+  assert.equal(after.outreachConfirmationCount, 1);
+  assert.equal(after.applyConfirmationCount, 0);
+});
+
+test('explicit confirm rejects moving an attached outreach to another round', async (t) => {
+  const { cli } = await fixture(t, 'no-reassign');
+  const first = cli(['round', 'start', '--stdin'], { requestedCount: 30 });
+  recordVerifiedOutreach(cli, { id: 'noon', company: 'Noon', domain: 'noon.com' });
+  const second = cli(['round', 'start', '--stdin'], { requestedCount: 30 });
+  assert.throws(
+    () => cli(['round', 'confirm', '--stdin'], { roundId: second.roundId, outreachId: 'noon' }),
+    /already attached to another round/,
+  );
+  assert.equal(cli(['round', 'status', first.roundId]).confirmedCount, 1);
+  assert.equal(cli(['round', 'status', second.roundId]).confirmedCount, 0);
+});
+
+test('auto-attach reconciles authenticated cloud rounds before choosing a destination', async (t) => {
+  const directory = await mkdtemp(join(tmpdir(), 'outreach-round-reconcile-'));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const started = { type: 'started', roundId: 'cloud-round', requestedCount: 30, occurredAt: '2026-09-14T10:00:00.000Z' };
+  const reconcileCalls = [];
+  const cloudClient = {
+    configured: async () => true,
+    status: async () => ({ configured: true, capabilities: ['outreach-tracking-v1'] }),
+    request: async () => ({ json: async () => ({ items: [verifiedItem('noon', 'Noon')] }) }),
+    reconcile: async (options) => {
+      reconcileCalls.push(options);
+      await writeFile(join(directory, 'rounds.ndjson'), `${JSON.stringify(started)}\n`);
+    },
+    appendRecord: async () => {},
+  };
+  const result = await confirmOutreachTowardRound({
+    directory,
+    outreachId: 'noon',
+    cloudClient,
+    occurredAt: '2026-09-14T11:00:00.000Z',
+  });
+  assert.deepEqual(reconcileCalls, [{ dryRun: false, provenance: 'outreach-round-attach', streams: ['rounds'] }]);
+  assert.equal(result.counted, true);
+  assert.equal(result.roundId, 'cloud-round');
+  assert.equal(result.company, 'Noon');
+});
+
+test('unmigrated outreach backend is an empty verified set', async (t) => {
+  const directory = await mkdtemp(join(tmpdir(), 'outreach-round-unmigrated-'));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const missingCapability = await loadSentVerifiedOutreach(directory, {
+    configured: async () => true,
+    status: async () => ({ configured: true, capabilities: ['application-accounting-v1'] }),
+    request: async () => {
+      throw new Error('Cloud state request failed (409): Outreach backend migration required');
+    },
+  });
+  assert.deepEqual(missingCapability, []);
+  const migrationConflict = await loadSentVerifiedOutreach(directory, {
+    configured: async () => true,
+    status: async () => ({ configured: true, capabilities: ['application-accounting-v1', 'outreach-tracking-v1'] }),
+    request: async () => {
+      throw new Error('Cloud state request failed (409): Outreach backend migration required');
+    },
+  });
+  assert.deepEqual(migrationConflict, []);
+});
+
+test('local outreach read failures stay visible to round status', async (t) => {
+  const directory = await mkdtemp(join(tmpdir(), 'outreach-round-locked-'));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  await writeFile(join(directory, 'outreach.lock'), 'stale-lock');
+  await assert.rejects(
+    () => loadSentVerifiedOutreach(directory, { configured: async () => false }),
+    /Outreach store is unavailable/,
+  );
+});
+
+test('delivery correction invalidates a counted confirmation; clear does not', () => {
+  const confirmation = { type: 'submission-confirmed', roundId: 'round-1', outreachId: 'noon', channel: OUTREACH_ROUND_CHANNEL, company: 'Noon' };
+  const failed = {
+    id: 'noon',
+    delivery: 'failed',
+    cleared: false,
+    attempts: [{ id: 'handoff-noon', purpose: 'initial', delivery: 'failed' }],
+    content: { assessment: { company: { name: 'Noon' }, role: 'Staff Product Engineer' } },
+  };
+  const failedCounts = projectOutreachRoundCounts({
+    applications: [],
+    delivery: deliveryProjection([], []),
+    roundEvents: [confirmation],
+    sentVerified: sentVerifiedFromOutreachItems([failed]),
+    invalidatedIds: invalidatedOutreachIds([failed]),
+    roundId: 'round-1',
+  });
+  assert.equal(failedCounts.outreachConfirmationCount, 0);
+  assert.equal(failedCounts.confirmedCount, 0);
+
+  const cleared = {
+    id: 'noon',
+    delivery: 'sent-verified',
+    cleared: true,
+    attempts: [{ id: 'handoff-noon', purpose: 'initial', delivery: 'sent-verified' }],
+    content: { assessment: { company: { name: 'Noon' }, role: 'Staff Product Engineer' } },
+  };
+  const clearedCounts = projectOutreachRoundCounts({
+    applications: [],
+    delivery: deliveryProjection([], []),
+    roundEvents: [confirmation],
+    sentVerified: sentVerifiedFromOutreachItems([cleared]),
+    invalidatedIds: invalidatedOutreachIds([cleared]),
+    roundId: 'round-1',
+  });
+  assert.equal(clearedCounts.outreachConfirmationCount, 1);
+  assert.equal(clearedCounts.confirmedCount, 1);
+});
+
+test('attached company identity stays on the confirmation event', () => {
+  const applications = [application('round-1', 'Acme')];
+  const delivery = deliveryProjection(applications, []);
+  const renamed = verifiedItem('acme', 'Acme Holdings');
+  const counts = projectOutreachRoundCounts({
+    applications,
+    delivery,
+    roundEvents: [{ type: 'submission-confirmed', roundId: 'round-1', outreachId: 'acme', channel: OUTREACH_ROUND_CHANNEL, company: 'Acme' }],
+    sentVerified: sentVerifiedFromOutreachItems([renamed]),
+    invalidatedIds: invalidatedOutreachIds([renamed]),
+    roundId: 'round-1',
+  });
+  assert.equal(counts.applyConfirmationCount, 1);
+  assert.equal(counts.outreachConfirmationCount, 0);
+  assert.equal(counts.confirmedCount, 1);
+});
+
+test('non-ASCII company names keep distinct count keys', () => {
+  assert.equal(companyCountKey('Made Card'), companyCountKey('MadeCard'));
+  assert.notEqual(companyCountKey('ソニー'), '');
+  assert.notEqual(companyCountKey('トヨタ'), '');
+  assert.notEqual(companyCountKey('ソニー'), companyCountKey('トヨタ'));
+});
+
+test('an earlier sent-verified attempt still qualifies after a later pending follow-up', () => {
+  const item = {
+    id: 'noon',
+    delivery: 'pending-handoff',
+    attempts: [
+      { id: 'handoff-noon', purpose: 'initial', delivery: 'sent-verified' },
+      { id: 'follow-noon', purpose: 'follow-up', delivery: 'pending-handoff' },
+    ],
+    content: { assessment: { company: { name: 'Noon' }, role: 'Staff Product Engineer' } },
+  };
+  const verified = sentVerifiedFromOutreachItems([item]);
+  assert.equal(verified.length, 1);
+  assert.equal(verified[0].id, 'noon');
+});
+
+test('confirm refuses a cached outreach snapshot when cloud is unavailable', async (t) => {
+  const directory = await mkdtemp(join(tmpdir(), 'outreach-round-no-cache-confirm-'));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  await writeFile(join(directory, 'rounds.ndjson'), `${JSON.stringify({ type: 'started', roundId: 'round-1', requestedCount: 30, occurredAt: '2026-09-14T10:00:00.000Z' })}\n`);
+  await writeFile(join(directory, 'outreach-cloud-cache.json'), JSON.stringify({
+    snapshot: { items: [verifiedItem('noon', 'Noon')] },
+  }));
+  const cloudClient = {
+    configured: async () => true,
+    status: async () => ({ configured: true, capabilities: ['outreach-tracking-v1'] }),
+    request: async () => {
+      throw new Error('Cloud state unavailable: network down');
+    },
+    reconcile: async () => {
+      throw new Error('Cloud state unavailable: network down');
+    },
+    appendRecord: async () => {
+      throw new Error('should not append from cache');
+    },
+  };
+  await assert.rejects(
+    () => confirmOutreachTowardRound({ directory, outreachId: 'noon', cloudClient }),
+    /authoritative state/,
+  );
+  const cachedStatus = await loadSentVerifiedOutreach(directory, cloudClient, { allowCache: true });
+  assert.equal(cachedStatus.length, 1);
+});
+
+test('round attachment failure does not disguise a committed send', async (t) => {
+  const { directory, cli } = await fixture(t, 'attachment-failed');
+  const { roundId } = cli(['round', 'start', '--stdin'], { requestedCount: 30 });
+  await writeFile(join(directory, 'rounds.ndjson'), `${JSON.stringify({ type: 'started', roundId, requestedCount: 30, occurredAt: '2026-09-14T10:00:00.000Z' })}\nnot-json\n`);
+  const recorded = recordVerifiedOutreach(cli, { id: 'noon', company: 'Noon', domain: 'noon.com' });
+  assert.equal(recorded.delivery, 'sent-verified');
+  assert.equal(recorded.roundConfirmation.counted, false);
+  assert.equal(recorded.roundConfirmation.reason, 'attachment-failed');
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "job-application-agent",
-  "version": "3.7.1",
+  "version": "3.7.2",
   "description": "A privacy-first Agent Skill and CLI for evidence-based job discovery, application completion, and outcome tracking.",
   "license": "MIT",
   "type": "module",
@@ -44,7 +44,7 @@
     "check:native-artifacts": "node scripts/ci/validate-native-artifacts.mjs",
     "privacy-audit": "node --test job-application-agent/tests/privacy-audit.test.mjs job-application-agent/tests/outreach-cli.test.mjs",
     "smoke:package": "node scripts/smoke-package.mjs",
-    "check": "node --check job-application-agent/scripts/job-application.mjs && node --check job-application-agent/scripts/attention-runner-poll.mjs && node --check job-application-agent/scripts/attention-resume-submit.mjs && node --check job-application-agent/scripts/session-binding.mjs && node --check job-application-agent/scripts/novnc-display-guard.mjs && node --check job-application-agent/scripts/ats/submit-adapters.mjs && node --check job-application-agent/scripts/cloud-state-client.mjs && node --check job-application-agent/scripts/secret-store.mjs && node --check job-application-agent/scripts/source-community-client.mjs && node --check job-application-agent/scripts/source-community-schema.mjs && node --check job-application-agent/scripts/telemetry-client.mjs && node --check job-application-agent/scripts/telemetry-schema.mjs && node --check job-application-agent/scripts/version.mjs && node --check telemetry-worker/src/worker.mjs && node --check telemetry-worker/src/public-stats.mjs && node --check telemetry-worker/public/dashboard.js && node --check installer/src/cli.mjs && node --check installer/src/installer.mjs && node --check installer/src/runner.mjs && node --check installer/src/scheduler.mjs && node --check scripts/ci/classify-paths.mjs && node --check scripts/ci/validate-native-artifacts.mjs && node --check bin/job-application-agent.mjs && node --check state-worker/src/worker.mjs && node --check state-worker/src/backup.mjs && node --check state-worker/src/cli.mjs && node --check state-worker/bin/sync.mjs && node --check job-application-agent/scripts/application-accounting.mjs && node --check job-application-agent/scripts/outreach-domain.mjs && node --check job-application-agent/scripts/outreach-store.mjs && node --check job-application-agent/scripts/outreach-cli.mjs && node --check state-worker/src/outreach.mjs && node --check job-application-agent/scripts/ats/answer-inject.mjs && node --check job-application-agent/scripts/attention-questions.mjs && node --check job-application-agent/scripts/captcha-vendor.mjs",
+    "check": "node --check job-application-agent/scripts/job-application.mjs && node --check job-application-agent/scripts/attention-runner-poll.mjs && node --check job-application-agent/scripts/attention-resume-submit.mjs && node --check job-application-agent/scripts/session-binding.mjs && node --check job-application-agent/scripts/novnc-display-guard.mjs && node --check job-application-agent/scripts/ats/submit-adapters.mjs && node --check job-application-agent/scripts/cloud-state-client.mjs && node --check job-application-agent/scripts/secret-store.mjs && node --check job-application-agent/scripts/source-community-client.mjs && node --check job-application-agent/scripts/source-community-schema.mjs && node --check job-application-agent/scripts/telemetry-client.mjs && node --check job-application-agent/scripts/telemetry-schema.mjs && node --check job-application-agent/scripts/version.mjs && node --check telemetry-worker/src/worker.mjs && node --check telemetry-worker/src/public-stats.mjs && node --check telemetry-worker/public/dashboard.js && node --check installer/src/cli.mjs && node --check installer/src/installer.mjs && node --check installer/src/runner.mjs && node --check installer/src/scheduler.mjs && node --check scripts/ci/classify-paths.mjs && node --check scripts/ci/validate-native-artifacts.mjs && node --check bin/job-application-agent.mjs && node --check state-worker/src/worker.mjs && node --check state-worker/src/backup.mjs && node --check state-worker/src/cli.mjs && node --check state-worker/bin/sync.mjs && node --check job-application-agent/scripts/application-accounting.mjs && node --check job-application-agent/scripts/outreach-domain.mjs && node --check job-application-agent/scripts/outreach-store.mjs && node --check job-application-agent/scripts/outreach-cli.mjs && node --check job-application-agent/scripts/outreach-round.mjs && node --check state-worker/src/outreach.mjs && node --check job-application-agent/scripts/ats/answer-inject.mjs && node --check job-application-agent/scripts/attention-questions.mjs && node --check job-application-agent/scripts/captcha-vendor.mjs",
     "prepack": "npm run check && npm test && npm run privacy-audit"
   },
   "engines": {