@agent-pattern-labs/leads-rig 0.1.3 → 0.1.5

package/lib/leadharness-crawler.mjs

@@ -1,7 +1,7 @@
 import { createHash } from 'crypto';
 import { lookup, resolveMx } from 'dns/promises';
 import { setTimeout as sleep } from 'timers/promises';
-import { cleanDomains, normalizeDomain } from './leadharness-leads.mjs';
+import { cleanDomains, dedupeLeadRecords, isRejectedLeadEmail, mergeLeadRecords, normalizeDomain } from './leadharness-leads.mjs';
 
 const DEFAULT_MAX_PAGES = 10;
 const HARD_MAX_PAGES = 25;
@@ -51,16 +51,14 @@ export async function crawlDomains(inputs, options = {}) {
       for (const lead of result.leads) {
         const key = leadKey(lead);
         const current = leadsByKey.get(key);
-        if (!current || isBetterLead(lead, current)) {
-          leadsByKey.set(key, lead);
-        }
+        leadsByKey.set(key, current ? mergeLeadRecords(current, lead) : lead);
       }
     } catch (error) {
       errors.push(`${target.domain}: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
 
-  const leads = [...leadsByKey.values()].sort(sortLead);
+  const leads = dedupeLeadRecords([...leadsByKey.values()]).sort(sortLead);
   const domains = cleanDomains([
     ...targets.map((target) => target.domain),
     ...results.map((result) => result.domain),
@@ -173,9 +171,7 @@ async function crawlDomainTarget(target, options) {
       if (!isRelevantLead(lead, { minConfidence, includeBlocked: options.includeBlocked })) continue;
       const key = leadKey(lead);
       const current = leadsByKey.get(key);
-      if (!current || isBetterLead(lead, current)) {
-        leadsByKey.set(key, lead);
-      }
+      leadsByKey.set(key, current ? mergeLeadRecords(current, lead) : lead);
     }
 
     if (page.hasForm && isContactLikeURL(page.url)) {
@@ -183,9 +179,7 @@ async function crawlDomainTarget(target, options) {
       if (isRelevantLead(lead, { minConfidence, includeBlocked: options.includeBlocked })) {
         const key = leadKey(lead);
         const current = leadsByKey.get(key);
-        if (!current || isBetterLead(lead, current)) {
-          leadsByKey.set(key, lead);
-        }
+        leadsByKey.set(key, current ? mergeLeadRecords(current, lead) : lead);
       }
     }
 
@@ -199,7 +193,7 @@ async function crawlDomainTarget(target, options) {
     await sleep(boundedInteger(options.delayMs, DEFAULT_DELAY_MS, 0, 10_000));
   }
 
-  const leads = [...leadsByKey.values()].sort(sortLead);
+  const leads = dedupeLeadRecords([...leadsByKey.values()]).sort(sortLead);
   const completedAt = new Date().toISOString();
   if (pages.length === 0) {
     warnings.push(`no pages could be crawled for ${target.domain}`);
@@ -372,7 +366,7 @@ function extractEmails(html) {
   for (const value of values) {
     for (const found of String(value || '').matchAll(EMAIL_RE)) {
       const email = found[0].toLowerCase().replace(/^mailto:/, '').replace(/[.,;:!?()[\]{}<>"']+$/g, '');
-      if (email && !isLikelyAssetEmail(email)) emails.add(email);
+      if (email && !isLikelyAssetEmail(email) && !isRejectedLeadEmail(email)) emails.add(email);
     }
   }
   return [...emails].sort();
@@ -502,6 +496,11 @@ async function buildEmailLead(email, companyDomain, websiteUrl, page) {
     emailType,
     sourceUrl,
     sourceLabel: sourceLabel(sourceUrl),
+    sources: [{
+      url: sourceUrl,
+      label: sourceLabel(sourceUrl),
+      evidence: snippet,
+    }],
     evidence: snippet,
     extractionMethod: 'agentic_harness_public_page',
     verificationStatus: emailType === 'blocked' ? 'blocked' : verificationStatus,
@@ -533,6 +532,11 @@ function buildContactPath(domain, websiteUrl, page) {
     emailType: 'contact_path',
     sourceUrl,
     sourceLabel: sourceLabel(sourceUrl),
+    sources: [{
+      url: sourceUrl,
+      label: sourceLabel(sourceUrl),
+      evidence: contactPathEvidence(page),
+    }],
     evidence: contactPathEvidence(page),
     extractionMethod: 'agentic_harness_contact_form',
     verificationStatus: 'not_applicable',

package/lib/leadharness-ingest.mjs

@@ -14,10 +14,18 @@ export function resolveIngestConfig(opts = {}, profile = loadProfileConfig()) {
   const configuredOperatorEmail = opts.operatorEmail || env.PUBLIC_LEADS_OPERATOR_EMAIL || env.LEAD_HARNESS_OPERATOR_EMAIL || profile.operatorEmail;
   const adminEmails = splitList(env.ADMIN_EMAILS);
   const operatorEmail = configuredOperatorEmail || legacyOperatorEmail || adminEmails[0] || '';
-  const tokenEnv = opts.tokenEnv || profile.authTokenEnv || profile.adminTokenEnv || 'ADMIN_API_TOKEN';
+  const tokenEnv = opts.tokenEnv
+    || profile.authTokenEnv
+    || profile.adminTokenEnv
+    || (env.PUBLIC_LEADS_API_TOKEN ? 'PUBLIC_LEADS_API_TOKEN' : '')
+    || (env.LEAD_HARNESS_API_TOKEN ? 'LEAD_HARNESS_API_TOKEN' : '')
+    || 'PUBLIC_LEADS_API_TOKEN';
+  const baseUrl = opts.api || env.PUBLIC_LEADS_API || env.LEAD_HARNESS_API || profile.baseUrl || '';
 
   return {
-    endpoint: `${stripTrailingSlash(opts.api || env.PUBLIC_LEADS_API || env.LEAD_HARNESS_API || profile.baseUrl || 'http://localhost:8080')}${normalizeEndpointPath(opts.ingestPath || env.PUBLIC_LEADS_INGEST_PATH || env.LEAD_HARNESS_INGEST_PATH || profile.ingestPath || '/api/lead-ingests')}`,
+    endpoint: baseUrl
+      ? `${stripTrailingSlash(baseUrl)}${normalizeEndpointPath(opts.ingestPath || env.PUBLIC_LEADS_INGEST_PATH || env.LEAD_HARNESS_INGEST_PATH || profile.ingestPath || '/api/lead-ingests')}`
+      : '',
     operatorEmail,
     operatorEmailHeader: opts.operatorEmailHeader
       || opts.adminEmailHeader
@@ -25,8 +33,7 @@ export function resolveIngestConfig(opts = {}, profile = loadProfileConfig()) {
       || env.LEAD_HARNESS_OPERATOR_EMAIL_HEADER
       || profile.operatorEmailHeader
       || profile.adminEmailHeader
-      || (legacyOperatorEmail || adminEmails.length > 0 ? 'X-Admin-Email' : '')
-      || (operatorEmail ? 'X-Operator-Email' : ''),
+      || 'X-Admin-Email',
     authHeader: opts.authHeader || env.PUBLIC_LEADS_AUTH_HEADER || env.LEAD_HARNESS_AUTH_HEADER || profile.authHeader || 'Authorization',
     authScheme: opts.authScheme || env.PUBLIC_LEADS_AUTH_SCHEME || env.LEAD_HARNESS_AUTH_SCHEME || profile.authScheme || 'Bearer',
     tokenEnv,
@@ -56,6 +63,10 @@ export async function ingestPayload(payload, opts = {}) {
     errors: payload.errors,
   };
 
+  if (!config.endpoint) {
+    throw new Error('ingest API base URL is required (--api, $PUBLIC_LEADS_API, $LEAD_HARNESS_API, or api.base_url)');
+  }
+
   if (opts.dryRun) {
     const output = {
       status: 'DRY RUN',
@@ -69,10 +80,16 @@ export async function ingestPayload(payload, opts = {}) {
   }
 
   if (config.operatorEmailHeader && !config.operatorEmail) {
-    throw new Error('operator email is required when an operator email header is configured');
+    throw new Error('operator email is required when an operator email header is configured (--operator-email, $PUBLIC_LEADS_OPERATOR_EMAIL, or api.operator_email)');
   }
   if (!config.token) {
-    throw new Error(`API token is required (--token or $${config.tokenEnv})`);
+    const tokenHints = [...new Set([
+      `$${config.tokenEnv}`,
+      '$PUBLIC_LEADS_API_TOKEN',
+      '$LEAD_HARNESS_API_TOKEN',
+      '$ADMIN_API_TOKEN',
+    ])];
+    throw new Error(`API token is required (--token, ${tokenHints.slice(0, -1).join(', ')}, or ${tokenHints.at(-1)})`);
   }
 
   const headers = {

package/lib/leadharness-leads.mjs

@@ -28,6 +28,37 @@ export const ALLOWED_VERIFICATION_STATUSES = new Set([
   'blocked',
   'unknown',
 ]);
+export const REJECTED_EMAIL_LOCAL_PREFIXES = [
+  'admin',
+  'booking',
+  'bookings',
+  'business',
+  'contact',
+  'customerservice',
+  'customer-service',
+  'customersuccess',
+  'customer-success',
+  'events',
+  'hello',
+  'help',
+  'hi',
+  'info',
+  'inquiries',
+  'enquiries',
+  'media',
+  'office',
+  'outreach',
+  'partners',
+  'partnerships',
+  'press',
+  'sales',
+  'service',
+  'services',
+  'speaking',
+  'success',
+  'support',
+  'team',
+];
 
 const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
 
@@ -94,7 +125,7 @@ export function normalizePayload(value, { now = new Date().toISOString(), source
     throw new Error('lead artifact must be a JSON array, JSONL records, or an object with a leads array');
   }
 
-  const leads = payload.leads.map((lead) => normalizeLead(lead, { now }));
+  const leads = dedupeLeadRecords(payload.leads.map((lead) => normalizeLead(lead, { now })));
   const results = Array.isArray(payload.results)
     ? payload.results.map((result) => normalizeResult(result, { now }))
     : [];
@@ -146,6 +177,11 @@ export function normalizeLead(input, { now = new Date().toISOString() } = {}) {
     emailType,
     sourceUrl,
     sourceLabel: stringValue(input.sourceLabel) || sourceUrl,
+    sources: normalizeLeadSources(input.sources, {
+      sourceUrl,
+      sourceLabel: stringValue(input.sourceLabel) || sourceUrl,
+      evidence: compactWhitespace(stringValue(input.evidence)),
+    }),
     evidence: compactWhitespace(stringValue(input.evidence)),
     extractionMethod: stringValue(input.extractionMethod) || 'agentic_harness',
     verificationStatus,
@@ -158,7 +194,7 @@ export function normalizeLead(input, { now = new Date().toISOString() } = {}) {
   };
 
   if (!lead.id) lead.id = stableLeadID(lead);
-  return lead;
+  return normalizeLeadRecord(lead);
 }
 
 export function normalizeResult(input, { now = new Date().toISOString() } = {}) {
@@ -169,7 +205,9 @@ export function normalizeResult(input, { now = new Date().toISOString() } = {})
   return {
     domain,
     websiteUrl: stringValue(input.websiteUrl) || (domain ? `https://${domain}/` : ''),
-    leads: Array.isArray(input.leads) ? input.leads.map((lead) => normalizeLead(lead, { now })) : [],
+    leads: Array.isArray(input.leads)
+      ? dedupeLeadRecords(input.leads.map((lead) => normalizeLead(lead, { now })))
+      : [],
     pages: Array.isArray(input.pages) ? input.pages.map(normalizePageVisit) : [],
     warnings: normalizeWarnings(input.warnings),
     completedAt: normalizeDateTime(input.completedAt, now),
@@ -225,6 +263,9 @@ export function validatePayload(payload, { allowEmpty = false } = {}) {
 
   results.forEach((result, index) => {
     validateResult(result, `results[${index}]`, issues);
+    result.leads.forEach((lead, leadIndex) => {
+      validateLead(lead, `results[${index}].leads[${leadIndex}]`, issues);
+    });
   });
 
   const errors = issues.filter((item) => item.severity === 'error').length;
@@ -252,6 +293,9 @@ export function validateLead(lead, path, issues) {
   if (lead.email && !EMAIL_RE.test(lead.email)) {
     issues.push(issue('error', `${path}.email`, 'invalid_email', 'email must be a valid email address when present'));
   }
+  if (lead.email && isRejectedLeadEmail(lead.email)) {
+    issues.push(issue('error', `${path}.email`, 'generic_inbox_rejected', 'generic company inboxes such as info@, hello@, or support@ are not accepted; submit named people instead'));
+  }
   if (lead.emailType && !ALLOWED_EMAIL_TYPES.has(lead.emailType)) {
     issues.push(issue('error', `${path}.emailType`, 'invalid_email_type', `emailType must be one of ${[...ALLOWED_EMAIL_TYPES].join(', ')}`));
   }
@@ -299,6 +343,19 @@ export function validateLead(lead, path, issues) {
   if (!Array.isArray(lead.warnings)) {
     issues.push(issue('error', `${path}.warnings`, 'invalid_warnings', 'warnings must be an array'));
   }
+  if (!Array.isArray(lead.sources)) {
+    issues.push(issue('error', `${path}.sources`, 'invalid_sources', 'sources must be an array'));
+  } else {
+    lead.sources.forEach((source, index) => {
+      if (!source || typeof source !== 'object' || Array.isArray(source)) {
+        issues.push(issue('error', `${path}.sources[${index}]`, 'invalid_source', 'sources entries must be objects'));
+        return;
+      }
+      if (!isHttpUrl(source.url)) {
+        issues.push(issue('error', `${path}.sources[${index}].url`, 'invalid_source_url', 'sources entries require an http(s) URL'));
+      }
+    });
+  }
   if (lead.foundAt && Number.isNaN(Date.parse(lead.foundAt))) {
     issues.push(issue('error', `${path}.foundAt`, 'invalid_found_at', 'foundAt must be ISO datetime'));
   }
@@ -447,6 +504,127 @@ export function domainFromUrl(value) {
   }
 }
 
+export function dedupeLeadRecords(leads) {
+  const byKey = new Map();
+  for (const rawLead of leads || []) {
+    const lead = normalizeLeadRecord(rawLead);
+    const key = stableLeadKey(lead);
+    const current = byKey.get(key);
+    byKey.set(key, current ? mergeLeadRecords(current, lead) : lead);
+  }
+  return [...byKey.values()];
+}
+
+function normalizeLeadRecord(lead) {
+  const sources = normalizeLeadSources(lead?.sources, {
+    sourceUrl: lead?.sourceUrl,
+    sourceLabel: lead?.sourceLabel,
+    evidence: lead?.evidence,
+  });
+  const normalized = {
+    ...lead,
+    sourceUrl: sources[0]?.url || stringValue(lead?.sourceUrl),
+    sourceLabel: sources[0]?.label || stringValue(lead?.sourceLabel),
+    sources,
+    evidence: sources[0]?.evidence || compactWhitespace(lead?.evidence),
+    warnings: normalizeWarnings(lead?.warnings),
+    socialUrls: normalizeUrlList(lead?.socialUrls),
+    contactUrls: normalizeUrlList(lead?.contactUrls),
+  };
+  normalized.id = stableLeadID(normalized);
+  return normalized;
+}
+
+export function mergeLeadRecords(current, candidate) {
+  const left = normalizeLeadRecord(current);
+  const right = normalizeLeadRecord(candidate);
+  const primary = leadQualityScore(right) > leadQualityScore(left) ? right : left;
+  const secondary = primary === right ? left : right;
+
+  const merged = {
+    ...primary,
+    company: primary.company || secondary.company,
+    domain: primary.domain || secondary.domain,
+    websiteUrl: primary.websiteUrl || secondary.websiteUrl,
+    contactName: primary.contactName || secondary.contactName,
+    title: primary.title || secondary.title,
+    email: primary.email || secondary.email,
+    emailType: primary.emailType || secondary.emailType,
+    extractionMethod: primary.extractionMethod || secondary.extractionMethod,
+    verificationStatus: verificationRank(secondary.verificationStatus) > verificationRank(primary.verificationStatus)
+      ? secondary.verificationStatus
+      : primary.verificationStatus,
+    confidence: Math.max(primary.confidence || 0, secondary.confidence || 0),
+    phone: primary.phone || secondary.phone,
+    socialUrls: normalizeUrlList([...(primary.socialUrls || []), ...(secondary.socialUrls || [])]),
+    contactUrls: normalizeUrlList([...(primary.contactUrls || []), ...(secondary.contactUrls || [])]),
+    warnings: normalizeWarnings([...(primary.warnings || []), ...(secondary.warnings || [])]),
+  };
+
+  merged.foundAt = earliestDateTime(primary.foundAt, secondary.foundAt);
+  if ((secondary.evidence || '').length > (merged.evidence || '').length) {
+    merged.evidence = secondary.evidence;
+  }
+
+  merged.sources = mergeLeadSources(merged.sourceUrl, left.sources, right.sources);
+  merged.sourceUrl = merged.sources[0]?.url || merged.sourceUrl;
+  merged.sourceLabel = merged.sources[0]?.label || merged.sourceLabel;
+  if (!merged.evidence) {
+    merged.evidence = merged.sources[0]?.evidence || '';
+  }
+  merged.id = stableLeadID(merged);
+  return normalizeLeadRecord(merged);
+}
+
+function normalizeLeadSources(value, fallback = {}) {
+  const byUrl = new Map();
+  const ordered = [];
+  const addSource = (source) => {
+    const url = stringValue(source?.url);
+    if (!url) return;
+
+    const entry = {
+      url,
+      label: stringValue(source?.label) || defaultSourceLabel(url),
+      evidence: compactWhitespace(source?.evidence),
+    };
+    const current = byUrl.get(url);
+    if (!current) {
+      byUrl.set(url, entry);
+      ordered.push(url);
+      return;
+    }
+    byUrl.set(url, {
+      url,
+      label: current.label || entry.label,
+      evidence: entry.evidence.length > current.evidence.length ? entry.evidence : current.evidence,
+    });
+  };
+
+  if (Array.isArray(value)) {
+    value.forEach(addSource);
+  }
+  addSource({
+    url: fallback.sourceUrl,
+    label: fallback.sourceLabel,
+    evidence: fallback.evidence,
+  });
+
+  const preferredUrl = stringValue(fallback.sourceUrl);
+  return ordered
+    .map((url) => byUrl.get(url))
+    .sort((left, right) => sourceSortValue(right, preferredUrl) - sourceSortValue(left, preferredUrl) || left.label.localeCompare(right.label) || left.url.localeCompare(right.url));
+}
+
+function mergeLeadSources(preferredUrl, ...lists) {
+  return normalizeLeadSources(lists.flat(), { sourceUrl: preferredUrl });
+}
+
+function sourceSortValue(source, preferredUrl) {
+  if (preferredUrl && source.url === preferredUrl) return 10_000;
+  return pagePriority(source.url || '') * 100 + Math.min((source.evidence || '').length, 99);
+}
+
 export function stableLeadID(lead) {
   const key = stableLeadKey(lead);
   if (!key.replace(/\|/g, '').trim()) return `agentic-${Date.now()}`;
@@ -469,10 +647,105 @@ function stableLeadKey(lead) {
   ].join('|').toLowerCase();
 }
 
+function leadQualityScore(lead) {
+  return (lead?.confidence || 0) * 1000
+    + verificationRank(lead?.verificationStatus) * 100
+    + pagePriority(lead?.sourceUrl || '') * 10
+    + (Array.isArray(lead?.sources) ? lead.sources.length : 0) * 5
+    + (lead?.phone ? 25 : 0)
+    + (Array.isArray(lead?.socialUrls) ? lead.socialUrls.length : 0) * 5
+    + (Array.isArray(lead?.contactUrls) ? lead.contactUrls.length : 0) * 5
+    + (lead?.contactName ? 20 : 0)
+    + (lead?.title ? 10 : 0);
+}
+
+function verificationRank(value) {
+  const status = stringValue(value).toLowerCase();
+  if (status === 'verified' || status === 'mx_verified') return 4;
+  if (status === 'unverified') return 3;
+  if (status === 'not_applicable') return 2;
+  if (status === 'unknown') return 1;
+  return 0;
+}
+
+function earliestDateTime(...values) {
+  const dates = values
+    .map((value) => stringValue(value))
+    .filter(Boolean)
+    .map((value) => new Date(value))
+    .filter((value) => !Number.isNaN(value.getTime()))
+    .sort((left, right) => left.getTime() - right.getTime());
+  return dates[0]?.toISOString() || new Date().toISOString();
+}
+
+function defaultSourceLabel(sourceUrl) {
+  const path = safePath(sourceUrl).replace(/^\/+|\/+$/g, '');
+  if (!path) return 'Home';
+  const last = path.split('/').filter(Boolean).pop() || path;
+  return last.replace(/[-_]+/g, ' ').replace(/\b\w/g, (char) => char.toUpperCase());
+}
+
+function safePath(value) {
+  try {
+    return new URL(value).pathname.toLowerCase();
+  } catch {
+    return '';
+  }
+}
+
+function pagePriority(link) {
+  const path = safePath(link);
+  const weighted = [
+    ['contact', 100],
+    ['about', 90],
+    ['team', 85],
+    ['people', 85],
+    ['leadership', 85],
+    ['staff', 80],
+    ['founder', 80],
+    ['press', 65],
+    ['media', 65],
+    ['blog', 55],
+    ['author', 55],
+    ['career', 45],
+    ['privacy', 25],
+    ['legal', 20],
+    ['impressum', 20],
+  ];
+  for (const [needle, score] of weighted) {
+    if (path.includes(needle)) return score;
+  }
+  return path === '/' ? 50 : 0;
+}
+
 export function fileHash(path) {
   return createHash('sha256').update(readFileSync(path)).digest('hex');
 }
 
+export function isRejectedLeadEmail(email) {
+  const local = String(email || '').trim().toLowerCase().split('@')[0] || '';
+  return isRejectedLeadLocalPart(local);
+}
+
+export function isRejectedLeadLocalPart(local) {
+  const value = normalizeRejectedLeadLocalPart(local);
+  if (!value) return false;
+  return REJECTED_EMAIL_LOCAL_PREFIXES.some((prefix) => {
+    if (value === prefix) return true;
+    if (!value.startsWith(prefix) || value.length === prefix.length) return false;
+    const next = value[prefix.length];
+    return next === '.' || next === '_' || next === '-' || next === '+' || /\d/.test(next);
+  });
+}
+
+function normalizeRejectedLeadLocalPart(local) {
+  let value = String(local || '').trim().toLowerCase();
+  for (const noise of ['mailto', 'u003e', 'email']) {
+    if (value.startsWith(noise)) value = value.slice(noise.length);
+  }
+  return value.replace(/^[>._+-]+/, '');
+}
+
 export function issue(severity, path, code, message) {
   return { severity, path, code, message };
 }
@@ -507,7 +780,7 @@ function normalizeVerificationStatus(value, emailType) {
 
 function normalizeWarnings(value) {
   if (!Array.isArray(value)) return [];
-  return value.map((item) => stringValue(item)).filter(Boolean);
+  return [...new Set(value.map((item) => stringValue(item)).filter(Boolean))];
 }
 
 function normalizeUrlList(value) {

package/modes/_shared.md

@@ -28,13 +28,14 @@ Required fields:
 - Prioritize home, contact, about, team, leadership, people, press, blog, careers, and legal pages.
 - Respect robots.txt, paywalls, login walls, and obvious anti-scraping notices.
 - Do not infer email formats. Do not brute-force guessed addresses.
+- Prefer named people over organizational inboxes. Do not emit generic catch-all emails such as `info@`, `hello@`, `contact@`, `support@`, `team@`, or similar aliases. If only a general contact path exists, emit `contact_path` instead.
 - Keep contact forms as `emailType: "contact_path"` with empty `email`.
 - Mark operational no-contact inboxes such as `noreply`, `abuse`, `security`, and `legal` as `blocked` with confidence `0`.
 
 ## Quality Heuristics
 
 - `person`: named person or person-like email with source context.
-- `role`: public role inbox such as `sales@`, `partnerships@`, or `press@`.
+- `role`: public role inbox only when it is clearly role-specific and not a generic catch-all alias.
 - `contact_path`: public form or page where no email is available.
 - `blocked`: public address that should not be used for outbound.
 
@@ -45,6 +46,7 @@ Confidence should reflect source quality, person specificity, domain match, and
 ```bash
 npx public-leads validate --input data/lead-results.json
 npx public-leads manifest --input data/lead-results.json
-npx public-leads ingest --input data/lead-results.json --dry-run
+PUBLIC_LEADS_API=https://cold-agent-leads.example.com npx public-leads ingest --input data/lead-results.json --dry-run
+npx public-leads pipeline --input data/domains.tsv --ingest
 npx public-leads verify
 ```

package/modes/batch.md

@@ -10,7 +10,7 @@ Prefer:
 batch/batch-runner.sh --parallel 2
 ```
 
-The runner delegates to `scripts/batch-orchestrator.mjs`, which uses `@razroo/iso-orchestrator` for durable workflow records in `.public-leads-runs/`, bounded fan-out, and state updates.
+The runner delegates to `scripts/batch-orchestrator.mjs`, which uses `@agent-pattern-labs/iso-orchestrator` for durable workflow records in `.public-leads-runs/`, bounded fan-out, and state updates.
 
 ## Input
 

package/modes/ingest.md

@@ -12,20 +12,23 @@ Use this when the user asks to store validated leads in a configured ingest API.
    ```bash
    npx public-leads manifest --input <artifact>
    ```
-3. Confirm ingest credentials and request settings are available through `config/profile.yml` and the configured environment variable. Do not print token values.
+3. Confirm upstream ingest settings are available through environment variables, flags, or `config/profile.yml`. Do not print token values.
+   - `PUBLIC_LEADS_API`
+   - `PUBLIC_LEADS_API_TOKEN`
+   - `PUBLIC_LEADS_OPERATOR_EMAIL`
 
 ## Dry Run
 
 Use dry-run before live ingest unless the user explicitly requested live submission:
 
 ```bash
-npx public-leads ingest --input <artifact> --dry-run --out data/ingest-response.json
+PUBLIC_LEADS_API=https://cold-agent-leads.example.com npx public-leads ingest --input <artifact> --dry-run --out data/ingest-response.json
 ```
 
 ## Live Ingest
 
 ```bash
-npx public-leads ingest --input <artifact> --target-project /path/to/cold-agent-leads --out data/ingest-response.json
+npx public-leads ingest --input <artifact> --out data/ingest-response.json
 ```
 
 ## Output

package/modes/pipeline.md

@@ -20,7 +20,7 @@ Read domains from the first available source:
 5. For browser-heavy batch work, use `batch/batch-runner.sh --parallel 2`.
 6. Validate every artifact with `npx public-leads validate`.
 7. Merge validated artifacts into a manifest with `npx public-leads manifest --input <artifact>`.
-8. Ingest with `npx public-leads pipeline --ingest --target-project /path/to/cold-agent-leads` only when upload is requested.
+8. Ingest with `npx public-leads pipeline --ingest` only when upload is requested and upstream API env vars are configured.
 
 ## Output
 

package/modes/setup.md

@@ -9,7 +9,7 @@ Use this when the user asks to configure or inspect the lead harness.
    - `data/domains.tsv`
    - `data/pipeline.md`
    - direct domains in the user request
-3. Confirm the ingest API settings:
+3. Confirm the upstream ingest API settings:
    - `api.base_url`
    - `api.ingest_path`
    - `api.operator_email`
@@ -17,7 +17,8 @@ Use this when the user asks to configure or inspect the lead harness.
    - `api.auth_header`
    - `api.auth_scheme`
    - `api.auth_token_env`
-   - `api.target_project` when using a local Cold Agent Leads checkout for `.env` credentials
+   - or `PUBLIC_LEADS_API`, `PUBLIC_LEADS_API_TOKEN`, and `PUBLIC_LEADS_OPERATOR_EMAIL`
+   - `api.target_project` only when intentionally reading credentials from a local Cold Agent Leads checkout
 4. Run `npx public-leads verify`.
 
 ## Output

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-pattern-labs/leads-rig",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Agentic public-web lead discovery harness with portable ingest artifacts",
   "type": "module",
   "author": "Razroo",
@@ -155,32 +155,32 @@
     "fast-uri": "3.1.2"
   },
   "dependencies": {
-    "@razroo/iso-cache": "^0.1.0",
-    "@razroo/iso-canon": "^0.1.0",
-    "@razroo/iso-capabilities": "^0.1.0",
-    "@razroo/iso-context": "^0.1.0",
-    "@razroo/iso-contract": "^0.1.0",
-    "@razroo/iso-facts": "^0.1.0",
-    "@razroo/iso-guard": "^0.1.0",
-    "@razroo/iso-index": "^0.1.0",
-    "@razroo/iso-ledger": "^0.1.0",
-    "@razroo/iso-lineage": "^0.1.0",
-    "@razroo/iso-migrate": "^0.1.0",
-    "@razroo/iso-orchestrator": "^0.2.0",
-    "@razroo/iso-postflight": "^0.1.0",
-    "@razroo/iso-preflight": "^0.1.0",
-    "@razroo/iso-prioritize": "^0.1.0",
-    "@razroo/iso-redact": "^0.1.0",
-    "@razroo/iso-score": "^0.1.0",
-    "@razroo/iso-timeline": "^0.1.0",
-    "@razroo/iso-trace": "^0.5.0",
+    "@agent-pattern-labs/iso-cache": "^0.1.1",
+    "@agent-pattern-labs/iso-canon": "^0.1.1",
+    "@agent-pattern-labs/iso-capabilities": "^0.1.1",
+    "@agent-pattern-labs/iso-context": "^0.1.1",
+    "@agent-pattern-labs/iso-contract": "^0.1.1",
+    "@agent-pattern-labs/iso-facts": "^0.1.1",
+    "@agent-pattern-labs/iso-guard": "^0.1.1",
+    "@agent-pattern-labs/iso-index": "^0.1.1",
+    "@agent-pattern-labs/iso-ledger": "^0.1.1",
+    "@agent-pattern-labs/iso-lineage": "^0.1.1",
+    "@agent-pattern-labs/iso-migrate": "^0.1.1",
+    "@agent-pattern-labs/iso-orchestrator": "^0.2.1",
+    "@agent-pattern-labs/iso-postflight": "^0.1.1",
+    "@agent-pattern-labs/iso-preflight": "^0.1.1",
+    "@agent-pattern-labs/iso-prioritize": "^0.1.1",
+    "@agent-pattern-labs/iso-redact": "^0.1.1",
+    "@agent-pattern-labs/iso-score": "^0.1.1",
+    "@agent-pattern-labs/iso-timeline": "^0.1.1",
+    "@agent-pattern-labs/iso-trace": "^0.5.1",
     "playwright": "^1.58.1"
   },
   "devDependencies": {
-    "@razroo/agentmd": "^0.3.0",
-    "@razroo/iso": "^0.3.1",
-    "@razroo/iso-eval": "^0.4.0",
-    "@razroo/iso-harness": "^0.8.0",
-    "@razroo/iso-route": "^0.5.3"
+    "@agent-pattern-labs/agentmd": "^0.3.1",
+    "@agent-pattern-labs/iso": "^0.3.2",
+    "@agent-pattern-labs/iso-eval": "^0.4.1",
+    "@agent-pattern-labs/iso-harness": "^0.8.1",
+    "@agent-pattern-labs/iso-route": "^0.6.1"
   }
 }