job-application-agent 3.1.1 → 3.2.0

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 { normalizeCommunityJob, normalizeCommunitySource } from './source-community-schema.mjs';
 import { TelemetryClient } from './telemetry-client.mjs';
 import { jobIdentity } from './telemetry-schema.mjs';
 
@@ -27,6 +31,13 @@ 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 COMMUNITY_SOURCE_ID = /^community-[0-9a-f]{16}$/;
 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 +89,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 +184,18 @@ 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 knownDiscoverySourceId(value, label) {
+  const id = sourceId(value, label);
+  if (!SOURCE_CATALOG_IDS.has(id) && !COMMUNITY_SOURCE_ID.test(id)) throw new Error(`${label} must match a packaged or community 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 +274,7 @@ 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) knownDiscoverySourceId(job.discoverySourceId, 'job.discoverySourceId');
   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 +432,9 @@ 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 = knownDiscoverySourceId(entry.discoverySourceId, 'entry.discoverySourceId');
+  }
   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 +469,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 +642,158 @@ async function jsonLines(file) {
   }
 }
 
+async function sourceCatalog() {
+  return SOURCE_CATALOG;
+}
+
+export 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: source.sourceId,
+    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 };
+}
+
+async function communityPendingStatus() {
+  return { ...await sourcesPending(), communityJobs: await communityJobsPending() };
+}
+
+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 };
+}
+
+function shareableLedgerJob(entry) {
+  return normalizeCommunityJob({
+    url: entry.url,
+    company: entry.company,
+    role: entry.role,
+    applicationChannel: entry.applicationChannel ?? entry.source,
+    ...(entry.discoverySource == null ? {} : { discoverySource: entry.discoverySource }),
+  });
+}
+
+async function markCommunityJobShared(applicationId, contribution) {
+  if (!contribution.shared) return;
+  await appendPrivateEvent('community-job-contribution-receipts', {
+    applicationId,
+    jobId: contribution.jobId,
+    sharedAt: new Date().toISOString(),
+  });
+}
+
+export async function communityJobsPending() {
+  const directory = await ensureStateDir();
+  const applications = await jsonLines(join(directory, 'applications.ndjson'));
+  const receipts = await jsonLines(join(directory, 'community-job-contribution-receipts.ndjson'));
+  const shared = new Set(receipts.map((receipt) => receipt.applicationId));
+  const pending = [];
+  let unshareable = 0;
+  for (const entry of applications) {
+    if (shared.has(entry.id)) continue;
+    try {
+      pending.push({ applicationId: entry.id, job: shareableLedgerJob(entry) });
+    } catch {
+      unshareable += 1;
+    }
+  }
+  return { count: pending.length, unshareable, applications: pending };
+}
+
+export async function communityJobsSync(community, { limit = 10, applicationIds = null } = {}) {
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100) throw new Error('Community job sync limit must be between 1 and 100.');
+  const selected = applicationIds == null ? null : new Set(applicationIds);
+  const state = await communityJobsPending();
+  const pending = state.applications.filter((entry) => selected == null || selected.has(entry.applicationId)).slice(0, limit);
+  let attempted = 0;
+  let shared = 0;
+  for (const entry of pending) {
+    attempted += 1;
+    const contribution = await community.contributeJob(entry.job);
+    await markCommunityJobShared(entry.applicationId, contribution);
+    if (contribution.shared) shared += 1;
+    else if (contribution.reason === 'disabled' || contribution.reason === 'unavailable' || contribution.reason === 'grace') break;
+  }
+  const remaining = await communityJobsPending();
+  return { attempted, shared, remaining: remaining.count, unshareable: remaining.unshareable };
+}
+
+async function syncAllCommunityData(community) {
+  const sources = await sourcesSync(community);
+  return {
+    ...sources,
+    communityJobs: await communityJobsSync(community),
+  };
+}
+
 async function withStateLock(name, action) {
   const dir = await ensureStateDir();
   const lockPath = join(dir, `.${name}.lock`);
@@ -736,63 +937,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 +1313,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 +1338,8 @@ 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);
+    result.communityJob = await communityJobsSync(community, { limit: 1, applicationIds: [entry.id] });
     domainEvents.push(await telemetryApplicationSubmitted(entry, telemetryDetails));
   } else if (area === 'ledger' && action === 'outcome' && value === '--stdin') {
     const outcome = await ledgerOutcome(await jsonStdin());
@@ -1116,12 +1360,29 @@ 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 syncAllCommunityData(community);
+    result = await sourcesList({}, await community.list());
+  } else if (area === 'sources' && action === 'list' && value === '--stdin') {
+    const filters = await jsonStdin();
+    await syncAllCommunityData(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 communityPendingStatus();
+  else if (area === 'sources' && action === 'sync' && value == null) result = await syncAllCommunityData(community);
+  else if (area === 'sources' && action === 'jobs' && value == null) result = await community.listJobs();
+  else if (area === 'sources' && action === 'jobs' && value === '--stdin') result = await community.listJobs(await jsonStdin());
+  else if (area === 'sources' && action === 'sharing' && ['status', 'enable', 'disable', 'reset'].includes(value)) {
+    result = await community.configure(value);
+    if (value === 'enable') result.communityJobs = await communityJobsSync(community);
+  }
+  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]|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;
 }
@@ -1143,6 +1404,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 +1421,8 @@ 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);
+    if (!(area === 'sources' || (area === 'ledger' && action === 'add'))) await communityJobsSync(community).catch(() => null);
     await telemetry.record({ event: 'command_completed', properties: { command, result: 'success', durationBucket: durationBucket(Date.now() - started) } }, session);
     return print(result);
   } catch (error) {
@@ -1169,7 +1432,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;