job-application-agent 3.1.1 → 3.1.2

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

@@ -1,11 +1,15 @@
 #!/usr/bin/env node
 
 import { createHash, randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
 import { appendFile, chmod, mkdir, open, readFile, rename, stat, unlink, writeFile } from 'node:fs/promises';
 import { platform } from 'node:os';
 import { basename, join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
 
 import { createSecretStore, migrateLegacyStateDir, resolveStateDir } from './secret-store.mjs';
+import { SourceCommunityClient } from './source-community-client.mjs';
+import { normalizeCommunitySource } from './source-community-schema.mjs';
 import { TelemetryClient } from './telemetry-client.mjs';
 import { jobIdentity } from './telemetry-schema.mjs';
 
@@ -27,6 +31,12 @@ const AUTONOMY_HARD_STOPS = Object.freeze(['authentication', 'mfa', 'captcha', '
 const ATTENTION_STAGES = new Set(['discovery', 'assessment', 'application', 'contact', 'resume', 'questions', 'legal', 'demographic', 'review', 'submission', 'confirmation', 'outcome', 'answers', 'upload']);
 const ATTENTION_BLOCKERS = new Set(['authentication', 'mfa', 'captcha', 'legal-attestation', 'demographic', 'government-id', 'ambiguous-authorization', 'ambiguous-compensation', 'unverifiable-claim', 'judgment', 'video', 'upload', 'site-error', 'other']);
 const REQUIRED_ACTIONS = new Set(['sign-in', 'complete-mfa', 'complete-captcha', 'review-legal', 'choose-demographic', 'provide-government-id', 'provide-authorization', 'provide-compensation', 'verify-claim', 'provide-judgment', 'record-video', 'enable-upload', 'retry-site']);
+const COMPANY_REAPPLY_COOLDOWN_DAYS = 15;
+const COMPANY_REAPPLY_OVERRIDE = 'CANDIDATE APPROVED EARLY REAPPLICATION';
+const SOURCE_CATALOG_URL = new URL('../references/SOURCES.json', import.meta.url);
+const SOURCE_CATALOG = JSON.parse(readFileSync(SOURCE_CATALOG_URL, 'utf8'));
+if (!Array.isArray(SOURCE_CATALOG)) throw new Error('The packaged source catalog is invalid.');
+const SOURCE_CATALOG_IDS = new Set(SOURCE_CATALOG.map((source) => sourceId(source.id, 'source catalog id')));
 const REQUIRED_PROFILE = ['name', 'email', 'phone', 'location', 'workAuthorization', 'roleFamilies', 'seniority', 'targetLocations', 'workModes', 'submissionMode', 'yearsExperience', 'autoSubmitMinScore', 'manualReviewMinScore', 'minMustHaveCoverage'];
 const STRING_PROFILE_FIELDS = new Set(['name', 'email', 'phone', 'location', 'workAuthorization', 'linkedin', 'github', 'portfolio', 'availability', 'currentCompensation', 'targetCompensation', 'submissionMode']);
 const ARRAY_PROFILE_FIELDS = new Set(['roleFamilies', 'seniority', 'skills', 'targetLocations', 'excludedLocations', 'workModes', 'industries', 'excludedCompanies']);
@@ -78,6 +88,7 @@ export function commandCategory([area, action]) {
   if (area === 'telemetry') return 'telemetry';
   if (area === 'autonomy') return 'profile';
   if (area === 'round') return 'round';
+  if (area === 'sources') return 'search';
   if (area === 'attention' || area === 'friction') return 'batch';
   return 'other';
 }
@@ -172,6 +183,12 @@ function stringArray(value, label, required = false) {
   return value.map((item, index) => string(item, `${label}[${index}]`, 300));
 }
 
+function sourceId(value, label) {
+  const id = string(value, label, 80).toLowerCase();
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(id)) throw new Error(`${label} must be a kebab-case public source ID.`);
+  return id;
+}
+
 function integer(value, label, min, max) {
   if (!Number.isInteger(value) || value < min || value > max) throw new Error(`${label} must be an integer from ${min} to ${max}.`);
   return value;
@@ -250,6 +267,9 @@ export function scoreJob(input, target) {
   const description = string(job.description, 'job.description', 40000);
   const source = string(job.source, 'job.source', 40).toLowerCase();
   const discoverySource = job.discoverySource == null ? null : string(job.discoverySource, 'job.discoverySource', 40).toLowerCase();
+  if (job.discoverySourceId != null && !SOURCE_CATALOG_IDS.has(sourceId(job.discoverySourceId, 'job.discoverySourceId'))) {
+    throw new Error('job.discoverySourceId must match an ID in the packaged source catalog.');
+  }
   const applicationChannel = job.applicationChannel == null ? null : string(job.applicationChannel, 'job.applicationChannel', 40).toLowerCase();
   const eligibility = string(job.eligibility, 'job.eligibility', 40).toLowerCase();
   const postingStatus = string(job.postingStatus ?? 'unclear', 'job.postingStatus', 40).toLowerCase();
@@ -407,6 +427,10 @@ export function validateLedgerEntry(input) {
   };
   if (entry.employerJobId != null) normalized.employerJobId = string(entry.employerJobId, 'entry.employerJobId', 300);
   if (entry.discoverySource != null) normalized.discoverySource = string(entry.discoverySource, 'entry.discoverySource', 40).toLowerCase();
+  if (entry.discoverySourceId != null) {
+    normalized.discoverySourceId = sourceId(entry.discoverySourceId, 'entry.discoverySourceId');
+    if (!SOURCE_CATALOG_IDS.has(normalized.discoverySourceId)) throw new Error('entry.discoverySourceId must match an ID in the packaged source catalog.');
+  }
   if (entry.applicationChannel != null) normalized.applicationChannel = string(entry.applicationChannel, 'entry.applicationChannel', 40).toLowerCase();
   if (entry.roundId != null) normalized.roundId = string(entry.roundId, 'entry.roundId', 180);
   if (!SOURCES.has(normalized.source)) throw new Error('entry.source is invalid.');
@@ -441,6 +465,27 @@ function normalizedText(value) {
   return String(value ?? '').toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
 }
 
+function comparableRoleTokens(value) {
+  const normalized = normalizedText(value)
+    .replace(/\bsr\b/g, 'senior')
+    .replace(/\bjr\b/g, 'junior')
+    .replace(/\bfull stack\b/g, 'fullstack')
+    .replace(/\bfront end\b/g, 'frontend')
+    .replace(/\bback end\b/g, 'backend');
+  const ignored = new Set(['software', 'junior', 'mid', 'senior', 'staff', 'principal', 'lead', 'manager', 'director', 'founding']);
+  return new Set(normalized.split(' ')
+    .map((token) => token === 'developer' ? 'engineer' : token)
+    .filter((token) => token && !ignored.has(token)));
+}
+
+function rolesLikelySame(left, right) {
+  const leftTokens = comparableRoleTokens(left);
+  const rightTokens = comparableRoleTokens(right);
+  if (leftTokens.size === 0 || rightTokens.size === 0) return normalizedText(left) === normalizedText(right);
+  const shared = [...leftTokens].filter((token) => rightTokens.has(token)).length;
+  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)}`;
@@ -593,6 +638,91 @@ async function jsonLines(file) {
   }
 }
 
+async function sourceCatalog() {
+  return SOURCE_CATALOG;
+}
+
+async function sourcesList(filtersInput = {}, communitySources = []) {
+  const filters = object(filtersInput, 'source filters');
+  const allowed = new Set(['regions', 'roleFamilies', 'kinds', 'requiresSession']);
+  for (const key of Object.keys(filters)) if (!allowed.has(key)) throw new Error(`Unknown source filter: ${key}.`);
+  const regions = filters.regions == null ? [] : terms(stringArray(filters.regions, 'source filters.regions'));
+  const roleFamilies = filters.roleFamilies == null ? [] : terms(stringArray(filters.roleFamilies, 'source filters.roleFamilies'));
+  const kinds = filters.kinds == null ? [] : terms(stringArray(filters.kinds, 'source filters.kinds'));
+  if (filters.requiresSession != null && typeof filters.requiresSession !== 'boolean') throw new Error('source filters.requiresSession must be a Boolean.');
+  const community = communitySources.map((source) => ({
+    id: null,
+    communitySourceId: source.sourceId,
+    name: source.name,
+    kind: source.kind,
+    jobsUrl: source.baseUrl,
+    regions: source.regions,
+    roleFamilies: source.roleFamilies,
+    requiresSession: source.requiresSession,
+    access: 'community',
+    verification: 'direct-employer-or-ats',
+    registryStatus: source.registryStatus,
+    contributionCount: source.contributionCount,
+  }));
+  const sources = [...await sourceCatalog(), ...community].filter((source) => {
+    if (regions.length && !source.regions.some((value) => regions.includes(value))) return false;
+    if (roleFamilies.length && !source.roleFamilies.some((value) => roleFamilies.includes(value))) return false;
+    if (kinds.length && !kinds.includes(source.kind)) return false;
+    if (filters.requiresSession != null && source.requiresSession !== filters.requiresSession) return false;
+    return true;
+  });
+  return { version: 1, count: sources.length, sources };
+}
+
+function sourceSuggestion(input) {
+  const value = normalizeCommunitySource(input);
+  return {
+    type: 'suggested',
+    id: `source-suggestion-${randomUUID()}`,
+    ...value,
+    createdAt: new Date().toISOString(),
+  };
+}
+
+function shareableSuggestion(suggestion) {
+  return Object.fromEntries(['name', 'baseUrl', 'kind', 'regions', 'roleFamilies', 'requiresSession'].map((key) => [key, suggestion[key]]));
+}
+
+async function markSourceShared(suggestionId, contribution) {
+  if (!contribution.shared) return;
+  await appendPrivateEvent('source-contribution-receipts', { suggestionId, sourceId: contribution.sourceId, sharedAt: new Date().toISOString() });
+}
+
+async function sourcesSuggest(input, community) {
+  const suggestion = sourceSuggestion(input);
+  await appendPrivateEvent('source-suggestions', suggestion);
+  const contribution = await community.contribute(shareableSuggestion(suggestion));
+  await markSourceShared(suggestion.id, contribution);
+  return { queued: true, community: contribution, suggestion };
+}
+
+async function sourcesPending() {
+  const suggestions = await jsonLines(join(await ensureStateDir(), 'source-suggestions.ndjson'));
+  const receipts = await jsonLines(join(await ensureStateDir(), 'source-contribution-receipts.ndjson'));
+  const shared = new Set(receipts.map((receipt) => receipt.suggestionId));
+  const pending = suggestions.filter((suggestion) => !shared.has(suggestion.id));
+  return { scope: 'local-unsent', count: pending.length, suggestions: pending };
+}
+
+export async function sourcesSync(community, limit = 10) {
+  const pending = (await sourcesPending()).suggestions.slice(0, limit);
+  let shared = 0;
+  let attempted = 0;
+  for (const suggestion of pending) {
+    attempted += 1;
+    const contribution = await community.contribute(shareableSuggestion(suggestion));
+    await markSourceShared(suggestion.id, contribution);
+    if (contribution.shared) shared += 1;
+    else if (contribution.reason === 'disabled' || contribution.reason === 'unavailable') break;
+  }
+  return { attempted, shared, remaining: (await sourcesPending()).count };
+}
+
 async function withStateLock(name, action) {
   const dir = await ensureStateDir();
   const lockPath = join(dir, `.${name}.lock`);
@@ -736,63 +866,105 @@ async function canonicalResumePath() {
   return { path: target };
 }
 
-function duplicateResult(entries, candidate) {
+function duplicateResult(entries, candidate, outcomes = [], now = new Date()) {
   const candidateCompany = normalizedText(candidate.company);
   const candidateRole = normalizedText(candidate.role);
   const candidateUrl = normalizeUrl(candidate.url);
-  const sameCompanyRole = (entry) => candidateCompany && candidateRole && normalizedText(entry.company) === candidateCompany && normalizedText(entry.role) === candidateRole;
-  const hard = entries.find((entry) => entry.id === candidate.id
-    || (candidate.employerJobId && entry.employerJobId && normalizedText(entry.company) === candidateCompany && entry.employerJobId.toLowerCase() === String(candidate.employerJobId).toLowerCase())
-    || normalizeUrl(entry.url) === candidateUrl);
+  const sameCompanyRole = (entry) => candidateCompany && candidateRole
+    && normalizedText(entry.company) === candidateCompany
+    && rolesLikelySame(entry.role, candidate.role);
+  const hardId = entries.find((entry) => entry.id === candidate.id);
+  const hardEmployerJobId = entries.find((entry) => candidate.employerJobId && entry.employerJobId
+    && normalizedText(entry.company) === candidateCompany
+    && entry.employerJobId.toLowerCase() === String(candidate.employerJobId).toLowerCase());
+  const hardUrl = entries.find((entry) => normalizeUrl(entry.url) === candidateUrl);
+  const hard = hardId ?? hardEmployerJobId ?? hardUrl;
+  const hardReason = hardId ? 'id' : hardEmployerJobId ? 'employer-job-id' : hardUrl ? 'url' : null;
   const possible = hard ? null : entries.find(sameCompanyRole);
   const match = hard ?? possible;
-  const companyApplications = candidateCompany
-    ? entries.filter((entry) => normalizedText(entry.company) === candidateCompany).slice(-20).map((entry) => ({
+  const sameCompanyEntries = candidateCompany
+    ? entries.filter((entry) => normalizedText(entry.company) === candidateCompany)
+    : [];
+  const companyApplications = sameCompanyEntries.slice(-20).map((entry) => ({
       id: entry.id,
       company: entry.company,
       role: entry.role,
       submittedAt: entry.submittedAt,
       ...(entry.employerJobId ? { employerJobId: entry.employerJobId } : {}),
-    }))
-    : [];
+    }));
+  const latestCompanyApplication = [...sameCompanyEntries]
+    .filter((entry) => !Number.isNaN(Date.parse(entry.submittedAt)))
+    .sort((left, right) => Date.parse(right.submittedAt) - Date.parse(left.submittedAt))[0] ?? null;
+  const daysSinceLatest = latestCompanyApplication
+    ? Math.max(0, Math.floor((now.getTime() - Date.parse(latestCompanyApplication.submittedAt)) / 86_400_000))
+    : null;
+  const hasFollowUp = latestCompanyApplication
+    ? outcomes.some((outcome) => outcome.id === latestCompanyApplication.id)
+    : false;
+  let companyReapplyDecision = 'fresh-company';
+  if (hard) companyReapplyDecision = 'hard-duplicate';
+  else if (possible) companyReapplyDecision = 'same-role-review';
+  else if (latestCompanyApplication && hasFollowUp) companyReapplyDecision = 'follow-up-present';
+  else if (latestCompanyApplication && daysSinceLatest < COMPANY_REAPPLY_COOLDOWN_DAYS) companyReapplyDecision = 'cooldown-active';
+  else if (latestCompanyApplication) companyReapplyDecision = 'eligible-after-cooldown';
   return {
     duplicate: Boolean(hard),
     possibleDuplicate: Boolean(possible),
-    reason: hard ? (hard.id === candidate.id ? 'id' : candidate.employerJobId && hard.employerJobId ? 'employer-job-id' : 'url') : possible ? 'company-role' : null,
+    reason: hardReason ?? (possible ? 'company-role' : null),
     match: match ? { id: match.id, company: match.company, role: match.role, submittedAt: match.submittedAt } : null,
     sameCompany: companyApplications.length > 0,
     companyApplications,
+    companyReapply: {
+      eligible: companyReapplyDecision === 'eligible-after-cooldown',
+      decision: companyReapplyDecision,
+      cooldownDays: COMPANY_REAPPLY_COOLDOWN_DAYS,
+      latestSubmittedAt: latestCompanyApplication?.submittedAt ?? null,
+      daysSinceLatest,
+      hasFollowUp,
+    },
   };
 }
 
 async function ledgerCheck(candidate) {
   object(candidate, 'candidate');
-  const entries = await jsonLines(join(await ensureStateDir(), 'applications.ndjson'));
+  const dir = await ensureStateDir();
+  const entries = await jsonLines(join(dir, 'applications.ndjson'));
+  const outcomes = await jsonLines(join(dir, 'outcomes.ndjson'));
   string(candidate.url, 'candidate.url', 2048);
-  return duplicateResult(entries, candidate);
+  return duplicateResult(entries, candidate, outcomes);
 }
 
-async function ledgerAdd(entryInput, duplicateOverride) {
+async function ledgerAdd(entryInput, duplicateOverride, companyReapplyOverride) {
   const entry = validateLedgerEntry(entryInput);
   return withStateLock('applications', async (dir) => {
     const file = join(dir, 'applications.ndjson');
     const entries = await jsonLines(file);
+    const outcomes = await jsonLines(join(dir, 'outcomes.ndjson'));
     if (entry.roundId) {
       const roundEvents = await jsonLines(join(dir, 'rounds.ndjson'));
       if (!roundEvents.some((event) => event.type === 'started' && event.roundId === entry.roundId)) throw new Error('entry.roundId does not identify a started round.');
       if (roundEvents.some((event) => event.type === 'completed' && event.roundId === entry.roundId)) throw new Error('entry.roundId identifies a completed round.');
     }
-    const duplicate = duplicateResult(entries, entry);
-    if (duplicate.duplicate) throw new Error('This application is already recorded.');
+    const duplicate = duplicateResult(entries, entry, outcomes);
+    if (duplicate.duplicate) throw new Error(`Hard duplicate blocked: matching ${duplicate.reason === 'employer-job-id' ? 'employer job ID or requisition' : duplicate.reason === 'url' ? 'canonical URL' : 'ledger ID'}.`);
     if (duplicate.possibleDuplicate && duplicateOverride !== 'NEW REQUISITION CONFIRMED') throw new Error('A possible same-company role duplicate requires NEW REQUISITION CONFIRMED.');
-    await appendFile(file, `${JSON.stringify(entry)}\n`, { mode: 0o600 });
+    if (!duplicate.possibleDuplicate && duplicate.companyReapply.decision === 'cooldown-active' && companyReapplyOverride !== COMPANY_REAPPLY_OVERRIDE) {
+      throw new Error(`Company reapplication cooldown is active for ${COMPANY_REAPPLY_COOLDOWN_DAYS} full days; use ${COMPANY_REAPPLY_OVERRIDE} only with explicit candidate approval.`);
+    }
+    if (!duplicate.possibleDuplicate && duplicate.companyReapply.decision === 'follow-up-present' && companyReapplyOverride !== COMPANY_REAPPLY_OVERRIDE) {
+      throw new Error(`Company reapplication blocked because the latest application has a recorded follow-up; use ${COMPANY_REAPPLY_OVERRIDE} only with explicit candidate approval.`);
+    }
+    const storedEntry = ['cooldown-active', 'follow-up-present'].includes(duplicate.companyReapply.decision)
+      ? { ...entry, reapplicationApproval: 'candidate-explicit' }
+      : entry;
+    await appendFile(file, `${JSON.stringify(storedEntry)}\n`, { mode: 0o600 });
     await chmod(file, 0o600);
     if (entry.roundId) {
       const roundsFile = join(dir, 'rounds.ndjson');
       await appendFile(roundsFile, `${JSON.stringify({ type: 'submission-confirmed', roundId: entry.roundId, applicationId: entry.id, occurredAt: entry.submittedAt })}\n`, { mode: 0o600 });
       await chmod(roundsFile, 0o600);
     }
-    return { recorded: entry.id, review: buildReview([...entries, entry]) };
+    return { recorded: storedEntry.id, review: buildReview([...entries, storedEntry]) };
   });
 }
 
@@ -1070,7 +1242,7 @@ function roundCompletedTelemetry(round) {
   };
 }
 
-async function executeCommand([area, action, value], telemetry, session) {
+async function executeCommand([area, action, value], telemetry, session, community) {
   const domainEvents = [];
   let result;
   if (area === 'profile' && action === 'set' && value === '--stdin') {
@@ -1095,7 +1267,7 @@ async function executeCommand([area, action, value], telemetry, session) {
     const input = await jsonStdin();
     const telemetryDetails = validateSubmissionTelemetry(input.telemetry);
     const entry = validateLedgerEntry(input);
-    result = await ledgerAdd(entry, input.duplicateOverride);
+    result = await ledgerAdd(entry, input.duplicateOverride, input.companyReapplyOverride);
     domainEvents.push(await telemetryApplicationSubmitted(entry, telemetryDetails));
   } else if (area === 'ledger' && action === 'outcome' && value === '--stdin') {
     const outcome = await ledgerOutcome(await jsonStdin());
@@ -1116,12 +1288,24 @@ async function executeCommand([area, action, value], telemetry, session) {
   else if (area === 'round' && action === 'complete' && value === '--stdin') {
     result = await roundComplete(await jsonStdin());
     domainEvents.push(roundCompletedTelemetry(result));
-  } else if (area === 'attention' && action === 'add' && value === '--stdin') result = await attentionAdd(await jsonStdin());
+  } else if (area === 'sources' && action === 'list' && value == null) {
+    await sourcesSync(community);
+    result = await sourcesList({}, await community.list());
+  } else if (area === 'sources' && action === 'list' && value === '--stdin') {
+    const filters = await jsonStdin();
+    await sourcesSync(community);
+    result = await sourcesList(filters, await community.list());
+  }
+  else if (area === 'sources' && action === 'suggest' && value === '--stdin') result = await sourcesSuggest(await jsonStdin(), community);
+  else if (area === 'sources' && action === 'pending' && value == null) result = await sourcesPending();
+  else if (area === 'sources' && action === 'sync' && value == null) result = await sourcesSync(community);
+  else if (area === 'sources' && action === 'sharing' && ['status', 'enable', 'disable', 'reset'].includes(value)) result = await community.configure(value);
+  else if (area === 'attention' && action === 'add' && value === '--stdin') result = await attentionAdd(await jsonStdin());
   else if (area === 'attention' && action === 'list' && value == null) result = await attentionList();
   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: 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|complete --stdin|status [round-id]; attention add|resolve --stdin|list; friction record --stdin|list; telemetry status|enable|disable|reset|preview --stdin|record --stdin');
+  else throw new Error('Usage: 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|complete --stdin|status [round-id]; sources list [--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;
 }
@@ -1143,6 +1327,7 @@ async function recordInstallationStart(telemetry, session) {
 async function main(args) {
   const [area, action, value] = args;
   const telemetry = new TelemetryClient({ stateDir: stateDir() });
+  const community = new SourceCommunityClient({ stateDir: stateDir() });
   if (area === 'telemetry') {
     if (['status', 'enable', 'disable', 'reset'].includes(action) && value == null) return print(await telemetry.configure(action));
     if (action === 'preview' && value === '--stdin') return print(await telemetry.preview(await jsonStdin()));
@@ -1159,7 +1344,7 @@ async function main(args) {
   await recordInstallationStart(telemetry, session);
   const started = Date.now();
   try {
-    const result = await executeCommand(args, telemetry, session);
+    const result = await executeCommand(args, telemetry, session, community);
     await telemetry.record({ event: 'command_completed', properties: { command, result: 'success', durationBucket: durationBucket(Date.now() - started) } }, session);
     return print(result);
   } catch (error) {
@@ -1169,7 +1354,7 @@ async function main(args) {
   }
 }
 
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
   main(process.argv.slice(2)).catch((error) => {
     process.stderr.write(`Error: ${error.message}\n`);
     process.exitCode = 1;

package/job-application-agent/scripts/source-community-client.mjs

@@ -0,0 +1,254 @@
+import { chmod, mkdir, open, readFile, rename, stat, unlink, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+
+import { SKILL_VERSION } from './telemetry-client.mjs';
+import { createSourceContributionEnvelope, normalizeCommunitySource, validateCommunitySourceList } from './source-community-schema.mjs';
+
+export const DEFAULT_SOURCE_COMMUNITY_ENDPOINT = process.env.JOB_APPLICATION_AGENT_SOURCE_COMMUNITY_URL ?? process.env.JOB_APPLICATION_AGENT_TELEMETRY_URL ?? 'https://job-application-agent-telemetry.varora1406.workers.dev';
+export const SOURCE_SHARING_NOTICE = 'Community source sharing is enabled by default. Repeatable public job boards and hiring feeds are shared anonymously into a pending maintainer-review queue after removing personal and referral data. Run `sources sharing disable` to opt out.\n';
+
+const CONFIG_FILE = 'source-sharing.json';
+const CONFIG_LOCK_FILE = '.source-sharing.lock';
+const CONFIG_LOCK_TIMEOUT_MS = 15_000;
+const CONFIG_LOCK_STALE_MS = 60_000;
+
+function defaultConfig() {
+  return { version: 1, enabled: true, disclosed: false, installationId: null, token: null, tokenExpiresAt: null };
+}
+
+function sameCredentialState(left, right) {
+  return left.enabled === right.enabled
+    && left.installationId === right.installationId
+    && left.token === right.token
+    && left.tokenExpiresAt === right.tokenExpiresAt;
+}
+
+function processIsAlive(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+  if (pid === process.pid) return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (error.code === 'ESRCH') return false;
+    return true;
+  }
+}
+
+async function writePrivate(file, value) {
+  const temporary = `${file}.${process.pid}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+  await rename(temporary, file);
+  await chmod(file, 0o600);
+}
+
+export class SourceCommunityClient {
+  constructor({ stateDir, endpoint = DEFAULT_SOURCE_COMMUNITY_ENDPOINT, fetch: fetchFn = globalThis.fetch, stderr = (value) => process.stderr.write(value), now = () => new Date(), timeoutMs = Number(process.env.JOB_APPLICATION_AGENT_SOURCE_COMMUNITY_TIMEOUT_MS ?? 3000) }) {
+    this.stateDir = stateDir;
+    this.endpoint = endpoint.replace(/\/$/, '');
+    this.fetch = fetchFn;
+    this.stderr = stderr;
+    this.now = now;
+    this.timeoutMs = timeoutMs;
+  }
+
+  get configPath() { return join(this.stateDir, CONFIG_FILE); }
+  get configLockPath() { return join(this.stateDir, CONFIG_LOCK_FILE); }
+
+  async ensureDirectory() {
+    await mkdir(this.stateDir, { recursive: true, mode: 0o700 });
+    await chmod(this.stateDir, 0o700);
+  }
+
+  async readConfig() {
+    try {
+      const value = JSON.parse(await readFile(this.configPath, 'utf8'));
+      return { version: 1, enabled: value.enabled !== false, disclosed: value.disclosed === true, installationId: value.installationId ?? null, token: value.token ?? null, tokenExpiresAt: value.tokenExpiresAt ?? null };
+    } catch (error) {
+      if (error.code === 'ENOENT') return null;
+      return { version: 1, enabled: false, disclosed: true, installationId: null, token: null, tokenExpiresAt: null };
+    }
+  }
+
+  async saveConfigUnlocked(config) {
+    await this.ensureDirectory();
+    await writePrivate(this.configPath, config);
+  }
+
+  async removeStaleConfigLock() {
+    let contents;
+    let metadata;
+    try {
+      [contents, metadata] = await Promise.all([
+        readFile(this.configLockPath, 'utf8'),
+        stat(this.configLockPath),
+      ]);
+    } catch (error) {
+      if (error.code === 'ENOENT') return true;
+      throw error;
+    }
+    const trimmed = contents.trim();
+    const pid = /^\d+$/.test(trimmed) ? Number(trimmed) : null;
+    const ownerIsDead = pid !== null && !processIsAlive(pid);
+    const lockExpired = Date.now() - metadata.mtimeMs >= CONFIG_LOCK_STALE_MS;
+    if (!ownerIsDead && !lockExpired) return false;
+    try {
+      if (await readFile(this.configLockPath, 'utf8') !== contents) return false;
+      await unlink(this.configLockPath);
+      return true;
+    } catch (error) {
+      if (error.code === 'ENOENT') return true;
+      throw error;
+    }
+  }
+
+  async withConfigLock(operation) {
+    await this.ensureDirectory();
+    const startedAt = Date.now();
+    let handle;
+    while (!handle) {
+      try {
+        handle = await open(this.configLockPath, 'wx', 0o600);
+      } catch (error) {
+        if (error.code !== 'EEXIST') throw error;
+        if (await this.removeStaleConfigLock()) continue;
+        if (Date.now() - startedAt >= CONFIG_LOCK_TIMEOUT_MS) throw new Error('Could not acquire source-sharing config lock.');
+        await delay(20);
+      }
+    }
+    try {
+      await handle.writeFile(`${process.pid}\n`);
+    } catch (error) {
+      await handle.close();
+      await unlink(this.configLockPath).catch(() => {});
+      throw error;
+    }
+    try {
+      return await operation();
+    } finally {
+      await handle.close();
+      await unlink(this.configLockPath).catch((error) => { if (error.code !== 'ENOENT') throw error; });
+    }
+  }
+
+  async updateConfig(transform) {
+    return this.withConfigLock(async () => {
+      const current = await this.readConfig() ?? defaultConfig();
+      const next = transform(current);
+      await this.saveConfigUnlocked(next);
+      return next;
+    });
+  }
+
+  async config() {
+    return this.withConfigLock(async () => {
+      const existing = await this.readConfig();
+      if (existing) return existing;
+      const config = defaultConfig();
+      await this.saveConfigUnlocked(config);
+      return config;
+    });
+  }
+
+  async status() {
+    const config = await this.readConfig();
+    return { enabled: config?.enabled ?? true, disclosed: config?.disclosed ?? false, hasInstallationId: Boolean(config?.installationId), endpoint: this.endpoint, schemaVersion: 1 };
+  }
+
+  async configure(action) {
+    if (action === 'status') return this.status();
+    await this.updateConfig((config) => {
+      if (action === 'enable') config.enabled = true;
+      else if (action === 'disable') config.enabled = false;
+      else if (action === 'reset') Object.assign(config, { enabled: false, disclosed: true, installationId: null, token: null, tokenExpiresAt: null });
+      else throw new Error('Source sharing action must be status, enable, disable, or reset.');
+      config.disclosed = true;
+      return config;
+    });
+    return this.status();
+  }
+
+  async credentials(config) {
+    if (config.installationId && config.token && config.tokenExpiresAt && Date.parse(config.tokenExpiresAt) > this.now().getTime() + 60_000) return config;
+    let expectedState = config;
+    let body = config.installationId && config.token ? { installationId: config.installationId, token: config.token } : {};
+    let response = await this.fetch(`${this.endpoint}/v1/install`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body), signal: AbortSignal.timeout(this.timeoutMs) });
+    if (response.status === 401 && body.installationId) {
+      config = await this.updateConfig((current) => {
+        if (current.installationId === body.installationId) Object.assign(current, { installationId: null, token: null, tokenExpiresAt: null });
+        return current;
+      });
+      expectedState = config;
+      body = {};
+      response = await this.fetch(`${this.endpoint}/v1/install`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body), signal: AbortSignal.timeout(this.timeoutMs) });
+    }
+    if (!response.ok) throw new Error('community relay unavailable');
+    const identity = await response.json();
+    return this.updateConfig((current) => sameCredentialState(current, expectedState)
+      ? { ...current, installationId: identity.installationId, token: identity.token, tokenExpiresAt: identity.expiresAt }
+      : current);
+  }
+
+  async preview(input) {
+    return normalizeCommunitySource(input);
+  }
+
+  async contribute(input) {
+    const source = normalizeCommunitySource(input);
+    try {
+      let config = await this.config();
+      if (!config.enabled) return { shared: false, reason: 'disabled' };
+      if (!config.disclosed) {
+        this.stderr(SOURCE_SHARING_NOTICE);
+        config = await this.updateConfig((current) => ({ ...current, disclosed: true }));
+        if (!config.enabled) return { shared: false, reason: 'disabled' };
+      }
+      config = await this.credentials(config);
+      let sent = await this.sendContribution(config, source);
+      if (sent.disabled) return { shared: false, reason: 'disabled' };
+      let response = sent.response;
+      if (response.status === 401) {
+        config = await this.updateConfig((current) => ({ ...current, tokenExpiresAt: null }));
+        config = await this.credentials(config);
+        sent = await this.sendContribution(config, source);
+        if (sent.disabled) return { shared: false, reason: 'disabled' };
+        response = sent.response;
+      }
+      if (!response.ok) {
+        return { shared: false, reason: 'unavailable' };
+      }
+      const result = await response.json();
+      const allowed = new Set(['accepted', 'sourceId', 'publicationStatus', 'uniqueContributors']);
+      if (!result || typeof result !== 'object' || Array.isArray(result) || Object.keys(result).some((key) => !allowed.has(key))) return { shared: false, reason: 'unavailable' };
+      if (result.accepted !== true || !/^community-[0-9a-f]{16}$/.test(result.sourceId)) return { shared: false, reason: 'unavailable' };
+      if (!['pending', 'published', 'rejected'].includes(result.publicationStatus)) return { shared: false, reason: 'unavailable' };
+      if (!Number.isSafeInteger(result.uniqueContributors) || result.uniqueContributors < 1 || result.uniqueContributors > 1_000_000_000) return { shared: false, reason: 'unavailable' };
+      return { shared: true, sourceId: result.sourceId, publicationStatus: result.publicationStatus, uniqueContributors: result.uniqueContributors };
+    } catch {
+      return { shared: false, reason: 'unavailable' };
+    }
+  }
+
+  async sendContribution(config, source) {
+    return this.withConfigLock(async () => {
+      const current = await this.readConfig() ?? config;
+      if (!current.enabled) return { disabled: true };
+      const envelope = createSourceContributionEnvelope({ installationId: current.installationId, token: current.token, source, skillVersion: SKILL_VERSION });
+      const response = await this.fetch(`${this.endpoint}/v1/sources`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(envelope), signal: AbortSignal.timeout(this.timeoutMs) });
+      return { disabled: false, response };
+    });
+  }
+
+  async list() {
+    if (this.readUnavailable) return [];
+    try {
+      const response = await this.fetch(`${this.endpoint}/v1/sources`, { headers: { accept: 'application/json' }, signal: AbortSignal.timeout(this.timeoutMs) });
+      if (!response.ok) return [];
+      return validateCommunitySourceList(await response.json());
+    } catch {
+      this.readUnavailable = true;
+      return [];
+    }
+  }
+}