diff --git a/apps/api/src/app.ts b/apps/api/src/app.ts
index 5a15866..23f34ca 100644
--- a/apps/api/src/app.ts
+++ b/apps/api/src/app.ts
@@ -38,12 +38,15 @@ import {
 } from './auth';
 import { evaluatePolicy, isExecutable, POLICY_VERSION } from '@outreachgraph/policy';
 import { draftForRecommendation, type TextModel } from '@outreachgraph/ai';
-import { runPipeline } from '@outreachgraph/pipeline';
-import { GitHubProvider } from '@outreachgraph/providers';
+import { batchStatus, enqueue, runPipeline } from '@outreachgraph/pipeline';
+import { GitHubProvider, normaliseUrl } from '@outreachgraph/providers';
 import { ConsoleMailer, verificationEmail, type Mailer } from '@outreachgraph/email';
 import { ApiError, canApprove, type AppEnv, type RequestActor } from './context';
 import * as repo from './repository';
 
+/** One paste, one reviewable unit of work. */
+const MAX_BULK_URLS = 100;
+
 export interface AppOptions {
   readonly db: Client;
   /**
@@ -393,6 +396,135 @@ export function createApp(options: AppOptions): Hono<AppEnv> {
     });
   });
 
+  // ------------------------------------------------------------ by url
+  /**
+   * Adds prospects from company URLs (PRD §8, URL-first intake).
+   *
+   * Accepts one URL or up to a hundred, and answers immediately with a batch
+   * id. Nothing is fetched inside the request: a single URL fans out to a
+   * crawl, an extraction, an identity resolution per person named and a draft
+   * per recommendation, and doing that inline for a hundred URLs is not a slow
+   * request but a request that never returns.
+   *
+   * A URL already queued is reported as a duplicate rather than rejected. The
+   * same address appearing twice in one paste is a normal thing for a human to
+   * do and must not fail the other ninety-nine.
+   */
+  api.post('/prospects/by-url', async (c) => {
+    const actor = c.get('actor');
+    const db = c.get('db');
+
+    if (!canApprove(actor)) throw ApiError.forbidden('adding prospects');
+
+    const raw = safeJson(await c.req.raw.text());
+    const submitted = Array.isArray(raw.urls) ? raw.urls : [raw.url];
+
+    const cleaned: string[] = [];
+    const rejected: { url: string; reason: string }[] = [];
+    const seen = new Set<string>();
+
+    for (const entry of submitted) {
+      if (typeof entry !== 'string' || !entry.trim()) continue;
+
+      let parsed: URL;
+      try {
+        parsed = new URL(normaliseUrl(entry));
+      } catch {
+        rejected.push({ url: String(entry), reason: 'not a url' });
+        continue;
+      }
+
+      if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+        rejected.push({ url: entry, reason: 'unsupported scheme' });
+        continue;
+      }
+
+      // `new URL` is far more permissive than a domain is: prefixing a scheme
+      // onto free text such as "not a url at all" produces a URL object with a
+      // one-word host, which would otherwise become a crawl job that can only
+      // ever fail. Require something that looks like a registrable domain.
+      if (
+        !/^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$/i.test(parsed.hostname)
+      ) {
+        rejected.push({ url: entry, reason: 'not a domain' });
+        continue;
+      }
+
+      // Deduped by host, not by the full string: `example.com`,
+      // `https://example.com/` and `https://www.example.com` are one company,
+      // and crawling a homepage three times helps nobody.
+      const key = parsed.hostname.replace(/^www\./, '').toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+
+      cleaned.push(parsed.toString());
+    }
+
+    if (cleaned.length === 0) {
+      throw ApiError.badRequest('enter at least one company URL', { urls: ['none were usable'] });
+    }
+
+    if (cleaned.length > MAX_BULK_URLS) {
+      throw ApiError.badRequest(`at most ${MAX_BULK_URLS} URLs at a time`, {
+        urls: [`received ${cleaned.length}`],
+      });
+    }
+
+    const batchId = newId('job');
+    const queued: string[] = [];
+    const duplicates: string[] = [];
+
+    for (const url of cleaned) {
+      const result = await enqueue(db, {
+        workspaceId: actor.workspaceId,
+        kind: 'crawl_site',
+        payload: { url },
+        batchId,
+        // One outstanding crawl per host per workspace. Releases itself when
+        // the job finishes, so the site can be re-crawled later.
+        dedupeKey: `crawl:${new URL(url).hostname.replace(/^www\./, '')}`,
+      });
+
+      if (result.queued) queued.push(url);
+      else duplicates.push(url);
+    }
+
+    await repo.audit(db, {
+      workspaceId: actor.workspaceId,
+      actorKind: 'user',
+      actorId: actor.userId,
+      eventType: 'prospects.bulk_queued',
+      entityKind: 'job',
+      entityId: batchId,
+      detail: { queued: queued.length, duplicates: duplicates.length, rejected: rejected.length },
+    });
+
+    return c.json(
+      {
+        batchId,
+        queued: queued.length,
+        urls: queued,
+        ...(duplicates.length ? { duplicates } : {}),
+        ...(rejected.length ? { rejected } : {}),
+      },
+      202,
+    );
+  });
+
+  /**
+   * Progress for one bulk submission.
+   *
+   * Reports the individual rows, not just counts: after a hundred URLs the
+   * useful question is which ones failed and why, and that answer is on the row.
+   */
+  api.get('/batches/:id', async (c) => {
+    const actor = c.get('actor');
+    const status = await batchStatus(c.get('db'), actor.workspaceId, c.req.param('id'));
+
+    if (!status) throw ApiError.notFound('batch');
+    return c.json(status);
+  });
+
   // -------------------------------------------------------------- people
   /**
    * The prospect list, ranked the way the UI ranks everything else — by
diff --git a/apps/api/src/by-url.test.ts b/apps/api/src/by-url.test.ts
new file mode 100644
index 0000000..205bc46
--- /dev/null
+++ b/apps/api/src/by-url.test.ts
@@ -0,0 +1,201 @@
+import { afterEach, describe, expect, test } from 'bun:test';
+import type { Hono } from 'hono';
+import { queryAll } from '@outreachgraph/db';
+import { createApp } from './app';
+import type { AppEnv, RequestActor } from './context';
+import { seedDatabase, SEED, type SeededDatabase } from './test-seed';
+
+const ACTOR: RequestActor = {
+  userId: SEED.userId,
+  workspaceId: SEED.workspaceId,
+  organizationId: SEED.organizationId,
+  role: 'owner',
+};
+
+let active: SeededDatabase | undefined;
+
+afterEach(() => {
+  active?.cleanup();
+  active = undefined;
+});
+
+async function harness(
+  label: string,
+  actor: RequestActor | null = ACTOR,
+): Promise<{ app: Hono<AppEnv>; seeded: SeededDatabase }> {
+  const seeded = await seedDatabase(label);
+  active = seeded;
+
+  const app = createApp({
+    db: seeded.db,
+    authenticate: async () => actor ?? undefined,
+  });
+
+  return { app, seeded };
+}
+
+async function post(app: Hono<AppEnv>, path: string, body: unknown): Promise<Response> {
+  return app.request(`/api/v1${path}`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+}
+
+describe('POST /prospects/by-url', () => {
+  test('a single URL is accepted and queued, not crawled inline', async () => {
+    const { app, seeded } = await harness('byurl-single');
+
+    const response = await post(app, '/prospects/by-url', { url: 'https://loopwright.io' });
+    const body = await response.json();
+
+    // 202, not 200: the work has been accepted, not done.
+    expect(response.status).toBe(202);
+    expect(body.queued).toBe(1);
+    expect(body.batchId).toStartWith('job_');
+
+    const jobs = await queryAll<{ kind: string; status: string; payload_json: string }>(
+      seeded.db,
+      'SELECT kind, status, payload_json FROM jobs',
+    );
+
+    expect(jobs).toHaveLength(1);
+    expect(jobs[0]!.kind).toBe('crawl_site');
+    expect(jobs[0]!.status).toBe('pending');
+    expect(JSON.parse(jobs[0]!.payload_json).url).toContain('loopwright.io');
+  });
+
+  test('a bare domain is accepted', async () => {
+    const { app } = await harness('byurl-bare');
+
+    const response = await post(app, '/prospects/by-url', { url: 'loopwright.io' });
+    const body = await response.json();
+
+    expect(response.status).toBe(202);
+    expect(body.urls[0]).toBe('https://loopwright.io/');
+  });
+
+  test('the same company twice in one paste is queued once', async () => {
+    const { app } = await harness('byurl-dupe-in-batch');
+
+    const response = await post(app, '/prospects/by-url', {
+      urls: ['https://loopwright.io', 'https://www.loopwright.io/', 'loopwright.io'],
+    });
+    const body = await response.json();
+
+    // Deduped by host: www and the bare domain are the same company, and
+    // crawling a homepage three times helps nobody.
+    expect(body.queued).toBe(1);
+  });
+
+  test('a URL already queued is reported, not rejected', async () => {
+    const { app } = await harness('byurl-dupe-across');
+
+    await post(app, '/prospects/by-url', { url: 'https://loopwright.io' });
+    const second = await post(app, '/prospects/by-url', {
+      urls: ['https://loopwright.io', 'https://other.example'],
+    });
+    const body = await second.json();
+
+    expect(body.queued).toBe(1);
+    expect(body.duplicates).toHaveLength(1);
+    // The point: one repeat must not take the other URL down with it.
+    expect(body.urls[0]).toContain('other.example');
+  });
+
+  test('unusable entries are named rather than silently dropped', async () => {
+    const { app } = await harness('byurl-rejected');
+
+    const response = await post(app, '/prospects/by-url', {
+      urls: ['https://good.example', 'ftp://files.example', 'not a url at all'],
+    });
+    const body = await response.json();
+
+    expect(body.queued).toBe(1);
+    expect(body.rejected.map((r: { url: string }) => r.url)).toContain('ftp://files.example');
+  });
+
+  test('a submission with nothing usable is a 400', async () => {
+    const { app } = await harness('byurl-empty');
+
+    const response = await post(app, '/prospects/by-url', { urls: ['', '  '] });
+    expect(response.status).toBe(400);
+  });
+
+  test('more than a hundred URLs is refused', async () => {
+    const { app } = await harness('byurl-too-many');
+
+    const urls = Array.from({ length: 101 }, (_, i) => `https://site-${i}.example`);
+    const response = await post(app, '/prospects/by-url', { urls });
+
+    expect(response.status).toBe(400);
+    expect((await response.json()).error.message).toContain('100');
+  });
+
+  test('a hundred URLs is accepted and answers immediately', async () => {
+    const { app, seeded } = await harness('byurl-hundred');
+
+    const urls = Array.from({ length: 100 }, (_, i) => `https://site-${i}.example`);
+    const response = await post(app, '/prospects/by-url', { urls });
+
+    expect(response.status).toBe(202);
+    expect((await response.json()).queued).toBe(100);
+
+    const rows = await queryAll<{ n: number }>(seeded.db, 'SELECT COUNT(*) AS n FROM jobs');
+    expect(Number(rows[0]!.n)).toBe(100);
+  });
+
+  test('a caller who cannot approve cannot add prospects', async () => {
+    const { app } = await harness('byurl-forbidden', { ...ACTOR, role: 'viewer' });
+
+    const response = await post(app, '/prospects/by-url', { url: 'https://loopwright.io' });
+    expect(response.status).toBe(403);
+  });
+});
+
+describe('GET /batches/:id', () => {
+  test('progress reports each URL, not just a count', async () => {
+    const { app } = await harness('batch-progress');
+
+    const created = await post(app, '/prospects/by-url', {
+      urls: ['https://one.example', 'https://two.example'],
+    });
+    const { batchId } = await created.json();
+
+    const response = await app.request(`/api/v1/batches/${batchId}`);
+    const body = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(body.total).toBe(2);
+    expect(body.pending).toBe(2);
+    // "Which ones, and why" is the question after a hundred URLs, and it can
+    // only be answered from the individual rows.
+    expect(body.items.map((i: { url: string }) => i.url).sort()).toEqual([
+      'https://one.example/',
+      'https://two.example/',
+    ]);
+  });
+
+  test('an unknown batch is a 404', async () => {
+    const { app } = await harness('batch-missing');
+
+    const response = await app.request('/api/v1/batches/job_nope');
+    expect(response.status).toBe(404);
+  });
+
+  test('another workspace cannot read this batch', async () => {
+    const { app, seeded } = await harness('batch-scoped');
+
+    const created = await post(app, '/prospects/by-url', { url: 'https://one.example' });
+    const { batchId } = await created.json();
+
+    // A second app over the *same* database, not a second harness: calling the
+    // helper twice would replace the tracked handle and leak the first file.
+    const other = createApp({
+      db: seeded.db,
+      authenticate: async () => ({ ...ACTOR, workspaceId: 'wsp_someone_else' }),
+    });
+
+    expect((await other.request(`/api/v1/batches/${batchId}`)).status).toBe(404);
+  });
+});
diff --git a/apps/server/src/index.ts b/apps/server/src/index.ts
index d76265b..68e22b2 100644
--- a/apps/server/src/index.ts
+++ b/apps/server/src/index.ts
@@ -29,8 +29,11 @@ import {
   expireSignals,
   processDeletion,
   rescoreProspect,
+  runPipelineForCandidate,
   type QueuedJob,
 } from '@outreachgraph/pipeline';
+import { BlueskyProvider, SiteProvider } from '@outreachgraph/providers';
+import { queryOne } from '@outreachgraph/db';
 
 const PORT = Number(process.env.PORT ?? 8080);
 const WEB_PORT = Number(process.env.WEB_PORT ?? 3001);
@@ -225,8 +228,79 @@ let inFlight: Promise<void> = Promise.resolve();
  * success. A throw here is how the queue is told to retry or, once attempts
  * run out, to keep the row as `failed` with the reason attached.
  */
+/** The site crawler, sharing the composer's key for its extraction fallback. */
+const site = new SiteProvider(model ? { model } : {});
+
+/**
+ * Providers the fan-out may consult once a candidate exists.
+ *
+ * Bluesky only, for now, and deliberately: its AppView needs no key and no
+ * contract, so it can run here without a commercial decision attached. X and
+ * the enrichment vendors both do, and shipping an adapter that cannot be
+ * exercised would be code pretending to be a feature.
+ */
+const fanOutProviders = [new BlueskyProvider()];
+
+/**
+ * Fetches one company URL and runs everyone it names.
+ *
+ * A page that names nobody is a completed job, not a failed one. Homepages
+ * frequently describe a company without naming a single person, and retrying
+ * that four more times would spend the crawl budget re-reading a page whose
+ * answer will not change.
+ */
+async function crawlSite(job: QueuedJob): Promise<void> {
+  const { url } = job.payload as { url?: string };
+  if (!url) throw new Error('crawl_site needs a url');
+
+  const result = await site.crawl(url);
+
+  if (result.outcome !== 'ok') {
+    // A refusal is the site's answer and re-asking will not change it, so this
+    // resolves the job rather than throwing it back into the retry loop.
+    console.log(`crawl ${url}: ${result.outcome}${result.detail ? ` (${result.detail})` : ''}`);
+    return;
+  }
+
+  const campaign = await queryOne<{ id: string }>(
+    db,
+    `SELECT id FROM campaigns WHERE workspace_id = ? ORDER BY created_at LIMIT 1`,
+    [job.workspaceId],
+  );
+
+  if (!campaign) throw new Error(`workspace ${job.workspaceId} has no campaign`);
+
+  let queued = 0;
+  for (const candidate of result.people) {
+    await runPipelineForCandidate(
+      {
+        db,
+        workspaceId: job.workspaceId,
+        campaignId: campaign.id,
+        providers: fanOutProviders,
+        ...(model ? { model } : {}),
+      },
+      candidate,
+      {
+        capabilities: site.capabilities(),
+        // No anchor: nobody named on a company page is proven to be that
+        // person. Every identity found there is a claim for the resolver.
+      },
+    );
+    queued += 1;
+  }
+
+  console.log(
+    `crawl ${url}: ${result.company.name ?? 'unnamed company'}, ${queued} people` +
+      ` (${result.usedSignals.join(', ') || 'no signals'})`,
+  );
+}
+
 async function runJob(job: QueuedJob): Promise<void> {
   switch (job.kind) {
+    case 'crawl_site':
+      await crawlSite(job);
+      return;
     case 'rescore_prospect': {
       const { campaignId, personId } = job.payload as { campaignId?: string; personId?: string };
       if (!campaignId || !personId)
diff --git a/migrations/0008_job_batches.sql b/migrations/0008_job_batches.sql
new file mode 100644
index 0000000..48e31d4
--- /dev/null
+++ b/migrations/0008_job_batches.sql
@@ -0,0 +1,16 @@
+-- Batches (PRD §8, URL-first intake).
+--
+-- Pasting a hundred URLs produces a hundred independent jobs, and the person
+-- who pasted them wants one answer: how far along is it, and which ones failed.
+-- Without a grouping key the API can only report on jobs it already holds the
+-- ids of, which means the client has to remember a hundred of them.
+--
+-- A column rather than a `batches` table. A batch has no attributes of its own
+-- beyond the jobs in it — no name, no owner beyond the workspace already on
+-- every job, no lifecycle that is not just the aggregate of its members. A
+-- table would add a join and a second thing to keep consistent for nothing.
+
+ALTER TABLE jobs ADD COLUMN batch_id TEXT;
+
+-- The progress query: every job in one batch, oldest first.
+CREATE INDEX idx_jobs_batch ON jobs(batch_id, created_at) WHERE batch_id IS NOT NULL;
diff --git a/packages/pipeline/src/index.ts b/packages/pipeline/src/index.ts
index 8beb504..8bba285 100644
--- a/packages/pipeline/src/index.ts
+++ b/packages/pipeline/src/index.ts
@@ -7,7 +7,13 @@
  * dependency direction a lie.
  */
 
-export { runPipeline, type PipelineOptions, type PipelineResult } from './pipeline';
+export {
+  runPipeline,
+  runPipelineForCandidate,
+  type CandidateOrigin,
+  type PipelineOptions,
+  type PipelineResult,
+} from './pipeline';
 export {
   expireSignals,
   markSourceUnavailable,
@@ -18,6 +24,7 @@ export {
   type JobResult,
 } from './jobs';
 export {
+  batchStatus,
   claimNext,
   completeJob,
   drainQueue,
@@ -26,6 +33,8 @@ export {
   queueDepth,
   reclaimStalled,
   JOB_STATUSES,
+  type BatchItem,
+  type BatchStatus,
   type DrainSummary,
   type EnqueueInput,
   type EnqueueResult,
diff --git a/packages/pipeline/src/jobs.ts b/packages/pipeline/src/jobs.ts
index fd1e60d..c8a19aa 100644
--- a/packages/pipeline/src/jobs.ts
+++ b/packages/pipeline/src/jobs.ts
@@ -24,6 +24,8 @@ export const JOB_KINDS = [
   'expire_signals',
   'process_deletion',
   'poll_drop',
+  /** Fetch one company URL, read it, and run everyone it names. */
+  'crawl_site',
 ] as const;
 
 export type JobKind = (typeof JOB_KINDS)[number];
diff --git a/packages/pipeline/src/pipeline.ts b/packages/pipeline/src/pipeline.ts
index 3f8c9bc..6774bc2 100644
--- a/packages/pipeline/src/pipeline.ts
+++ b/packages/pipeline/src/pipeline.ts
@@ -16,11 +16,13 @@ import { resolveIdentity, type EvidenceInput } from '@outreachgraph/identity';
 import {
   deriveEvidence,
   extractSignals,
+  findIdentities,
   GitHubProvider,
   GitHubRateLimitError,
   type ExtractedSignal,
   type PersonCandidate,
   type PersonEnrichmentProvider,
+  type ProviderCapabilities,
 } from '@outreachgraph/providers';
 import { generateRecommendation, type CandidateSignal } from '@outreachgraph/recommend';
 import { draftForRecommendation, type TextModel } from '@outreachgraph/ai';
@@ -54,17 +56,14 @@ export interface PipelineResult {
 /**
  * Runs the full chain for one GitHub handle.
  *
- * GitHub-first is deliberate: it is free, its profiles carry self-declared
- * cross-links, and the launch wedge is developer tooling (PRD §45).
+ * GitHub-first was the launch wedge: it is free and its profiles carry
+ * self-declared cross-links (PRD §45). It is now one way in among others —
+ * this resolves a handle to a candidate and hands over to the shared chain.
  */
 export async function runPipeline(
   options: PipelineOptions,
   handle: string,
 ): Promise<PipelineResult> {
-  const { db, workspaceId, campaignId } = options;
-  const stamp = now();
-
-  // ---------------------------------------------------------------- enrich
   const github = options.github ?? new GitHubProvider();
   const enrichment = await github.enrich({ handles: { github: handle } });
 
@@ -77,10 +76,44 @@ export async function runPipeline(
     };
   }
 
-  const candidate = enrichment.candidate;
+  return runPipelineForCandidate(options, enrichment.candidate, {
+    capabilities: github.capabilities(),
+    // The GitHub account this run started from is the anchor: it is the person,
+    // not an inference about them, so it links without a confidence test.
+    anchorNetwork: 'github',
+    githubHandle: handle,
+  });
+}
+
+export interface CandidateOrigin {
+  /** Whose data this is, for provenance and evidence weighting. */
+  readonly capabilities: ProviderCapabilities;
+  /** A network whose identity *is* the person, rather than a match for them. */
+  readonly anchorNetwork?: Network;
+  /** Enables the GitHub research stage when the candidate has a handle. */
+  readonly githubHandle?: string;
+}
+
+/**
+ * The chain, from a candidate onwards.
+ *
+ * This is the part that does not care where the person came from. A GitHub
+ * handle, a name lifted off a company homepage and an enrichment vendor's
+ * record all arrive here as the same normalised candidate, and everything after
+ * this point — suppression, resolution, research, scoring, recommendation,
+ * drafting — is identical for all three.
+ */
+export async function runPipelineForCandidate(
+  options: PipelineOptions,
+  candidate: PersonCandidate,
+  origin: CandidateOrigin,
+): Promise<PipelineResult> {
+  const { db, workspaceId, campaignId } = options;
+  const stamp = now();
+
   const personId = await upsertPerson(db, candidate, stamp);
 
-  await recordProvenance(db, personId, candidate, stamp);
+  await recordProvenance(db, personId, candidate, origin, stamp);
   await ensureCampaignMembership(db, campaignId, personId, workspaceId, stamp);
 
   // Suppression outranks everything: a suppressed person is never researched
@@ -97,21 +130,42 @@ export async function runPipeline(
   }
 
   // -------------------------------------------------------------- resolve
-  const linked = await linkIdentities(db, personId, candidate, github, stamp);
+  //
+  // Ask the other configured providers what else they can vouch for before
+  // resolving. Nothing is merged here — the fan-out gathers claims and the
+  // resolver below decides which of them are the same person.
+  const fanned =
+    options.providers.length > 0 ? await findIdentities(candidate, options.providers) : undefined;
+
+  const enriched = fanned?.candidate ?? candidate;
+
+  const linked = await linkIdentities(db, personId, enriched, origin, stamp);
   await setStatus(db, campaignId, personId, 'resolved');
 
   // ------------------------------------------------------------- research
+  //
+  // Only GitHub produces signals today, so a candidate with no GitHub identity
+  // reaches the queue with evidence but no activity. That is a real limitation
+  // rather than a bug: the card still carries the prospect and its source, and
+  // the composer refuses to invent a reason it cannot ground.
+  const researchHandle =
+    origin.githubHandle ??
+    candidate.identities.find((identity) => identity.network === 'github')?.handle;
+
   let stored = 0;
-  try {
-    const activity = await github.activity(handle);
-    const context = await extractionContext(db, campaignId);
-    const extracted = extractSignals(activity.events, activity.repos, context);
-    stored = await storeSignals(db, workspaceId, personId, extracted, stamp);
-    await setStatus(db, campaignId, personId, 'researching');
-  } catch (error) {
-    // A quota wall is not a prospect failure — keep what we have and let the
-    // next tick resume research.
-    if (!(error instanceof GitHubRateLimitError)) throw error;
+  if (researchHandle) {
+    const github = options.github ?? new GitHubProvider();
+    try {
+      const activity = await github.activity(researchHandle);
+      const context = await extractionContext(db, campaignId);
+      const extracted = extractSignals(activity.events, activity.repos, context);
+      stored = await storeSignals(db, workspaceId, personId, extracted, stamp);
+      await setStatus(db, campaignId, personId, 'researching');
+    } catch (error) {
+      // A quota wall is not a prospect failure — keep what we have and let the
+      // next tick resume research.
+      if (!(error instanceof GitHubRateLimitError)) throw error;
+    }
   }
 
   // ---------------------------------------------------------------- score
@@ -237,7 +291,7 @@ async function linkIdentities(
   db: Client,
   personId: string,
   candidate: PersonCandidate,
-  provider: GitHubProvider,
+  origin: CandidateOrigin,
   stamp: string,
 ): Promise<number> {
   const workspace = await queryOne<{ auto_merge_threshold: number; candidate_threshold: number }>(
@@ -262,14 +316,16 @@ async function linkIdentities(
     const evidence: EvidenceInput[] = deriveEvidence({
       identity,
       candidate,
-      capabilities: provider.capabilities(),
+      capabilities: origin.capabilities,
       crossLinkedHandles: declared,
       ...(candidate.companyName ? { platformEmployer: candidate.companyName } : {}),
     });
 
-    // The GitHub account itself is the anchor, not an inference about it.
+    // The anchor identity *is* the person the run started from, not an
+    // inference about them, so it links without a confidence test. A crawl has
+    // no anchor: every identity on a company page is a claim to be resolved.
     const resolution =
-      identity.network === 'github'
+      origin.anchorNetwork && identity.network === origin.anchorNetwork
         ? { decision: 'merge' as const, score: 1, verifiedBy: ['provider_asserted_link'] }
         : resolveIdentity(evidence, { thresholds });
 
@@ -277,7 +333,7 @@ async function linkIdentities(
       await db.execute({
         sql: `INSERT INTO social_identities (id, person_id, network, handle, platform_user_id,
               profile_url, confidence, source_type, verified_by, first_seen_at, last_verified_at)
-              VALUES (?, ?, ?, ?, ?, ?, ?, 'official_api', ?, ?, ?)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
               -- The uniqueness index is partial, so the conflict target has to
               -- repeat its WHERE clause or SQLite refuses to match it.
               ON CONFLICT(network, platform_user_id) WHERE platform_user_id IS NOT NULL
@@ -290,6 +346,7 @@ async function linkIdentities(
           identity.platformUserId ?? null,
           identity.profileUrl ?? null,
           resolution.score,
+          origin.capabilities.sourceType,
           JSON.stringify(resolution.verifiedBy),
           stamp,
           stamp,
@@ -519,6 +576,7 @@ async function recordProvenance(
   db: Client,
   personId: string,
   candidate: PersonCandidate,
+  origin: CandidateOrigin,
   stamp: string,
 ): Promise<void> {
   const fields: [string, string | undefined][] = [
@@ -531,15 +589,22 @@ async function recordProvenance(
   for (const [field, value] of fields) {
     if (!value) continue;
     await db.execute({
+      // Attribution follows the provider that actually supplied the value.
+      // Hardcoding GitHub's here was harmless while GitHub was the only source;
+      // with a crawl in the mix it would label a scraped name as an API fact
+      // and mis-classify what may be retained and exported (PRD §35).
       sql: `INSERT INTO field_provenance (id, entity_kind, entity_id, field, value, source_type,
             provider, source_record_id, license_class, confidence, observed_at, created_at)
-            VALUES (?, 'person', ?, ?, ?, 'official_api', 'github', ?, 'public_api', 1.0, ?, ?)`,
+            VALUES (?, 'person', ?, ?, ?, ?, ?, ?, ?, 1.0, ?, ?)`,
       args: [
         newId('fieldProvenance'),
         personId,
         field,
         value,
+        origin.capabilities.sourceType,
+        origin.capabilities.slug,
         candidate.sourceRecordId ?? null,
+        origin.capabilities.licenseClass,
         candidate.observedAt,
         stamp,
       ],
diff --git a/packages/pipeline/src/queue.ts b/packages/pipeline/src/queue.ts
index 721a70d..fd68cd0 100644
--- a/packages/pipeline/src/queue.ts
+++ b/packages/pipeline/src/queue.ts
@@ -50,6 +50,8 @@ export interface EnqueueInput {
   readonly maxAttempts?: number;
   /** Suppresses a duplicate while an identical job is still outstanding. */
   readonly dedupeKey?: string;
+  /** Groups this job with the rest of one bulk submission. */
+  readonly batchId?: string;
 }
 
 export interface EnqueueResult {
@@ -77,8 +79,8 @@ export async function enqueue(db: Client, input: EnqueueInput): Promise<EnqueueR
   try {
     await db.execute({
       sql: `INSERT INTO jobs (id, workspace_id, kind, payload_json, status, attempts,
-              max_attempts, run_after, dedupe_key, created_at, updated_at)
-            VALUES (?, ?, ?, ?, 'pending', 0, ?, ?, ?, ?, ?)`,
+              max_attempts, run_after, dedupe_key, batch_id, created_at, updated_at)
+            VALUES (?, ?, ?, ?, 'pending', 0, ?, ?, ?, ?, ?, ?)`,
       args: [
         id,
         input.workspaceId,
@@ -87,6 +89,7 @@ export async function enqueue(db: Client, input: EnqueueInput): Promise<EnqueueR
         input.maxAttempts ?? 5,
         plus(stamp, input.delayMs ?? 0),
         input.dedupeKey ?? null,
+        input.batchId ?? null,
         stamp,
         stamp,
       ],
@@ -295,6 +298,75 @@ export async function drainQueue(
   return { processed, succeeded, retried, dead, reclaimed };
 }
 
+export interface BatchItem {
+  readonly id: string;
+  readonly status: JobStatus;
+  readonly attempts: number;
+  /** The URL this job was created for, when it has one. */
+  readonly url?: string;
+  readonly lastError?: string;
+}
+
+export interface BatchStatus {
+  readonly batchId: string;
+  readonly total: number;
+  readonly pending: number;
+  readonly running: number;
+  readonly done: number;
+  readonly failed: number;
+  readonly items: readonly BatchItem[];
+}
+
+/**
+ * Progress for one bulk submission.
+ *
+ * Returns the individual rows rather than only the counts, because the useful
+ * question after a hundred URLs is not "how many failed" but "which ones, and
+ * why" — and that answer lives in each row's `last_error`.
+ */
+export async function batchStatus(
+  db: Client,
+  workspaceId: string,
+  batchId: string,
+): Promise<BatchStatus | undefined> {
+  const rows = await queryAll<{
+    id: string;
+    status: string;
+    attempts: number;
+    payload_json: string;
+    last_error: string | null;
+  }>(
+    db,
+    `SELECT id, status, attempts, payload_json, last_error
+       FROM jobs WHERE batch_id = ? AND workspace_id = ? ORDER BY created_at`,
+    [batchId, workspaceId],
+  );
+
+  if (rows.length === 0) return undefined;
+
+  const counts: Record<JobStatus, number> = { pending: 0, running: 0, done: 0, failed: 0 };
+  const items: BatchItem[] = [];
+
+  for (const row of rows) {
+    const status = (
+      (JOB_STATUSES as readonly string[]).includes(row.status) ? row.status : 'pending'
+    ) as JobStatus;
+    counts[status] += 1;
+
+    const url = safeParse(row.payload_json).url;
+
+    items.push({
+      id: row.id,
+      status,
+      attempts: Number(row.attempts),
+      ...(typeof url === 'string' ? { url } : {}),
+      ...(row.last_error ? { lastError: row.last_error } : {}),
+    });
+  }
+
+  return { batchId, total: rows.length, ...counts, items };
+}
+
 /** Queue depth by status, for the tick log and, later, an operator view. */
 export async function queueDepth(db: Client): Promise<Record<JobStatus, number>> {
   const rows = await queryAll<{ status: string; n: number }>(
diff --git a/packages/providers/src/bluesky/bluesky.test.ts b/packages/providers/src/bluesky/bluesky.test.ts
new file mode 100644
index 0000000..c956ec0
--- /dev/null
+++ b/packages/providers/src/bluesky/bluesky.test.ts
@@ -0,0 +1,178 @@
+import { describe, expect, test } from 'bun:test';
+import { BlueskyProvider, BlueskyRateLimitError } from './provider';
+import { findIdentities } from '../fan-out';
+import type { PersonCandidate, PersonEnrichmentProvider } from '../provider';
+
+function jsonFetch(status: number, body: unknown) {
+  return async (): Promise<Response> =>
+    new Response(JSON.stringify(body), {
+      status,
+      headers: { 'content-type': 'application/json' },
+    });
+}
+
+const PROFILE = {
+  did: 'did:plc:abc123',
+  handle: 'alex.bsky.social',
+  displayName: 'Alex Chen',
+  description: 'agent reliability',
+};
+
+describe('BlueskyProvider', () => {
+  test('a known handle resolves to an identity carrying the stable did', async () => {
+    const provider = new BlueskyProvider({ fetchImpl: jsonFetch(200, PROFILE) });
+
+    const result = await provider.enrich({ handles: { bluesky: 'alex.bsky.social' } });
+
+    expect(result.matchConfidence).toBe(1);
+    expect(result.candidate?.fullName).toBe('Alex Chen');
+    // The did, not the handle: handles on this network are renameable.
+    expect(result.candidate?.identities[0]!.platformUserId).toBe('did:plc:abc123');
+    expect(result.candidate?.identities[0]!.profileUrl).toContain('alex.bsky.social');
+  });
+
+  test('a name alone resolves to nothing', async () => {
+    let called = false;
+    const provider = new BlueskyProvider({
+      fetchImpl: async () => {
+        called = true;
+        return new Response('{}', { status: 200 });
+      },
+    });
+
+    const result = await provider.enrich({ fullName: 'Alex Chen' });
+
+    // Taking the first search hit for a display name is how the wrong human
+    // reaches an approval queue. Finding nobody is the correct answer.
+    expect(result.matchConfidence).toBe(0);
+    expect(called).toBe(false);
+  });
+
+  test('an unknown actor is an answer, not an error', async () => {
+    const provider = new BlueskyProvider({
+      fetchImpl: jsonFetch(400, { error: 'InvalidRequest' }),
+    });
+
+    const result = await provider.enrich({ handles: { bluesky: 'nobody.bsky.social' } });
+    expect(result.candidate).toBeUndefined();
+  });
+
+  test('a quota wall is typed so callers can keep partial work', async () => {
+    const provider = new BlueskyProvider({ fetchImpl: jsonFetch(429, {}) });
+
+    await expect(
+      provider.enrich({ handles: { bluesky: 'alex.bsky.social' } }),
+    ).rejects.toBeInstanceOf(BlueskyRateLimitError);
+  });
+
+  test('search returns candidates for keywords', async () => {
+    const provider = new BlueskyProvider({ fetchImpl: jsonFetch(200, { actors: [PROFILE] }) });
+
+    const result = await provider.search({ keywords: ['agent reliability'] });
+    expect(result.candidates).toHaveLength(1);
+    expect(result.candidates[0]!.identities[0]!.network).toBe('bluesky');
+  });
+
+  test('it reports itself as free, so the waterfall reaches it early', () => {
+    expect(new BlueskyProvider().capabilities().costPerEnrichmentUsd).toBe(0);
+  });
+});
+
+describe('findIdentities', () => {
+  const BASE: PersonCandidate = {
+    fullName: 'Alex Chen',
+    identities: [{ network: 'github', handle: 'alexchen' }],
+    observedAt: '2026-08-13T00:00:00.000Z',
+  };
+
+  function stub(
+    slug: string,
+    networks: readonly ('github' | 'bluesky')[],
+    result: () => Promise<{
+      candidate?: PersonCandidate;
+      matchConfidence: number;
+      costUsd: number;
+    }>,
+  ): PersonEnrichmentProvider {
+    return {
+      capabilities: () => ({
+        slug,
+        displayName: slug,
+        networks,
+        canSearch: false,
+        canEnrich: true,
+        licenseClass: 'public_api',
+        sourceType: 'official_api',
+        costPerEnrichmentUsd: 0,
+      }),
+      search: async () => ({ candidates: [], costUsd: 0 }),
+      enrich: result,
+      costEstimate: async () => 0,
+    };
+  }
+
+  test('a provider is only asked about a network we already hold a handle for', async () => {
+    let asked = false;
+    const bluesky = stub('bluesky', ['bluesky'], async () => {
+      asked = true;
+      return { matchConfidence: 0, costUsd: 0 };
+    });
+
+    await findIdentities(BASE, [bluesky]);
+
+    // The candidate has a GitHub handle and nothing else. Asking Bluesky to
+    // find "Alex Chen" would be a guess, so it is not asked at all.
+    expect(asked).toBe(false);
+  });
+
+  test('discovered identities are folded in without duplicating what we had', async () => {
+    const candidate: PersonCandidate = {
+      ...BASE,
+      identities: [
+        { network: 'github', handle: 'alexchen' },
+        { network: 'bluesky', handle: 'alex.bsky.social' },
+      ],
+    };
+
+    const provider = stub('bluesky', ['bluesky'], async () => ({
+      candidate: {
+        ...candidate,
+        identities: [
+          { network: 'bluesky', handle: 'alex.bsky.social', platformUserId: 'did:plc:abc' },
+        ],
+      },
+      matchConfidence: 1,
+      costUsd: 0,
+    }));
+
+    const result = await findIdentities(candidate, [provider]);
+
+    // The returned identity keys on the did while ours keyed on the handle, so
+    // both survive — the resolver, not the fan-out, decides they are one person.
+    expect(result.attempts[0]!.found).toBe(1);
+    expect(result.candidate.identities.length).toBeGreaterThanOrEqual(2);
+  });
+
+  test('one provider failing does not lose the others', async () => {
+    const angry = stub('angry', ['github'], async () => {
+      throw new Error('rate limited');
+    });
+    const calm = stub('calm', ['github'], async () => ({
+      candidate: { ...BASE, identities: [{ network: 'bluesky', handle: 'found.bsky.social' }] },
+      matchConfidence: 1,
+      costUsd: 0,
+    }));
+
+    const result = await findIdentities(BASE, [angry, calm]);
+
+    expect(result.attempts.find((a) => a.provider === 'angry')?.ok).toBe(false);
+    expect(result.attempts.find((a) => a.provider === 'calm')?.found).toBe(1);
+    expect(result.candidate.identities.map((i) => i.network)).toContain('bluesky');
+  });
+
+  test('with no providers the candidate is returned untouched', async () => {
+    const result = await findIdentities(BASE, []);
+    expect(result.candidate).toEqual(BASE);
+    expect(result.attempts).toHaveLength(0);
+  });
+});
diff --git a/packages/providers/src/bluesky/provider.ts b/packages/providers/src/bluesky/provider.ts
new file mode 100644
index 0000000..45f998b
--- /dev/null
+++ b/packages/providers/src/bluesky/provider.ts
@@ -0,0 +1,150 @@
+/**
+ * Bluesky as an identity source (capability matrix: `bluesky/observe` is
+ * `official_api`, "public AppView feed and profile data").
+ *
+ * First after GitHub for one reason: the AppView is genuinely public. No key,
+ * no contract, no per-seat cost — so it can ship and be tested without a
+ * commercial decision attached, which is not true of X or an enrichment vendor.
+ *
+ * Read-only. Every write action on this network is `official_api` in the
+ * matrix and belongs to the execution path, not to research.
+ */
+
+import type { FetchLike } from '../site/fetch';
+import type {
+  CandidateIdentity,
+  PersonCandidate,
+  PersonEnrichmentInput,
+  PersonEnrichmentProvider,
+  PersonEnrichmentResult,
+  PersonSearchInput,
+  PersonSearchResult,
+  ProviderCapabilities,
+} from '../provider';
+
+export const BLUESKY_API = 'https://public.api.bsky.app';
+
+export interface BlueskyProviderOptions {
+  readonly baseUrl?: string;
+  readonly fetchImpl?: FetchLike;
+  readonly timeoutMs?: number;
+}
+
+interface ActorProfile {
+  did?: string;
+  handle?: string;
+  displayName?: string;
+  description?: string;
+}
+
+/** Raised for a quota wall, so callers can keep partial work as GitHub does. */
+export class BlueskyRateLimitError extends Error {
+  constructor() {
+    super('bluesky rate limit reached');
+    this.name = 'BlueskyRateLimitError';
+  }
+}
+
+export class BlueskyProvider implements PersonEnrichmentProvider {
+  readonly #baseUrl: string;
+  readonly #fetch: FetchLike;
+  readonly #timeoutMs: number;
+
+  constructor(options: BlueskyProviderOptions = {}) {
+    this.#baseUrl = options.baseUrl ?? BLUESKY_API;
+    this.#fetch = options.fetchImpl ?? fetch;
+    this.#timeoutMs = options.timeoutMs ?? 10_000;
+  }
+
+  capabilities(): ProviderCapabilities {
+    return {
+      slug: 'bluesky',
+      displayName: 'Bluesky',
+      networks: ['bluesky'],
+      canSearch: true,
+      canEnrich: true,
+      licenseClass: 'public_api',
+      sourceType: 'official_api',
+      costPerEnrichmentUsd: 0,
+    };
+  }
+
+  async #get<T>(path: string, params: Record<string, string>): Promise<T | undefined> {
+    const url = new URL(`/xrpc/${path}`, this.#baseUrl);
+    for (const [key, value] of Object.entries(params)) url.searchParams.set(key, value);
+
+    const response = await this.#fetch(url.toString(), {
+      headers: { accept: 'application/json' },
+      signal: AbortSignal.timeout(this.#timeoutMs),
+    });
+
+    if (response.status === 429) throw new BlueskyRateLimitError();
+    // A missing actor is an answer, not a fault: most people are not here.
+    if (response.status === 400 || response.status === 404) return undefined;
+    if (!response.ok) throw new Error(`bluesky ${path} failed: ${response.status}`);
+
+    return (await response.json()) as T;
+  }
+
+  async search(input: PersonSearchInput): Promise<PersonSearchResult> {
+    const query = input.keywords?.join(' ').trim();
+    if (!query) return { candidates: [], costUsd: 0 };
+
+    const result = await this.#get<{ actors?: ActorProfile[] }>('app.bsky.actor.searchActors', {
+      q: query,
+      limit: String(Math.min(input.limit ?? 20, 50)),
+    });
+
+    const observedAt = new Date().toISOString();
+    const candidates = (result?.actors ?? [])
+      .filter((actor) => actor.handle)
+      .map((actor) => toCandidate(actor, observedAt));
+
+    return { candidates, costUsd: 0 };
+  }
+
+  /**
+   * Resolves one Bluesky identity.
+   *
+   * Only a known handle is looked up. Searching by display name and taking the
+   * first hit is how a product confidently attaches the wrong person: names are
+   * not unique and this network has no verification to break the tie. Finding
+   * nobody is the correct answer to a name.
+   */
+  async enrich(input: PersonEnrichmentInput): Promise<PersonEnrichmentResult> {
+    const handle = input.handles?.bluesky;
+    if (!handle) return { matchConfidence: 0, costUsd: 0 };
+
+    const profile = await this.#get<ActorProfile>('app.bsky.actor.getProfile', { actor: handle });
+    if (!profile?.handle) return { matchConfidence: 0, costUsd: 0 };
+
+    return {
+      candidate: toCandidate(profile, new Date().toISOString()),
+      // The handle was supplied and the profile exists: this is a resolution,
+      // not a guess.
+      matchConfidence: 1,
+      costUsd: 0,
+    };
+  }
+
+  async costEstimate(_input: PersonSearchInput | PersonEnrichmentInput): Promise<number> {
+    return 0;
+  }
+}
+
+function toCandidate(actor: ActorProfile, observedAt: string): PersonCandidate {
+  const identity: CandidateIdentity = {
+    network: 'bluesky',
+    handle: actor.handle!,
+    ...(actor.did ? { platformUserId: actor.did } : {}),
+    profileUrl: `https://bsky.app/profile/${actor.handle}`,
+    providerConfidence: 1,
+  };
+
+  return {
+    fullName: actor.displayName?.trim() || actor.handle!,
+    identities: [identity],
+    ...(actor.did ? { sourceRecordId: actor.did } : {}),
+    observedAt,
+  };
+}
diff --git a/packages/providers/src/fan-out.ts b/packages/providers/src/fan-out.ts
new file mode 100644
index 0000000..b3a26aa
--- /dev/null
+++ b/packages/providers/src/fan-out.ts
@@ -0,0 +1,105 @@
+/**
+ * Asking every configured provider what else it knows about one person.
+ *
+ * The waterfall picks *one* provider to answer a question cheaply. This is the
+ * other shape: a candidate already exists, and each provider is asked to add
+ * the identities it can vouch for. A crawl that produced a name and an X handle
+ * gains a Bluesky profile here, and only then does the resolver decide whether
+ * any of it is the same human.
+ *
+ * Nothing here merges anything. It gathers claims; `@outreachgraph/identity`
+ * weighs them. Keeping those apart is what stops a provider's confidence from
+ * quietly becoming the product's confidence.
+ */
+
+import type { Network } from '@outreachgraph/domain';
+import type { CandidateIdentity, PersonCandidate, PersonEnrichmentProvider } from './provider';
+
+export interface FanOutAttempt {
+  readonly provider: string;
+  readonly ok: boolean;
+  readonly found: number;
+  readonly error?: string;
+}
+
+export interface FanOutResult {
+  /** The candidate with everything discovered folded in. */
+  readonly candidate: PersonCandidate;
+  readonly attempts: readonly FanOutAttempt[];
+  readonly costUsd: number;
+}
+
+function key(identity: CandidateIdentity): string {
+  return `${identity.network}:${(identity.platformUserId ?? identity.handle ?? '').toLowerCase()}`;
+}
+
+/**
+ * Runs every provider that can add something, and folds the results together.
+ *
+ * A provider is only asked when the candidate already carries a handle it can
+ * resolve. Handing a display name to a network with no verification and taking
+ * the first match is how the wrong person ends up in an approval queue, so
+ * discovery here is strictly "resolve what we were told", never "find someone
+ * who looks like this".
+ *
+ * One provider failing never fails the fan-out. A quota wall on one network is
+ * not a reason to discard what the others returned.
+ */
+export async function findIdentities(
+  candidate: PersonCandidate,
+  providers: readonly PersonEnrichmentProvider[],
+): Promise<FanOutResult> {
+  const merged = new Map<string, CandidateIdentity>();
+  for (const identity of candidate.identities) merged.set(key(identity), identity);
+
+  const attempts: FanOutAttempt[] = [];
+  let costUsd = 0;
+
+  const known: Partial<Record<Network, string>> = {};
+  for (const identity of candidate.identities) {
+    if (identity.handle) known[identity.network] = identity.handle;
+  }
+
+  for (const provider of providers) {
+    const capabilities = provider.capabilities();
+    if (!capabilities.canEnrich) continue;
+
+    // Only ask a provider about a network we already hold a handle for.
+    const usable = capabilities.networks.some((network) => known[network]);
+    if (!usable) continue;
+
+    try {
+      const result = await provider.enrich({
+        fullName: candidate.fullName,
+        ...(candidate.companyDomain ? { companyDomain: candidate.companyDomain } : {}),
+        ...(candidate.companyName ? { companyName: candidate.companyName } : {}),
+        handles: known,
+      });
+
+      costUsd += result.costUsd;
+
+      let found = 0;
+      for (const identity of result.candidate?.identities ?? []) {
+        const id = key(identity);
+        if (merged.has(id)) continue;
+        merged.set(id, identity);
+        found += 1;
+      }
+
+      attempts.push({ provider: capabilities.slug, ok: true, found });
+    } catch (error) {
+      attempts.push({
+        provider: capabilities.slug,
+        ok: false,
+        found: 0,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  return {
+    candidate: { ...candidate, identities: [...merged.values()] },
+    attempts,
+    costUsd,
+  };
+}
diff --git a/packages/providers/src/index.ts b/packages/providers/src/index.ts
index b0c0514..59d7e97 100644
--- a/packages/providers/src/index.ts
+++ b/packages/providers/src/index.ts
@@ -54,3 +54,47 @@ export {
 } from './github/provider';
 
 export { extractSignals, type ExtractedSignal, type ExtractionContext } from './github/signals';
+
+export {
+  SiteProvider,
+  normaliseUrl,
+  type CrawlResult,
+  type SiteProviderOptions,
+} from './site/provider';
+
+export {
+  fetchPage,
+  loadRobots,
+  USER_AGENT,
+  type FetchLike,
+  type FetchOptions,
+  type FetchOutcome,
+  type FetchedPage,
+} from './site/fetch';
+
+export {
+  extractCompany,
+  extractPeople,
+  extractSite,
+  networkForUrl,
+  type ExtractedCompany,
+  type SiteExtraction,
+} from './site/extract';
+
+export {
+  extractWithModel,
+  visibleText,
+  type ExtractionModel,
+  type ModelExtraction,
+} from './site/model-extract';
+
+export { isAllowed, parseRobots, type RobotsRules } from './site/robots';
+
+export {
+  BlueskyProvider,
+  BlueskyRateLimitError,
+  BLUESKY_API,
+  type BlueskyProviderOptions,
+} from './bluesky/provider';
+
+export { findIdentities, type FanOutAttempt, type FanOutResult } from './fan-out';
diff --git a/packages/providers/src/site/extract.ts b/packages/providers/src/site/extract.ts
new file mode 100644
index 0000000..8323331
--- /dev/null
+++ b/packages/providers/src/site/extract.ts
@@ -0,0 +1,302 @@
+/**
+ * Deterministic extraction — the first half of the hybrid.
+ *
+ * Everything here reads markup the site published *about itself*: JSON-LD,
+ * OpenGraph, `rel="me"`, outbound links to networks we know. That matters
+ * beyond convenience. The grounding rule says no claim without stored
+ * evidence, and a value lifted from a site's own structured data has evidence
+ * by construction — we can point at the element it came from.
+ *
+ * The model only runs when this finds nothing, so a site with decent markup
+ * never costs a token.
+ */
+
+import type { Network } from '@outreachgraph/domain';
+import type { CandidateIdentity, PersonCandidate } from '../provider';
+
+export interface ExtractedCompany {
+  readonly name?: string;
+  readonly description?: string;
+  readonly domain?: string;
+  readonly location?: string;
+  /** Company-level profiles found on the page, e.g. its own X account. */
+  readonly identities: readonly CandidateIdentity[];
+}
+
+export interface SiteExtraction {
+  readonly company: ExtractedCompany;
+  readonly people: readonly PersonCandidate[];
+  /** Which routes produced something, for the log and for tests. */
+  readonly usedSignals: readonly string[];
+}
+
+/** Hosts that identify a network, longest-first so `x.com` beats a bare match. */
+const NETWORK_HOSTS: readonly (readonly [RegExp, Network])[] = [
+  [/(^|\.)github\.com$/i, 'github'],
+  [/(^|\.)twitter\.com$/i, 'x'],
+  [/(^|\.)x\.com$/i, 'x'],
+  [/(^|\.)bsky\.app$/i, 'bluesky'],
+  [/(^|\.)linkedin\.com$/i, 'linkedin'],
+  [/(^|\.)reddit\.com$/i, 'reddit'],
+  [/(^|\.)youtube\.com$/i, 'youtube'],
+  [/(^|\.)instagram\.com$/i, 'instagram'],
+];
+
+export function networkForUrl(url: string): Network | undefined {
+  try {
+    const host = new URL(url).hostname;
+    return NETWORK_HOSTS.find(([pattern]) => pattern.test(host))?.[1];
+  } catch {
+    return undefined;
+  }
+}
+
+/** `https://github.com/octocat/repo` → `octocat`. */
+function handleFromUrl(url: string): string | undefined {
+  try {
+    const segments = new URL(url).pathname.split('/').filter(Boolean);
+    const first = segments[0];
+    if (!first) return undefined;
+    // Company pages and static sections are not handles.
+    if (/^(company|school|showcase|in|pub|c|channel|user|r)$/i.test(first)) return segments[1];
+    return first;
+  } catch {
+    return undefined;
+  }
+}
+
+function decodeEntities(text: string): string {
+  return text
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#0?39;/g, "'")
+    .replace(/&apos;/g, "'")
+    .replace(/&nbsp;/g, ' ')
+    .replace(/&amp;/g, '&');
+}
+
+function collapse(text: string): string {
+  return decodeEntities(text).replace(/\s+/g, ' ').trim();
+}
+
+/** Every `<script type="application/ld+json">` payload on the page. */
+function jsonLdBlocks(html: string): unknown[] {
+  const blocks: unknown[] = [];
+  const pattern =
+    /<script\b[^>]*type\s*=\s*["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+
+  for (const match of html.matchAll(pattern)) {
+    const body = match[1];
+    if (!body) continue;
+    try {
+      const parsed: unknown = JSON.parse(body.trim());
+      // A page may ship one object, an array, or an @graph wrapper.
+      if (Array.isArray(parsed)) blocks.push(...parsed);
+      else if (parsed && typeof parsed === 'object') {
+        const graph = (parsed as { '@graph'?: unknown })['@graph'];
+        if (Array.isArray(graph)) blocks.push(...graph);
+        else blocks.push(parsed);
+      }
+    } catch {
+      // Malformed JSON-LD is extremely common and is not an error worth
+      // failing a crawl over. The other routes still run.
+    }
+  }
+
+  return blocks;
+}
+
+function typeOf(node: unknown): string[] {
+  if (!node || typeof node !== 'object') return [];
+  const raw = (node as { '@type'?: unknown })['@type'];
+  if (typeof raw === 'string') return [raw];
+  if (Array.isArray(raw)) return raw.filter((t): t is string => typeof t === 'string');
+  return [];
+}
+
+function stringField(node: unknown, field: string): string | undefined {
+  if (!node || typeof node !== 'object') return undefined;
+  const value = (node as Record<string, unknown>)[field];
+  if (typeof value === 'string' && value.trim()) return collapse(value);
+  // schema.org allows a nested object with a name, e.g. an address or a brand.
+  if (value && typeof value === 'object') {
+    const nested = (value as Record<string, unknown>).name;
+    if (typeof nested === 'string' && nested.trim()) return collapse(nested);
+  }
+  return undefined;
+}
+
+function urlList(node: unknown, field: string): string[] {
+  if (!node || typeof node !== 'object') return [];
+  const value = (node as Record<string, unknown>)[field];
+  if (typeof value === 'string') return [value];
+  if (Array.isArray(value)) return value.filter((v): v is string => typeof v === 'string');
+  return [];
+}
+
+function metaContent(html: string, attr: 'property' | 'name', key: string): string | undefined {
+  const pattern = new RegExp(
+    `<meta\\b[^>]*${attr}\\s*=\\s*["']${key}["'][^>]*content\\s*=\\s*["']([^"']*)["']`,
+    'i',
+  );
+  const reversed = new RegExp(
+    `<meta\\b[^>]*content\\s*=\\s*["']([^"']*)["'][^>]*${attr}\\s*=\\s*["']${key}["']`,
+    'i',
+  );
+  const found = html.match(pattern)?.[1] ?? html.match(reversed)?.[1];
+  return found && found.trim() ? collapse(found) : undefined;
+}
+
+/** Outbound links, plus anything the page marked `rel="me"`. */
+function linkedProfiles(html: string): CandidateIdentity[] {
+  const found = new Map<string, CandidateIdentity>();
+
+  for (const match of html.matchAll(/<a\b[^>]*href\s*=\s*["']([^"']+)["'][^>]*>/gi)) {
+    const href = match[1];
+    if (!href) continue;
+    const network = networkForUrl(href);
+    if (!network) continue;
+
+    const handle = handleFromUrl(href);
+    if (!handle) continue;
+
+    const key = `${network}:${handle.toLowerCase()}`;
+    if (found.has(key)) continue;
+
+    found.set(key, {
+      network,
+      handle,
+      profileUrl: href,
+      // A link the site published is a self-declared association, but the page
+      // is the *company's*, so it says less about any individual than a
+      // person's own profile does. The resolver weighs it accordingly.
+      providerConfidence: /rel\s*=\s*["'][^"']*\bme\b/i.test(match[0]) ? 0.9 : 0.6,
+    });
+  }
+
+  return [...found.values()];
+}
+
+function domainOf(url: string): string | undefined {
+  try {
+    return new URL(url).hostname.replace(/^www\./, '');
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Reads what a page says about the organisation behind it.
+ *
+ * Order is by trustworthiness, not convenience: JSON-LD is a deliberate
+ * machine-readable statement, OpenGraph is for social cards and is often the
+ * page title rather than the company, and `<title>` is a last resort.
+ */
+export function extractCompany(html: string, pageUrl: string): ExtractedCompany {
+  const blocks = jsonLdBlocks(html);
+  const org = blocks.find((node) =>
+    typeOf(node).some((t) => /^(Organization|Corporation|LocalBusiness|NGO)$/i.test(t)),
+  );
+
+  const identities = new Map<string, CandidateIdentity>();
+  for (const identity of linkedProfiles(html)) {
+    identities.set(`${identity.network}:${identity.handle?.toLowerCase()}`, identity);
+  }
+
+  // `sameAs` is schema.org's own cross-link field and is the strongest thing a
+  // company page offers about its other profiles.
+  for (const url of urlList(org, 'sameAs')) {
+    const network = networkForUrl(url);
+    const handle = handleFromUrl(url);
+    if (!network || !handle) continue;
+    identities.set(`${network}:${handle.toLowerCase()}`, {
+      network,
+      handle,
+      profileUrl: url,
+      providerConfidence: 0.9,
+    });
+  }
+
+  const name =
+    stringField(org, 'name') ??
+    metaContent(html, 'property', 'og:site_name') ??
+    metaContent(html, 'property', 'og:title') ??
+    collapse(html.match(/<title\b[^>]*>([\s\S]*?)<\/title>/i)?.[1] ?? '') ??
+    undefined;
+
+  const description =
+    stringField(org, 'description') ??
+    metaContent(html, 'property', 'og:description') ??
+    metaContent(html, 'name', 'description');
+
+  const location = stringField(org, 'address');
+
+  return {
+    ...(name ? { name } : {}),
+    ...(description ? { description } : {}),
+    ...(domainOf(pageUrl) ? { domain: domainOf(pageUrl)! } : {}),
+    ...(location ? { location } : {}),
+    identities: [...identities.values()],
+  };
+}
+
+/**
+ * People the page names in structured data.
+ *
+ * Only JSON-LD `Person`, and only entries carrying a name. Guessing at people
+ * from prose is exactly the job handed to the model, and inventing a colleague
+ * from a stray capitalised phrase is worse than finding nobody.
+ */
+export function extractPeople(
+  html: string,
+  pageUrl: string,
+  company: ExtractedCompany,
+): PersonCandidate[] {
+  const observedAt = new Date().toISOString();
+  const people: PersonCandidate[] = [];
+  const seen = new Set<string>();
+
+  for (const node of jsonLdBlocks(html)) {
+    if (!typeOf(node).some((t) => /^Person$/i.test(t))) continue;
+
+    const fullName = stringField(node, 'name');
+    if (!fullName) continue;
+
+    const key = fullName.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+
+    const identities: CandidateIdentity[] = [];
+    for (const url of [...urlList(node, 'sameAs'), ...urlList(node, 'url')]) {
+      const network = networkForUrl(url);
+      const handle = handleFromUrl(url);
+      if (!network || !handle) continue;
+      identities.push({ network, handle, profileUrl: url, providerConfidence: 0.9 });
+    }
+
+    people.push({
+      fullName,
+      ...(stringField(node, 'jobTitle') ? { title: stringField(node, 'jobTitle')! } : {}),
+      ...(company.name ? { companyName: company.name } : {}),
+      ...(company.domain ? { companyDomain: company.domain } : {}),
+      identities,
+      observedAt,
+      sourceRecordId: pageUrl,
+    });
+  }
+
+  return people;
+}
+
+export function extractSite(html: string, pageUrl: string): SiteExtraction {
+  const company = extractCompany(html, pageUrl);
+  const people = extractPeople(html, pageUrl, company);
+
+  const usedSignals: string[] = [];
+  if (jsonLdBlocks(html).length > 0) usedSignals.push('json-ld');
+  if (metaContent(html, 'property', 'og:site_name')) usedSignals.push('opengraph');
+  if (company.identities.length > 0) usedSignals.push('links');
+
+  return { company, people, usedSignals };
+}
diff --git a/packages/providers/src/site/fetch.ts b/packages/providers/src/site/fetch.ts
new file mode 100644
index 0000000..5778923
--- /dev/null
+++ b/packages/providers/src/site/fetch.ts
@@ -0,0 +1,260 @@
+/**
+ * The bounded page fetcher.
+ *
+ * Every limit here exists because the alternative is a worker that a single
+ * hostile or broken URL can hold forever: a redirect loop, a response that
+ * never ends, a host that accepts the connection and then goes quiet.
+ *
+ * The user agent names the product and carries a contact URL. That is the only
+ * way an operator who does not want us can tell us so, and it is the difference
+ * between a crawler and an unattributed scraper.
+ */
+
+import { isAllowed, parseRobots, type RobotsRules } from './robots';
+
+export const USER_AGENT =
+  'OutreachGraphBot/0.1 (+https://outreachgraph.com/bot; research retrieval)';
+
+const MAX_REDIRECTS = 5;
+const MAX_BYTES = 2_000_000;
+const TIMEOUT_MS = 15_000;
+
+export type FetchOutcome =
+  'ok' | 'robots_denied' | 'not_html' | 'too_large' | 'unreachable' | 'http_error';
+
+export interface FetchedPage {
+  readonly outcome: FetchOutcome;
+  /** Where the body actually came from, after redirects. */
+  readonly finalUrl: string;
+  readonly status?: number;
+  readonly html?: string;
+  readonly contentHash?: string;
+  readonly fetchedAt: string;
+  readonly detail?: string;
+  /** What the site asked for between requests, if it said. */
+  readonly crawlDelaySeconds?: number;
+}
+
+/**
+ * Just enough of `fetch` to make the call.
+ *
+ * Not `typeof fetch`: Bun's global carries extras such as `preconnect`, and
+ * requiring those would mean a test stub has to impersonate the runtime rather
+ * than answer a request.
+ */
+export type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+
+export interface FetchOptions {
+  readonly userAgent?: string;
+  readonly maxBytes?: number;
+  readonly timeoutMs?: number;
+  /** Injected in tests; defaults to global fetch. */
+  readonly fetchImpl?: FetchLike;
+  /** Skips the robots round trip when the caller already has the rules. */
+  readonly robots?: RobotsRules;
+}
+
+/** SHA-256 of the body, so an unchanged page can be recognised and skipped. */
+async function hash(text: string): Promise<string> {
+  const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(text));
+  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, '0')).join('');
+}
+
+/**
+ * Reads robots.txt for an origin.
+ *
+ * A missing or unreadable file means "no rules", not "deny everything" — the
+ * overwhelming majority of sites have no robots.txt and every one of them is
+ * fetchable. A 5xx is treated the same way rather than as a temporary block,
+ * which is a deliberate simplification worth revisiting if it ever bites.
+ */
+export async function loadRobots(origin: string, options: FetchOptions = {}): Promise<RobotsRules> {
+  const doFetch = options.fetchImpl ?? fetch;
+  const agent = options.userAgent ?? USER_AGENT;
+
+  try {
+    const response = await doFetch(new URL('/robots.txt', origin).toString(), {
+      headers: { 'user-agent': agent, accept: 'text/plain' },
+      redirect: 'follow',
+      signal: AbortSignal.timeout(options.timeoutMs ?? TIMEOUT_MS),
+    });
+
+    if (!response.ok) return { disallow: [], allow: [] };
+    return parseRobots(await response.text(), agent);
+  } catch {
+    return { disallow: [], allow: [] };
+  }
+}
+
+/**
+ * Fetches one page, or explains why it did not.
+ *
+ * Never throws for an expected refusal. A blocked or unreachable URL is an
+ * outcome the caller records against the batch, not an exception that fails a
+ * hundred other URLs alongside it.
+ */
+export async function fetchPage(url: string, options: FetchOptions = {}): Promise<FetchedPage> {
+  const doFetch = options.fetchImpl ?? fetch;
+  const agent = options.userAgent ?? USER_AGENT;
+  const maxBytes = options.maxBytes ?? MAX_BYTES;
+  const fetchedAt = new Date().toISOString();
+
+  let target: URL;
+  try {
+    target = new URL(url);
+  } catch {
+    return { outcome: 'unreachable', finalUrl: url, fetchedAt, detail: 'not a url' };
+  }
+
+  if (target.protocol !== 'http:' && target.protocol !== 'https:') {
+    return { outcome: 'unreachable', finalUrl: url, fetchedAt, detail: 'unsupported scheme' };
+  }
+
+  const robots = options.robots ?? (await loadRobots(target.origin, options));
+  if (!isAllowed(robots, target.pathname)) {
+    return {
+      outcome: 'robots_denied',
+      finalUrl: target.toString(),
+      fetchedAt,
+      detail: 'robots.txt disallows this path',
+      ...(robots.crawlDelaySeconds === undefined
+        ? {}
+        : { crawlDelaySeconds: robots.crawlDelaySeconds }),
+    };
+  }
+
+  // Redirects are followed by hand so each hop can be re-checked against
+  // robots: a site that allows `/` and denies `/app` should not be crawled at
+  // `/app` merely because `/` redirected there.
+  let current = target;
+  let response: Response | undefined;
+
+  for (let hop = 0; hop <= MAX_REDIRECTS; hop += 1) {
+    try {
+      response = await doFetch(current.toString(), {
+        headers: { 'user-agent': agent, accept: 'text/html,application/xhtml+xml' },
+        redirect: 'manual',
+        signal: AbortSignal.timeout(options.timeoutMs ?? TIMEOUT_MS),
+      });
+    } catch (error) {
+      return {
+        outcome: 'unreachable',
+        finalUrl: current.toString(),
+        fetchedAt,
+        detail: error instanceof Error ? error.message : String(error),
+      };
+    }
+
+    if (response.status < 300 || response.status >= 400) break;
+
+    const location = response.headers.get('location');
+    if (!location) break;
+
+    let next: URL;
+    try {
+      next = new URL(location, current);
+    } catch {
+      return {
+        outcome: 'http_error',
+        finalUrl: current.toString(),
+        fetchedAt,
+        status: response.status,
+      };
+    }
+
+    // A redirect off the origin needs that origin's own robots.
+    const hopRules =
+      next.origin === current.origin ? robots : await loadRobots(next.origin, options);
+    if (!isAllowed(hopRules, next.pathname)) {
+      return {
+        outcome: 'robots_denied',
+        finalUrl: next.toString(),
+        fetchedAt,
+        detail: 'redirect target is disallowed',
+      };
+    }
+
+    current = next;
+
+    if (hop === MAX_REDIRECTS) {
+      return {
+        outcome: 'http_error',
+        finalUrl: current.toString(),
+        fetchedAt,
+        detail: 'too many redirects',
+      };
+    }
+  }
+
+  if (!response) {
+    return { outcome: 'unreachable', finalUrl: current.toString(), fetchedAt };
+  }
+
+  if (!response.ok) {
+    return {
+      outcome: 'http_error',
+      finalUrl: current.toString(),
+      status: response.status,
+      fetchedAt,
+      detail: `http ${response.status}`,
+    };
+  }
+
+  const contentType = response.headers.get('content-type') ?? '';
+  if (contentType && !/text\/html|application\/xhtml\+xml/i.test(contentType)) {
+    return {
+      outcome: 'not_html',
+      finalUrl: current.toString(),
+      status: response.status,
+      fetchedAt,
+      detail: contentType,
+    };
+  }
+
+  // Trust the declared length when it is present and absurd, but do not trust
+  // its absence — the body is measured after reading either way.
+  const declared = Number(response.headers.get('content-length') ?? '0');
+  if (declared > maxBytes) {
+    return {
+      outcome: 'too_large',
+      finalUrl: current.toString(),
+      status: response.status,
+      fetchedAt,
+      detail: `${declared} bytes`,
+    };
+  }
+
+  let html: string;
+  try {
+    html = await response.text();
+  } catch (error) {
+    return {
+      outcome: 'unreachable',
+      finalUrl: current.toString(),
+      fetchedAt,
+      detail: error instanceof Error ? error.message : String(error),
+    };
+  }
+
+  if (html.length > maxBytes) {
+    return {
+      outcome: 'too_large',
+      finalUrl: current.toString(),
+      status: response.status,
+      fetchedAt,
+      detail: `${html.length} bytes`,
+    };
+  }
+
+  return {
+    outcome: 'ok',
+    finalUrl: current.toString(),
+    status: response.status,
+    html,
+    contentHash: await hash(html),
+    fetchedAt,
+    ...(robots.crawlDelaySeconds === undefined
+      ? {}
+      : { crawlDelaySeconds: robots.crawlDelaySeconds }),
+  };
+}
diff --git a/packages/providers/src/site/model-extract.ts b/packages/providers/src/site/model-extract.ts
new file mode 100644
index 0000000..a53488f
--- /dev/null
+++ b/packages/providers/src/site/model-extract.ts
@@ -0,0 +1,173 @@
+/**
+ * The model half of the hybrid.
+ *
+ * Runs only when the deterministic pass found nothing, which keeps a
+ * well-marked-up site free and reserves the token spend for the bespoke
+ * marketing pages that structured parsing cannot read.
+ *
+ * The model is described structurally rather than imported from
+ * `@outreachgraph/ai`, so this package keeps its one rule: providers depend on
+ * `domain` and nothing else. It also means a test can pass a plain object.
+ */
+
+import type { CandidateIdentity, PersonCandidate } from '../provider';
+import { networkForUrl, type ExtractedCompany } from './extract';
+
+/** The subset of `@outreachgraph/ai`'s `TextModel` this needs. */
+export interface ExtractionModel {
+  generate(input: {
+    system: string;
+    user: string;
+    maxTokens?: number;
+  }): Promise<{ text: string; refused: boolean }>;
+}
+
+const SYSTEM = [
+  'You read the visible text of a company web page and report only what it states.',
+  '',
+  'Return one JSON object and nothing else:',
+  '{"company":{"name":string|null,"description":string|null},',
+  ' "people":[{"fullName":string,"title":string|null,"profileUrl":string|null}]}',
+  '',
+  'Rules:',
+  '- Report only what the page states outright. Never infer, guess or complete a name.',
+  '- A person needs a full personal name printed on the page. Never invent one,',
+  '  and never turn a team, department, role or product into a person.',
+  '- If the page names nobody, return an empty people array. That is a correct answer.',
+  '- Never use knowledge from outside the page.',
+].join('\n');
+
+/** Strips markup, script and style so the model sees the page's prose. */
+export function visibleText(html: string, maxChars = 12_000): string {
+  const text = html
+    .replace(/<script\b[\s\S]*?<\/script>/gi, ' ')
+    .replace(/<style\b[\s\S]*?<\/style>/gi, ' ')
+    .replace(/<noscript\b[\s\S]*?<\/noscript>/gi, ' ')
+    .replace(/<!--[\s\S]*?-->/g, ' ')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/&nbsp;/g, ' ')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/\s+/g, ' ')
+    .trim();
+
+  return text.slice(0, maxChars);
+}
+
+/**
+ * Pulls the JSON object out of a model reply.
+ *
+ * Models wrap JSON in prose or fences often enough that demanding a bare object
+ * would fail on answers that are otherwise correct.
+ */
+function parseReply(text: string): unknown {
+  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i)?.[1];
+  const candidate = (fenced ?? text).trim();
+
+  const start = candidate.indexOf('{');
+  const end = candidate.lastIndexOf('}');
+  if (start < 0 || end <= start) return undefined;
+
+  try {
+    return JSON.parse(candidate.slice(start, end + 1));
+  } catch {
+    return undefined;
+  }
+}
+
+export interface ModelExtraction {
+  readonly company: { readonly name?: string; readonly description?: string };
+  readonly people: readonly PersonCandidate[];
+}
+
+const EMPTY: ModelExtraction = { company: {}, people: [] };
+
+/**
+ * Asks the model what the page says.
+ *
+ * Every failure mode returns empty rather than throwing: a refusal, an
+ * unparseable reply, a model outage. None of those should fail a crawl whose
+ * deterministic half may already have produced a usable company.
+ */
+export async function extractWithModel(
+  model: ExtractionModel,
+  html: string,
+  pageUrl: string,
+  company: ExtractedCompany,
+): Promise<ModelExtraction> {
+  const text = visibleText(html);
+  if (!text) return EMPTY;
+
+  let reply: { text: string; refused: boolean };
+  try {
+    reply = await model.generate({
+      system: SYSTEM,
+      user: `Page URL: ${pageUrl}\n\nPage text:\n${text}`,
+      maxTokens: 1200,
+    });
+  } catch {
+    return EMPTY;
+  }
+
+  if (reply.refused) return EMPTY;
+
+  const parsed = parseReply(reply.text);
+  if (!parsed || typeof parsed !== 'object') return EMPTY;
+
+  const root = parsed as {
+    company?: { name?: unknown; description?: unknown };
+    people?: unknown;
+  };
+
+  const observedAt = new Date().toISOString();
+  const people: PersonCandidate[] = [];
+
+  if (Array.isArray(root.people)) {
+    for (const entry of root.people) {
+      if (!entry || typeof entry !== 'object') continue;
+      const record = entry as { fullName?: unknown; title?: unknown; profileUrl?: unknown };
+
+      const fullName = typeof record.fullName === 'string' ? record.fullName.trim() : '';
+      // Two words minimum. A single token is a first name, a handle or a
+      // department, and none of those is a person we can responsibly research.
+      if (!fullName || fullName.split(/\s+/).length < 2 || fullName.length > 120) continue;
+
+      const identities: CandidateIdentity[] = [];
+      if (typeof record.profileUrl === 'string') {
+        const network = networkForUrl(record.profileUrl);
+        if (network) {
+          identities.push({
+            network,
+            profileUrl: record.profileUrl,
+            // Lower than a structured-data link on purpose: a model repeating a
+            // URL from prose is weaker evidence than the site declaring it.
+            providerConfidence: 0.5,
+          });
+        }
+      }
+
+      people.push({
+        fullName,
+        ...(typeof record.title === 'string' && record.title.trim()
+          ? { title: record.title.trim() }
+          : {}),
+        ...(company.name ? { companyName: company.name } : {}),
+        ...(company.domain ? { companyDomain: company.domain } : {}),
+        identities,
+        observedAt,
+        sourceRecordId: pageUrl,
+      });
+    }
+  }
+
+  const name = typeof root.company?.name === 'string' ? root.company.name.trim() : undefined;
+  const description =
+    typeof root.company?.description === 'string' ? root.company.description.trim() : undefined;
+
+  return {
+    company: { ...(name ? { name } : {}), ...(description ? { description } : {}) },
+    people,
+  };
+}
diff --git a/packages/providers/src/site/provider.ts b/packages/providers/src/site/provider.ts
new file mode 100644
index 0000000..d7da7b1
--- /dev/null
+++ b/packages/providers/src/site/provider.ts
@@ -0,0 +1,168 @@
+/**
+ * A company web page as a source (PRD §10.1; `website/observe` in the
+ * capability matrix, "permitted public web retrieval").
+ *
+ * Hybrid by design. The deterministic pass reads what a site published about
+ * itself and costs nothing; the model runs only where that came back empty.
+ * Most sites with any structured data never reach the model at all, and the
+ * ones that do are exactly the bespoke marketing pages parsing cannot read.
+ */
+
+import type {
+  PersonCandidate,
+  PersonEnrichmentInput,
+  PersonEnrichmentProvider,
+  PersonEnrichmentResult,
+  PersonSearchInput,
+  PersonSearchResult,
+  ProviderCapabilities,
+} from '../provider';
+import { fetchPage, type FetchOptions, type FetchOutcome, type FetchedPage } from './fetch';
+import { extractSite, type ExtractedCompany } from './extract';
+import { extractWithModel, type ExtractionModel } from './model-extract';
+
+export interface SiteProviderOptions extends FetchOptions {
+  /** Omit to run deterministic-only; the crawl still works, it just reads less. */
+  readonly model?: ExtractionModel;
+}
+
+export interface CrawlResult {
+  readonly url: string;
+  readonly finalUrl: string;
+  readonly outcome: FetchOutcome;
+  readonly company: ExtractedCompany;
+  readonly people: readonly PersonCandidate[];
+  /** Which halves contributed: `json-ld`, `opengraph`, `links`, `model`. */
+  readonly usedSignals: readonly string[];
+  readonly contentHash?: string;
+  readonly fetchedAt: string;
+  readonly detail?: string;
+}
+
+function emptyCompany(): ExtractedCompany {
+  return { identities: [] };
+}
+
+export class SiteProvider implements PersonEnrichmentProvider {
+  readonly #options: SiteProviderOptions;
+
+  constructor(options: SiteProviderOptions = {}) {
+    this.#options = options;
+  }
+
+  capabilities(): ProviderCapabilities {
+    return {
+      slug: 'site',
+      displayName: 'Company website',
+      networks: ['website', 'x', 'github', 'bluesky', 'linkedin'],
+      // There is nothing to search: this provider answers about a URL you
+      // already have. Discovery is the enrichment vendors' job.
+      canSearch: false,
+      canEnrich: true,
+      licenseClass: 'public_web',
+      sourceType: 'public_web',
+      // Free apart from the model fallback, so the waterfall reaches it early.
+      costPerEnrichmentUsd: 0,
+    };
+  }
+
+  async search(_input: PersonSearchInput): Promise<PersonSearchResult> {
+    return { candidates: [], costUsd: 0 };
+  }
+
+  /**
+   * Enriches from a company domain.
+   *
+   * Returns the first named person as the candidate, because the interface is
+   * one-candidate-shaped. `crawl` is the honest entry point for a URL that may
+   * name several people, and it is what the pipeline calls.
+   */
+  async enrich(input: PersonEnrichmentInput): Promise<PersonEnrichmentResult> {
+    const target = input.companyDomain ?? input.profileUrls?.[0];
+    if (!target) return { matchConfidence: 0, costUsd: 0 };
+
+    const result = await this.crawl(normaliseUrl(target));
+    const candidate = result.people[0];
+
+    if (!candidate) return { matchConfidence: 0, costUsd: 0 };
+    return { candidate, matchConfidence: 0.6, costUsd: 0 };
+  }
+
+  async costEstimate(_input: PersonSearchInput | PersonEnrichmentInput): Promise<number> {
+    return 0;
+  }
+
+  /**
+   * Fetches one page and reads it.
+   *
+   * A refusal — robots, a 404, a PDF — is a result, not an exception. One bad
+   * URL in a batch of a hundred must not take the other ninety-nine with it.
+   */
+  async crawl(url: string): Promise<CrawlResult> {
+    const page: FetchedPage = await fetchPage(url, this.#options);
+
+    if (page.outcome !== 'ok' || !page.html) {
+      return {
+        url,
+        finalUrl: page.finalUrl,
+        outcome: page.outcome,
+        company: emptyCompany(),
+        people: [],
+        usedSignals: [],
+        fetchedAt: page.fetchedAt,
+        ...(page.detail ? { detail: page.detail } : {}),
+      };
+    }
+
+    const deterministic = extractSite(page.html, page.finalUrl);
+    const usedSignals = [...deterministic.usedSignals];
+
+    let company = deterministic.company;
+    let people = [...deterministic.people];
+
+    // The hybrid's hinge. The model is asked only for what parsing missed, so a
+    // page with JSON-LD people never pays for it — and a page whose only claim
+    // to a company name was its <title> can still get a better one.
+    const needsPeople = people.length === 0;
+    const needsName = !company.name;
+
+    if (this.#options.model && (needsPeople || needsName)) {
+      const fromModel = await extractWithModel(
+        this.#options.model,
+        page.html,
+        page.finalUrl,
+        company,
+      );
+
+      if (needsName && fromModel.company.name) {
+        company = { ...company, name: fromModel.company.name };
+      }
+      if (!company.description && fromModel.company.description) {
+        company = { ...company, description: fromModel.company.description };
+      }
+      if (needsPeople && fromModel.people.length > 0) {
+        people = [...fromModel.people];
+      }
+
+      if (fromModel.company.name || fromModel.people.length > 0) usedSignals.push('model');
+    }
+
+    return {
+      url,
+      finalUrl: page.finalUrl,
+      outcome: 'ok',
+      company,
+      people,
+      usedSignals,
+      ...(page.contentHash ? { contentHash: page.contentHash } : {}),
+      fetchedAt: page.fetchedAt,
+    };
+  }
+}
+
+/** `example.com` and `https://example.com/` both mean the same thing here. */
+export function normaliseUrl(input: string): string {
+  const trimmed = input.trim();
+  if (/^https?:\/\//i.test(trimmed)) return trimmed;
+  return `https://${trimmed.replace(/^\/+/, '')}`;
+}
diff --git a/packages/providers/src/site/robots.ts b/packages/providers/src/site/robots.ts
new file mode 100644
index 0000000..ed4e29e
--- /dev/null
+++ b/packages/providers/src/site/robots.ts
@@ -0,0 +1,129 @@
+/**
+ * robots.txt, read the way a well-behaved crawler reads it.
+ *
+ * This is not politeness theatre. The policy engine permits `website/observe`
+ * as "permitted public web retrieval", and what makes a retrieval permitted is
+ * partly that the site said it was. A crawler that ignores robots is how a
+ * research tool becomes an abuse report.
+ *
+ * Deliberately small: only the directives that decide whether one URL may be
+ * fetched. No sitemap discovery, no wildcards beyond `*` and `$`, which is what
+ * the original specification defines and what almost every file actually uses.
+ */
+
+export interface RobotsRules {
+  /** Path prefixes this agent must not fetch. */
+  readonly disallow: readonly string[];
+  /** Prefixes that override a broader disallow. */
+  readonly allow: readonly string[];
+  /** Seconds the site asked callers to wait between requests. */
+  readonly crawlDelaySeconds?: number;
+}
+
+const EMPTY: RobotsRules = { disallow: [], allow: [] };
+
+/**
+ * Parses robots.txt for one user-agent.
+ *
+ * A group naming our agent wins outright; otherwise the `*` group applies. That
+ * is the precedence the specification describes, and it matters: a site that
+ * blocks everyone but allows us has said something specific, and a site that
+ * blocks us specifically has said something even more specific.
+ */
+export function parseRobots(text: string, userAgent: string): RobotsRules {
+  const wanted = userAgent.toLowerCase();
+
+  const groups: { agents: string[]; disallow: string[]; allow: string[]; delay?: number }[] = [];
+  let current: (typeof groups)[number] | undefined;
+  // Consecutive `User-agent` lines share one group; a rule line closes the run.
+  let collectingAgents = false;
+
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.split('#')[0]?.trim() ?? '';
+    if (!line) continue;
+
+    const separator = line.indexOf(':');
+    if (separator < 0) continue;
+
+    const field = line.slice(0, separator).trim().toLowerCase();
+    const value = line.slice(separator + 1).trim();
+
+    if (field === 'user-agent') {
+      if (!collectingAgents || !current) {
+        current = { agents: [], disallow: [], allow: [] };
+        groups.push(current);
+        collectingAgents = true;
+      }
+      current.agents.push(value.toLowerCase());
+      continue;
+    }
+
+    if (!current) continue;
+    collectingAgents = false;
+
+    if (field === 'disallow') current.disallow.push(value);
+    else if (field === 'allow') current.allow.push(value);
+    else if (field === 'crawl-delay') {
+      const delay = Number(value);
+      if (Number.isFinite(delay) && delay >= 0) current.delay = delay;
+    }
+  }
+
+  const named = groups.find((group) =>
+    group.agents.some((agent) => agent !== '*' && wanted.includes(agent)),
+  );
+  const wildcard = groups.find((group) => group.agents.includes('*'));
+  const chosen = named ?? wildcard;
+
+  if (!chosen) return EMPTY;
+
+  return {
+    // An empty `Disallow:` means "nothing is disallowed" and must not be read
+    // as the prefix that matches every path.
+    disallow: chosen.disallow.filter((rule) => rule !== ''),
+    allow: chosen.allow.filter((rule) => rule !== ''),
+    ...(chosen.delay === undefined ? {} : { crawlDelaySeconds: chosen.delay }),
+  };
+}
+
+function matches(rule: string, path: string): boolean {
+  const anchored = rule.endsWith('$');
+  const pattern = anchored ? rule.slice(0, -1) : rule;
+  const segments = pattern.split('*');
+
+  let index = 0;
+  for (let i = 0; i < segments.length; i += 1) {
+    const segment = segments[i]!;
+    if (segment === '') continue;
+
+    const found = i === 0 ? (path.startsWith(segment) ? 0 : -1) : path.indexOf(segment, index);
+    if (found < 0) return false;
+    index = found + segment.length;
+  }
+
+  // `$` means the rule has to consume the path to its end.
+  if (anchored && index !== path.length) return false;
+  return true;
+}
+
+/**
+ * Whether one path may be fetched.
+ *
+ * The longest matching rule wins, and a tie goes to `Allow` — both are what the
+ * specification says, and together they are what lets a site disallow a whole
+ * tree while opening one page inside it.
+ */
+export function isAllowed(rules: RobotsRules, path: string): boolean {
+  let bestAllow = -1;
+  let bestDisallow = -1;
+
+  for (const rule of rules.allow) {
+    if (matches(rule, path)) bestAllow = Math.max(bestAllow, rule.length);
+  }
+  for (const rule of rules.disallow) {
+    if (matches(rule, path)) bestDisallow = Math.max(bestDisallow, rule.length);
+  }
+
+  if (bestDisallow < 0) return true;
+  return bestAllow >= bestDisallow;
+}
diff --git a/packages/providers/src/site/site.test.ts b/packages/providers/src/site/site.test.ts
new file mode 100644
index 0000000..31e155e
--- /dev/null
+++ b/packages/providers/src/site/site.test.ts
@@ -0,0 +1,388 @@
+import { describe, expect, test } from 'bun:test';
+import { isAllowed, parseRobots } from './robots';
+import { fetchPage, USER_AGENT } from './fetch';
+import { extractCompany, extractPeople, extractSite, networkForUrl } from './extract';
+import { extractWithModel, visibleText, type ExtractionModel } from './model-extract';
+import { SiteProvider, normaliseUrl } from './provider';
+
+/** A fetch stand-in that answers from a map of url → response. */
+function stubFetch(routes: Record<string, { body: string; status?: number; type?: string }>) {
+  return async (input: string | URL | Request): Promise<Response> => {
+    const url = typeof input === 'string' ? input : input.toString();
+    const route = routes[url];
+    if (!route) return new Response('not found', { status: 404 });
+    return new Response(route.body, {
+      status: route.status ?? 200,
+      headers: { 'content-type': route.type ?? 'text/html' },
+    });
+  };
+}
+
+describe('robots', () => {
+  test('a group naming our agent beats the wildcard group', () => {
+    const rules = parseRobots(
+      [
+        'User-agent: *',
+        'Disallow: /',
+        '',
+        'User-agent: OutreachGraphBot',
+        'Disallow: /private',
+      ].join('\n'),
+      'OutreachGraphBot/0.1',
+    );
+
+    expect(isAllowed(rules, '/about')).toBe(true);
+    expect(isAllowed(rules, '/private/x')).toBe(false);
+  });
+
+  test('an empty Disallow means nothing is disallowed', () => {
+    const rules = parseRobots('User-agent: *\nDisallow:', 'OutreachGraphBot/0.1');
+    // The bug this guards: treating '' as a prefix would match every path and
+    // silently refuse to crawl the entire web.
+    expect(isAllowed(rules, '/anything')).toBe(true);
+  });
+
+  test('a longer Allow overrides a broader Disallow', () => {
+    const rules = parseRobots(
+      'User-agent: *\nDisallow: /team\nAllow: /team/about',
+      'OutreachGraphBot/0.1',
+    );
+
+    expect(isAllowed(rules, '/team/list')).toBe(false);
+    expect(isAllowed(rules, '/team/about')).toBe(true);
+  });
+
+  test('wildcards and end-anchors are honoured', () => {
+    const rules = parseRobots('User-agent: *\nDisallow: /*.pdf$', 'OutreachGraphBot/0.1');
+
+    expect(isAllowed(rules, '/docs/report.pdf')).toBe(false);
+    expect(isAllowed(rules, '/docs/report.pdf.html')).toBe(true);
+  });
+
+  test('consecutive user-agent lines share one group', () => {
+    const rules = parseRobots(
+      'User-agent: Googlebot\nUser-agent: *\nDisallow: /nope',
+      'OutreachGraphBot/0.1',
+    );
+
+    expect(isAllowed(rules, '/nope')).toBe(false);
+  });
+
+  test('crawl-delay is carried through', () => {
+    const rules = parseRobots('User-agent: *\nCrawl-delay: 4', 'OutreachGraphBot/0.1');
+    expect(rules.crawlDelaySeconds).toBe(4);
+  });
+});
+
+describe('fetchPage', () => {
+  test('a disallowed path is refused without fetching it', async () => {
+    let pageRequested = false;
+    const fetchImpl = async (input: string | URL | Request): Promise<Response> => {
+      const url = input.toString();
+      if (url.endsWith('/robots.txt')) {
+        return new Response('User-agent: *\nDisallow: /', {
+          headers: { 'content-type': 'text/plain' },
+        });
+      }
+      pageRequested = true;
+      return new Response('<html></html>');
+    };
+
+    const page = await fetchPage('https://example.com/', { fetchImpl });
+
+    expect(page.outcome).toBe('robots_denied');
+    expect(pageRequested).toBe(false);
+  });
+
+  test('a non-html response is reported rather than parsed', async () => {
+    const page = await fetchPage('https://example.com/', {
+      fetchImpl: stubFetch({
+        'https://example.com/robots.txt': { body: '', type: 'text/plain' },
+        'https://example.com/': { body: '%PDF-1.4', type: 'application/pdf' },
+      }),
+    });
+
+    expect(page.outcome).toBe('not_html');
+  });
+
+  test('an oversized body is rejected', async () => {
+    const page = await fetchPage('https://example.com/', {
+      maxBytes: 50,
+      fetchImpl: stubFetch({
+        'https://example.com/robots.txt': { body: '', type: 'text/plain' },
+        'https://example.com/': { body: '<html>' + 'x'.repeat(500) + '</html>' },
+      }),
+    });
+
+    expect(page.outcome).toBe('too_large');
+  });
+
+  test('the user agent names the product and how to reach us', () => {
+    expect(USER_AGENT).toContain('OutreachGraphBot');
+    expect(USER_AGENT).toContain('https://');
+  });
+
+  test('the same body hashes the same, so an unchanged page is recognisable', async () => {
+    const routes = {
+      'https://example.com/robots.txt': { body: '', type: 'text/plain' },
+      'https://example.com/': { body: '<html><title>Loopwright</title></html>' },
+    };
+
+    const first = await fetchPage('https://example.com/', { fetchImpl: stubFetch(routes) });
+    const second = await fetchPage('https://example.com/', { fetchImpl: stubFetch(routes) });
+
+    expect(first.contentHash).toBe(second.contentHash!);
+    expect(first.contentHash).toHaveLength(64);
+  });
+});
+
+describe('deterministic extraction', () => {
+  const HTML = `
+    <html><head>
+      <title>Loopwright — agent reliability</title>
+      <meta property="og:site_name" content="Loopwright" />
+      <meta name="description" content="Reliability tooling for agent teams." />
+      <script type="application/ld+json">
+        {"@context":"https://schema.org","@type":"Organization","name":"Loopwright",
+         "description":"Reliability tooling for agent teams.",
+         "sameAs":["https://github.com/loopwright","https://x.com/loopwright"]}
+      </script>
+      <script type="application/ld+json">
+        {"@type":"Person","name":"Alex Chen","jobTitle":"Staff Engineer",
+         "sameAs":["https://github.com/alexchen"]}
+      </script>
+    </head><body>
+      <a rel="me" href="https://bsky.app/profile/loopwright.io">bluesky</a>
+    </body></html>`;
+
+  test('the organisation is read from JSON-LD, not the page title', () => {
+    const company = extractCompany(HTML, 'https://loopwright.io/');
+
+    // <title> says "Loopwright — agent reliability"; the structured statement
+    // is the company's actual name and has to win.
+    expect(company.name).toBe('Loopwright');
+    expect(company.domain).toBe('loopwright.io');
+    expect(company.description).toContain('Reliability tooling');
+  });
+
+  test('sameAs and rel=me both become identities', () => {
+    const company = extractCompany(HTML, 'https://loopwright.io/');
+    const networks = company.identities.map((i) => i.network).sort();
+
+    expect(networks).toContain('github');
+    expect(networks).toContain('x');
+    expect(networks).toContain('bluesky');
+  });
+
+  test('a JSON-LD person carries their title and company', () => {
+    const company = extractCompany(HTML, 'https://loopwright.io/');
+    const people = extractPeople(HTML, 'https://loopwright.io/', company);
+
+    expect(people).toHaveLength(1);
+    expect(people[0]!.fullName).toBe('Alex Chen');
+    expect(people[0]!.title).toBe('Staff Engineer');
+    expect(people[0]!.companyName).toBe('Loopwright');
+    expect(people[0]!.identities[0]!.handle).toBe('alexchen');
+  });
+
+  test('an @graph wrapper is unwrapped', () => {
+    const html = `<script type="application/ld+json">
+      {"@graph":[{"@type":"Organization","name":"Graphed Co"}]}</script>`;
+
+    expect(extractCompany(html, 'https://graphed.co/').name).toBe('Graphed Co');
+  });
+
+  test('malformed JSON-LD does not stop the other routes', () => {
+    const html = `<html><head>
+      <script type="application/ld+json">{ not json at all </script>
+      <meta property="og:site_name" content="Still Here" />
+    </head></html>`;
+
+    expect(extractCompany(html, 'https://x.example/').name).toBe('Still Here');
+  });
+
+  test('a linkedin company path yields the company slug, not the word company', () => {
+    expect(networkForUrl('https://www.linkedin.com/company/loopwright')).toBe('linkedin');
+    const company = extractCompany(
+      '<a href="https://www.linkedin.com/company/loopwright">li</a>',
+      'https://loopwright.io/',
+    );
+    expect(company.identities[0]!.handle).toBe('loopwright');
+  });
+
+  test('a page with no structured data names nobody', () => {
+    const result = extractSite('<html><body><p>We are a team.</p></body></html>', 'https://a.io/');
+    expect(result.people).toHaveLength(0);
+  });
+});
+
+describe('model extraction', () => {
+  function modelReturning(text: string, refused = false): ExtractionModel {
+    return { generate: async () => ({ text, refused }) };
+  }
+
+  test('visible text drops script, style and markup', () => {
+    const text = visibleText(
+      '<html><style>a{color:red}</style><script>var x=1</script><p>Hello&nbsp;world</p></html>',
+    );
+
+    expect(text).toBe('Hello world');
+  });
+
+  test('a fenced JSON reply is parsed', async () => {
+    const model = modelReturning(
+      '```json\n{"company":{"name":"Bespoke Co"},"people":[{"fullName":"Dana Reed","title":"CTO"}]}\n```',
+    );
+
+    const result = await extractWithModel(model, '<p>text</p>', 'https://b.co/', {
+      identities: [],
+      domain: 'b.co',
+    });
+
+    expect(result.company.name).toBe('Bespoke Co');
+    expect(result.people[0]!.fullName).toBe('Dana Reed');
+    expect(result.people[0]!.companyDomain).toBe('b.co');
+  });
+
+  test('a single-word name is discarded', async () => {
+    const model = modelReturning(
+      '{"people":[{"fullName":"Engineering"},{"fullName":"Ada Byron"}]}',
+    );
+
+    const result = await extractWithModel(model, '<p>x</p>', 'https://b.co/', { identities: [] });
+
+    // "Engineering" is a department. Turning it into a prospect would put a
+    // fabricated human into the approval queue.
+    expect(result.people.map((p) => p.fullName)).toEqual(['Ada Byron']);
+  });
+
+  test('a refusal yields nothing rather than throwing', async () => {
+    const result = await extractWithModel(modelReturning('no', true), '<p>x</p>', 'https://b.co/', {
+      identities: [],
+    });
+
+    expect(result.people).toHaveLength(0);
+    expect(result.company.name).toBeUndefined();
+  });
+
+  test('an unparseable reply yields nothing rather than throwing', async () => {
+    const result = await extractWithModel(
+      modelReturning('I am unable to find any JSON here'),
+      '<p>x</p>',
+      'https://b.co/',
+      { identities: [] },
+    );
+
+    expect(result.people).toHaveLength(0);
+  });
+
+  test('a thrown model error does not fail the crawl', async () => {
+    const model: ExtractionModel = {
+      generate: async () => {
+        throw new Error('api down');
+      },
+    };
+
+    const result = await extractWithModel(model, '<p>x</p>', 'https://b.co/', { identities: [] });
+    expect(result.people).toHaveLength(0);
+  });
+});
+
+describe('SiteProvider', () => {
+  const ROBOTS = { body: '', type: 'text/plain' };
+
+  test('a well-marked-up page never reaches the model', async () => {
+    let modelCalls = 0;
+    const model: ExtractionModel = {
+      generate: async () => {
+        modelCalls += 1;
+        return { text: '{}', refused: false };
+      },
+    };
+
+    const provider = new SiteProvider({
+      model,
+      fetchImpl: stubFetch({
+        'https://loop.io/robots.txt': ROBOTS,
+        'https://loop.io/': {
+          body: `<script type="application/ld+json">
+            {"@type":"Organization","name":"Loop"}</script>
+            <script type="application/ld+json">
+            {"@type":"Person","name":"Alex Chen"}</script>`,
+        },
+      }),
+    });
+
+    const result = await provider.crawl('https://loop.io/');
+
+    expect(result.company.name).toBe('Loop');
+    expect(result.people).toHaveLength(1);
+    // The whole economic argument for the hybrid: structured data is free.
+    expect(modelCalls).toBe(0);
+    expect(result.usedSignals).not.toContain('model');
+  });
+
+  test('a bespoke page falls through to the model', async () => {
+    const model: ExtractionModel = {
+      generate: async () => ({
+        text: '{"company":{"name":"Handmade Ltd"},"people":[{"fullName":"Sam Rivers","title":"Founder"}]}',
+        refused: false,
+      }),
+    };
+
+    const provider = new SiteProvider({
+      model,
+      fetchImpl: stubFetch({
+        'https://handmade.example/robots.txt': ROBOTS,
+        'https://handmade.example/': {
+          body: '<html><body><h1>We build things</h1><p>Sam Rivers, Founder</p></body></html>',
+        },
+      }),
+    });
+
+    const result = await provider.crawl('https://handmade.example/');
+
+    expect(result.company.name).toBe('Handmade Ltd');
+    expect(result.people[0]!.fullName).toBe('Sam Rivers');
+    expect(result.usedSignals).toContain('model');
+  });
+
+  test('without a model it degrades to deterministic-only', async () => {
+    const provider = new SiteProvider({
+      fetchImpl: stubFetch({
+        'https://plain.example/robots.txt': ROBOTS,
+        'https://plain.example/': { body: '<html><body><p>Nothing structured</p></body></html>' },
+      }),
+    });
+
+    const result = await provider.crawl('https://plain.example/');
+
+    expect(result.outcome).toBe('ok');
+    expect(result.people).toHaveLength(0);
+  });
+
+  test('a blocked page is a result, not a throw', async () => {
+    const provider = new SiteProvider({
+      fetchImpl: stubFetch({
+        'https://blocked.example/robots.txt': {
+          body: 'User-agent: *\nDisallow: /',
+          type: 'text/plain',
+        },
+      }),
+    });
+
+    const result = await provider.crawl('https://blocked.example/');
+
+    expect(result.outcome).toBe('robots_denied');
+    expect(result.people).toHaveLength(0);
+  });
+
+  test('a bare domain is normalised to https', () => {
+    expect(normaliseUrl('example.com')).toBe('https://example.com');
+    expect(normaliseUrl('http://example.com')).toBe('http://example.com');
+  });
+
+  test('it does not claim it can search', () => {
+    expect(new SiteProvider().capabilities().canSearch).toBe(false);
+  });
+});