diff --git a/apps/api/src/app.ts b/apps/api/src/app.ts
index 23f34ca..15dd76a 100644
--- a/apps/api/src/app.ts
+++ b/apps/api/src/app.ts
@@ -19,6 +19,7 @@ import {
   privacyRequestSchema,
   registerSchema,
   snoozeRecommendationSchema,
+  workspaceProfileSchema,
 } from '@outreachgraph/contracts';
 import { newId, type ActionKind, type Network } from '@outreachgraph/domain';
 import { now, queryOne, type Client } from '@outreachgraph/db';
@@ -37,12 +38,13 @@ import {
   workspacesForUser,
 } from './auth';
 import { evaluatePolicy, isExecutable, POLICY_VERSION } from '@outreachgraph/policy';
-import { draftForRecommendation, type TextModel } from '@outreachgraph/ai';
+import { draftForRecommendation, draftProfile, type TextModel } from '@outreachgraph/ai';
 import { batchStatus, enqueue, runPipeline } from '@outreachgraph/pipeline';
-import { GitHubProvider, normaliseUrl } from '@outreachgraph/providers';
+import { GitHubProvider, SiteProvider, 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';
+import { loadWorkspaceProfile, saveWorkspaceProfile } from './workspace-profile';
 
 /** One paste, one reviewable unit of work. */
 const MAX_BULK_URLS = 100;
@@ -71,6 +73,8 @@ export interface AppOptions {
    * inject a fake; production leaves it unset and gets the real client.
    */
   readonly github?: GitHubProvider;
+  /** Reads the customer's own site during onboarding. Tests inject a fake. */
+  readonly site?: SiteProvider;
   /**
    * Sends account email. Omit to log messages instead of sending them, which
    * is what local development and the test suite do.
@@ -396,6 +400,125 @@ export function createApp(options: AppOptions): Hono<AppEnv> {
     });
   });
 
+  // ---------------------------------------------------------- onboarding
+  /**
+   * Reads your own site and drafts your profile (PRD §7, §11).
+   *
+   * The mirror image of the crawler that reads a prospect's site: the page
+   * belongs to the person signing up, and what comes back describes their
+   * business rather than a lead — what they sell, who plausibly buys it, how
+   * they write, and where those buyers are active.
+   *
+   * Nothing is saved here. The reply is a draft to correct, because it is a
+   * model's reading of a marketing page and not a fact about someone's company.
+   * `PUT` is what commits it.
+   *
+   * Verified email is required before the model runs. An unverified signup is
+   * an unattributed one, and this is the first route where a stranger can spend
+   * our tokens.
+   */
+  api.post('/onboarding/profile', async (c) => {
+    const actor = c.get('actor');
+    const db = c.get('db');
+
+    if (!canApprove(actor)) throw ApiError.forbidden('setting up the workspace');
+    await requireVerifiedEmail(db, actor, 'we read your site');
+
+    if (!options.model) {
+      throw new ApiError(
+        503,
+        'composer_unavailable',
+        'no language model is configured; fill the profile in by hand for now',
+      );
+    }
+
+    const raw = safeJson(await c.req.raw.text());
+    if (typeof raw.url !== 'string' || !raw.url.trim()) {
+      throw ApiError.badRequest('enter your website address', { url: ['required'] });
+    }
+
+    let target: URL;
+    try {
+      target = new URL(normaliseUrl(raw.url));
+    } catch {
+      throw ApiError.badRequest('that does not look like a web address', { url: ['invalid'] });
+    }
+
+    const page = await (options.site ?? new SiteProvider()).crawl(target.toString());
+    if (page.outcome !== 'ok') {
+      // The site's own answer, phrased for the person who owns it.
+      const why =
+        page.outcome === 'robots_denied'
+          ? 'your robots.txt blocks us from reading it'
+          : `we could not read it (${page.outcome})`;
+      throw ApiError.badRequest(`we could not read ${target.hostname}: ${why}`, {
+        url: [page.outcome],
+      });
+    }
+
+    const result = await draftProfile(options.model, page.pageText ?? '', page.finalUrl);
+    if (!result.ok || !result.draft) {
+      throw new ApiError(502, 'profile_draft_failed', result.reason ?? 'could not draft a profile');
+    }
+
+    await repo.audit(db, {
+      workspaceId: actor.workspaceId,
+      actorKind: 'user',
+      actorId: actor.userId,
+      eventType: 'onboarding.profile_drafted',
+      entityKind: 'workspace',
+      entityId: actor.workspaceId,
+      detail: { url: page.finalUrl },
+    });
+
+    return c.json({
+      url: page.finalUrl,
+      companyName: page.company.name,
+      draft: result.draft,
+    });
+  });
+
+  /**
+   * Commits the profile the person confirmed.
+   *
+   * Takes the edited draft rather than re-reading the site: what is saved has
+   * to be what they approved, and re-running the model here would quietly
+   * replace their corrections with a fresh guess.
+   */
+  api.put('/onboarding/profile', async (c) => {
+    const actor = c.get('actor');
+    const db = c.get('db');
+
+    if (!canApprove(actor)) throw ApiError.forbidden('setting up the workspace');
+
+    const raw = safeJson(await c.req.raw.text());
+    const parsed = workspaceProfileSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw ApiError.badRequest('that profile is incomplete', parsed.error.flatten().fieldErrors);
+    }
+
+    const saved = await saveWorkspaceProfile(db, actor.workspaceId, parsed.data);
+
+    await repo.audit(db, {
+      workspaceId: actor.workspaceId,
+      actorKind: 'user',
+      actorId: actor.userId,
+      eventType: 'onboarding.profile_saved',
+      entityKind: 'offering',
+      entityId: saved.offeringId,
+      detail: { name: parsed.data.offering.name },
+    });
+
+    return c.json({ saved: true, ...saved });
+  });
+
+  /** What the workspace currently believes about itself. */
+  api.get('/onboarding/profile', async (c) => {
+    const actor = c.get('actor');
+    const profile = await loadWorkspaceProfile(c.get('db'), actor.workspaceId);
+    return c.json(profile);
+  });
+
   // ------------------------------------------------------------ by url
   /**
    * Adds prospects from company URLs (PRD §8, URL-first intake).
@@ -1164,11 +1287,15 @@ function numberOr(value: unknown, fallback: number): number {
  * A service token has no user, so this cannot apply to it; machine callers
  * are authorised by holding the token.
  */
-async function requireVerifiedEmail(db: Client, actor: RequestActor): Promise<void> {
+async function requireVerifiedEmail(
+  db: Client,
+  actor: RequestActor,
+  action = 'sending anything',
+): Promise<void> {
   if (actor.userId === 'usr_service') return;
   if (await isEmailVerified(db, actor.userId)) return;
 
-  throw new ApiError(403, 'email_unverified', 'confirm your email address before sending anything');
+  throw new ApiError(403, 'email_unverified', `confirm your email address before ${action}`);
 }
 
 /**
diff --git a/apps/api/src/onboarding.test.ts b/apps/api/src/onboarding.test.ts
new file mode 100644
index 0000000..a843b6d
--- /dev/null
+++ b/apps/api/src/onboarding.test.ts
@@ -0,0 +1,274 @@
+import { afterEach, describe, expect, test } from 'bun:test';
+import type { Hono } from 'hono';
+import { StubModel } from '@outreachgraph/ai';
+import { SiteProvider, type FetchLike } from '@outreachgraph/providers';
+import { queryOne } 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;
+});
+
+const SITE_HTML = `<html><head><title>Loopwright</title></head><body>
+  <h1>Reliability tooling for agent teams</h1>
+  <p>Catch agent regressions before your customers do.</p>
+</body></html>`;
+
+function stubNetwork(html = SITE_HTML): FetchLike {
+  return async (input) =>
+    input.toString().endsWith('/robots.txt')
+      ? new Response('', { headers: { 'content-type': 'text/plain' } })
+      : new Response(html, { headers: { 'content-type': 'text/html' } });
+}
+
+const GOOD_DRAFT = JSON.stringify({
+  offering: {
+    name: 'Loopwright',
+    category: 'developer tooling',
+    description: 'Reliability tooling for agent teams.',
+    valuePropositions: ['Catch regressions early'],
+    likelyPains: ['Agents fail silently in production'],
+    competitors: [],
+  },
+  icp: {
+    titles: ['Staff Engineer', 'Head of Platform'],
+    seniorities: ['senior'],
+    industries: ['software'],
+    technologies: ['python'],
+    keywords: ['agent reliability'],
+    exclusions: ['students'],
+  },
+  voice: { style: 'direct and technical', instructions: 'no hype', maxWords: 120 },
+  whereToFind: ['GitHub issues on agent frameworks — people describe failures there.'],
+});
+
+async function harness(
+  label: string,
+  options: { actor?: RequestActor | null; model?: StubModel; verified?: boolean } = {},
+): Promise<{ app: Hono<AppEnv>; seeded: SeededDatabase }> {
+  const seeded = await seedDatabase(label);
+  active = seeded;
+
+  if (options.verified === false) {
+    await seeded.db.execute({
+      sql: 'UPDATE users SET email_verified_at = NULL WHERE id = ?',
+      args: [SEED.userId],
+    });
+  }
+
+  const app = createApp({
+    db: seeded.db,
+    authenticate: async () => options.actor ?? (options.actor === null ? undefined : ACTOR),
+    site: new SiteProvider({ fetchImpl: stubNetwork() }),
+    ...(options.model ? { model: options.model } : {}),
+  });
+
+  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),
+  });
+}
+
+async function put(app: Hono<AppEnv>, path: string, body: unknown): Promise<Response> {
+  return app.request(`/api/v1${path}`, {
+    method: 'PUT',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+}
+
+describe('POST /onboarding/profile', () => {
+  test('an unverified email cannot spend a model call', async () => {
+    const model = new StubModel(GOOD_DRAFT);
+    const { app } = await harness('onboard-unverified', { model, verified: false });
+
+    const response = await post(app, '/onboarding/profile', { url: 'loopwright.io' });
+
+    expect(response.status).toBe(403);
+    expect((await response.json()).error.code).toBe('email_unverified');
+    // The gate has to sit in front of the spend, not merely in front of the
+    // reply: an unverified signup that still burned a call would be an open
+    // invitation to do it a thousand times.
+    expect(model.calls).toHaveLength(0);
+  });
+
+  test('a verified caller gets a draft back', async () => {
+    const model = new StubModel(GOOD_DRAFT);
+    const { app } = await harness('onboard-draft', { model });
+
+    const response = await post(app, '/onboarding/profile', { url: 'loopwright.io' });
+    const body = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(body.draft.offering.name).toBe('Loopwright');
+    expect(body.draft.icp.titles).toContain('Staff Engineer');
+    expect(body.draft.whereToFind.length).toBeGreaterThan(0);
+  });
+
+  test('nothing is written until the draft is confirmed', async () => {
+    const model = new StubModel(GOOD_DRAFT);
+    const { app, seeded } = await harness('onboard-no-write', { model });
+
+    await post(app, '/onboarding/profile', { url: 'loopwright.io' });
+
+    const offering = await queryOne<{ name: string }>(
+      seeded.db,
+      'SELECT name FROM offerings WHERE workspace_id = ? ORDER BY created_at LIMIT 1',
+      [SEED.workspaceId],
+    );
+
+    // A model's reading of a marketing page is a suggestion. Adopting it
+    // silently would ground every later draft in something nobody checked.
+    expect(offering?.name).not.toBe('Loopwright');
+  });
+
+  test('without a model configured it says so rather than failing opaquely', async () => {
+    const { app } = await harness('onboard-nomodel');
+
+    const response = await post(app, '/onboarding/profile', { url: 'loopwright.io' });
+    expect(response.status).toBe(503);
+    expect((await response.json()).error.message).toContain('by hand');
+  });
+
+  test('a site we cannot read is explained in terms of the site', async () => {
+    const model = new StubModel(GOOD_DRAFT);
+    const seeded = await seedDatabase('onboard-blocked');
+    active = seeded;
+
+    const app = createApp({
+      db: seeded.db,
+      authenticate: async () => ACTOR,
+      model,
+      site: new SiteProvider({
+        fetchImpl: async (input) =>
+          input.toString().endsWith('/robots.txt')
+            ? new Response('User-agent: *\nDisallow: /', {
+                headers: { 'content-type': 'text/plain' },
+              })
+            : new Response('<html></html>'),
+      }),
+    });
+
+    const response = await post(app, '/onboarding/profile', { url: 'loopwright.io' });
+    expect(response.status).toBe(400);
+    expect((await response.json()).error.message).toContain('robots.txt');
+  });
+
+  test('an unparseable model reply is a 502, not a saved profile', async () => {
+    const model = new StubModel('I am not JSON');
+    const { app } = await harness('onboard-badreply', { model });
+
+    const response = await post(app, '/onboarding/profile', { url: 'loopwright.io' });
+    expect(response.status).toBe(502);
+  });
+});
+
+describe('PUT /onboarding/profile', () => {
+  const PROFILE = {
+    url: 'https://loopwright.io',
+    offering: {
+      name: 'Loopwright',
+      category: 'developer tooling',
+      description: 'Reliability tooling.',
+      valuePropositions: ['Catch regressions'],
+      likelyPains: ['Silent failures'],
+      competitors: [],
+    },
+    icp: {
+      titles: ['Staff Engineer'],
+      seniorities: [],
+      industries: ['software'],
+      technologies: [],
+      keywords: ['agent reliability'],
+      exclusions: [],
+    },
+    voice: { style: 'direct', instructions: 'no hype', maxWords: 120 },
+  };
+
+  test('a confirmed profile replaces the placeholder offering', async () => {
+    const { app, seeded } = await harness('onboard-save');
+
+    const response = await put(app, '/onboarding/profile', PROFILE);
+    expect(response.status).toBe(200);
+
+    const offering = await queryOne<{ name: string; likely_pains: string }>(
+      seeded.db,
+      'SELECT name, likely_pains FROM offerings WHERE workspace_id = ? ORDER BY created_at LIMIT 1',
+      [SEED.workspaceId],
+    );
+
+    expect(offering?.name).toBe('Loopwright');
+    expect(offering?.likely_pains).toContain('Silent failures');
+  });
+
+  test('the ICP lands on the campaign the pipeline actually reads', async () => {
+    const { app, seeded } = await harness('onboard-filters');
+
+    await put(app, '/onboarding/profile', PROFILE);
+
+    const filters = await queryOne<{ titles: string; keywords: string }>(
+      seeded.db,
+      `SELECT f.titles, f.keywords FROM campaign_filters f
+         JOIN campaigns c ON c.id = f.campaign_id
+        WHERE c.workspace_id = ? LIMIT 1`,
+      [SEED.workspaceId],
+    );
+
+    expect(filters?.titles).toContain('Staff Engineer');
+    expect(filters?.keywords).toContain('agent reliability');
+  });
+
+  test('saving twice corrects the profile rather than creating a rival', async () => {
+    const { app, seeded } = await harness('onboard-twice');
+
+    await put(app, '/onboarding/profile', PROFILE);
+    await put(app, '/onboarding/profile', {
+      ...PROFILE,
+      offering: { ...PROFILE.offering, name: 'Loopwright v2' },
+    });
+
+    const rows = await seeded.db.execute({
+      sql: 'SELECT COUNT(*) AS n FROM offerings WHERE workspace_id = ?',
+      args: [SEED.workspaceId],
+    });
+
+    expect(Number(rows.rows[0]!.n)).toBe(1);
+  });
+
+  test('an incomplete profile is rejected', async () => {
+    const { app } = await harness('onboard-invalid');
+
+    const response = await put(app, '/onboarding/profile', { offering: { name: '' } });
+    expect(response.status).toBe(400);
+  });
+
+  test('GET reports an unconfigured workspace as unconfigured', async () => {
+    const { app } = await harness('onboard-get');
+
+    const before = await (await app.request('/api/v1/onboarding/profile')).json();
+    expect(before.configured).toBe(false);
+
+    await put(app, '/onboarding/profile', PROFILE);
+
+    const after = await (await app.request('/api/v1/onboarding/profile')).json();
+    expect(after.configured).toBe(true);
+    expect(after.offering.name).toBe('Loopwright');
+  });
+});
diff --git a/apps/api/src/workspace-profile.ts b/apps/api/src/workspace-profile.ts
new file mode 100644
index 0000000..1849121
--- /dev/null
+++ b/apps/api/src/workspace-profile.ts
@@ -0,0 +1,267 @@
+/**
+ * The workspace's own profile: what you sell, who buys it, how you write.
+ *
+ * Three tables that already existed and nothing ever filled — `offerings`,
+ * `campaign_filters` and `voice_profiles`. Until now the only thing writing
+ * them was the test seed, and the default campaign bootstrapped an offering
+ * named "Your offering" with placeholder text that every draft was then
+ * grounded in.
+ *
+ * Upserts rather than inserts throughout: this is a setup step people re-run
+ * after changing their site or getting the ICP wrong the first time, and a
+ * second run must correct the profile rather than create a rival one.
+ */
+
+import { newId } from '@outreachgraph/domain';
+import { now, queryOne, type Client } from '@outreachgraph/db';
+import type { WorkspaceProfile } from '@outreachgraph/contracts';
+
+export interface SavedProfile {
+  readonly offeringId: string;
+  readonly voiceProfileId: string;
+  readonly campaignId: string;
+}
+
+/** JSON columns hold arrays; this keeps the encoding in one place. */
+function list(values: readonly string[] | undefined): string {
+  return JSON.stringify(values ?? []);
+}
+
+function parseList(value: unknown): string[] {
+  if (typeof value !== 'string') return [];
+  try {
+    const parsed: unknown = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((v): v is string => typeof v === 'string') : [];
+  } catch {
+    return [];
+  }
+}
+
+export async function saveWorkspaceProfile(
+  db: Client,
+  workspaceId: string,
+  profile: WorkspaceProfile,
+): Promise<SavedProfile> {
+  const stamp = now();
+
+  const existingOffering = await queryOne<{ id: string }>(
+    db,
+    'SELECT id FROM offerings WHERE workspace_id = ? ORDER BY created_at ASC LIMIT 1',
+    [workspaceId],
+  );
+
+  const offeringId = existingOffering?.id ?? newId('offering');
+
+  if (existingOffering) {
+    await db.execute({
+      sql: `UPDATE offerings SET name = ?, category = ?, url = ?, description = ?,
+              value_propositions = ?, likely_pains = ?, competitors = ?, updated_at = ?
+             WHERE id = ?`,
+      args: [
+        profile.offering.name,
+        profile.offering.category,
+        profile.url ?? null,
+        profile.offering.description ?? null,
+        list(profile.offering.valuePropositions),
+        list(profile.offering.likelyPains),
+        list(profile.offering.competitors),
+        stamp,
+        offeringId,
+      ],
+    });
+  } else {
+    await db.execute({
+      sql: `INSERT INTO offerings (id, workspace_id, name, category, url, description,
+              value_propositions, likely_pains, competitors, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        offeringId,
+        workspaceId,
+        profile.offering.name,
+        profile.offering.category,
+        profile.url ?? null,
+        profile.offering.description ?? null,
+        list(profile.offering.valuePropositions),
+        list(profile.offering.likelyPains),
+        list(profile.offering.competitors),
+        stamp,
+        stamp,
+      ],
+    });
+  }
+
+  const existingVoice = await queryOne<{ id: string }>(
+    db,
+    'SELECT id FROM voice_profiles WHERE workspace_id = ? ORDER BY created_at ASC LIMIT 1',
+    [workspaceId],
+  );
+
+  const voiceProfileId = existingVoice?.id ?? newId('voiceProfile');
+
+  if (existingVoice) {
+    await db.execute({
+      sql: `UPDATE voice_profiles SET style = ?, instructions = ?, max_words = ?, updated_at = ?
+             WHERE id = ?`,
+      args: [
+        profile.voice.style,
+        profile.voice.instructions ?? null,
+        profile.voice.maxWords ?? null,
+        stamp,
+        voiceProfileId,
+      ],
+    });
+  } else {
+    await db.execute({
+      sql: `INSERT INTO voice_profiles (id, workspace_id, name, style, instructions, max_words,
+              created_at, updated_at)
+            VALUES (?, ?, 'Default', ?, ?, ?, ?, ?)`,
+      args: [
+        voiceProfileId,
+        workspaceId,
+        profile.voice.style,
+        profile.voice.instructions ?? null,
+        profile.voice.maxWords ?? null,
+        stamp,
+        stamp,
+      ],
+    });
+  }
+
+  // The campaign is what joins the three together, and it is what the pipeline
+  // reads. A workspace whose profile is set but whose campaign still points at
+  // the placeholder offering would draft against text nobody wrote.
+  const existingCampaign = await queryOne<{ id: string }>(
+    db,
+    `SELECT id FROM campaigns WHERE workspace_id = ?
+      ORDER BY CASE status WHEN 'active' THEN 0 ELSE 1 END, created_at ASC LIMIT 1`,
+    [workspaceId],
+  );
+
+  const campaignId = existingCampaign?.id ?? newId('campaign');
+
+  if (existingCampaign) {
+    await db.execute({
+      sql: `UPDATE campaigns SET offering_id = ?, voice_profile_id = ?, updated_at = ? WHERE id = ?`,
+      args: [offeringId, voiceProfileId, stamp, campaignId],
+    });
+  } else {
+    await db.execute({
+      sql: `INSERT INTO campaigns (id, workspace_id, name, offering_id, voice_profile_id,
+              approval_mode, status, created_at, updated_at, started_at)
+            VALUES (?, ?, 'First campaign', ?, ?, 'draft_and_approve', 'active', ?, ?, ?)`,
+      args: [campaignId, workspaceId, offeringId, voiceProfileId, stamp, stamp, stamp],
+    });
+  }
+
+  await db.execute({
+    sql: `INSERT INTO campaign_filters (campaign_id, titles, seniorities, industries,
+            technologies, keywords, exclusions, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+          ON CONFLICT(campaign_id) DO UPDATE SET
+            titles = excluded.titles, seniorities = excluded.seniorities,
+            industries = excluded.industries, technologies = excluded.technologies,
+            keywords = excluded.keywords, exclusions = excluded.exclusions,
+            updated_at = excluded.updated_at`,
+    args: [
+      campaignId,
+      list(profile.icp.titles),
+      list(profile.icp.seniorities),
+      list(profile.icp.industries),
+      list(profile.icp.technologies),
+      list(profile.icp.keywords),
+      list(profile.icp.exclusions),
+      stamp,
+    ],
+  });
+
+  return { offeringId, voiceProfileId, campaignId };
+}
+
+export interface LoadedProfile {
+  readonly configured: boolean;
+  readonly url?: string;
+  readonly offering?: WorkspaceProfile['offering'];
+  readonly icp?: WorkspaceProfile['icp'];
+  readonly voice?: WorkspaceProfile['voice'];
+}
+
+export async function loadWorkspaceProfile(
+  db: Client,
+  workspaceId: string,
+): Promise<LoadedProfile> {
+  const offering = await queryOne<{
+    id: string;
+    name: string;
+    category: string;
+    url: string | null;
+    description: string | null;
+    value_propositions: string;
+    likely_pains: string;
+    competitors: string;
+  }>(
+    db,
+    `SELECT id, name, category, url, description, value_propositions, likely_pains, competitors
+       FROM offerings WHERE workspace_id = ? ORDER BY created_at ASC LIMIT 1`,
+    [workspaceId],
+  );
+
+  const voice = await queryOne<{
+    style: string;
+    instructions: string | null;
+    max_words: number | null;
+  }>(
+    db,
+    `SELECT style, instructions, max_words FROM voice_profiles
+       WHERE workspace_id = ? ORDER BY created_at ASC LIMIT 1`,
+    [workspaceId],
+  );
+
+  // A voice profile is the signal, because only completing setup creates one —
+  // the campaign bootstrap writes a placeholder offering but never a voice.
+  // Keying off the offering instead meant comparing its name to the literal
+  // string "Your offering", which is the kind of check that silently stops
+  // working the day somebody edits the bootstrap copy.
+  if (!offering || !voice) return { configured: false };
+
+  const filters = await queryOne<{
+    titles: string;
+    seniorities: string;
+    industries: string;
+    technologies: string;
+    keywords: string;
+    exclusions: string;
+  }>(
+    db,
+    `SELECT f.titles, f.seniorities, f.industries, f.technologies, f.keywords, f.exclusions
+       FROM campaign_filters f
+       JOIN campaigns c ON c.id = f.campaign_id
+      WHERE c.workspace_id = ? ORDER BY c.created_at ASC LIMIT 1`,
+    [workspaceId],
+  );
+
+  return {
+    configured: true,
+    ...(offering.url ? { url: offering.url } : {}),
+    offering: {
+      name: offering.name,
+      category: offering.category,
+      ...(offering.description ? { description: offering.description } : {}),
+      valuePropositions: parseList(offering.value_propositions),
+      likelyPains: parseList(offering.likely_pains),
+      competitors: parseList(offering.competitors),
+    },
+    icp: {
+      titles: parseList(filters?.titles),
+      seniorities: parseList(filters?.seniorities),
+      industries: parseList(filters?.industries),
+      technologies: parseList(filters?.technologies),
+      keywords: parseList(filters?.keywords),
+      exclusions: parseList(filters?.exclusions),
+    },
+    voice: {
+      style: voice.style,
+      ...(voice.instructions ? { instructions: voice.instructions } : {}),
+      ...(voice.max_words ? { maxWords: voice.max_words } : {}),
+    },
+  };
+}
diff --git a/apps/web/app/(app)/setup/page.tsx b/apps/web/app/(app)/setup/page.tsx
new file mode 100644
index 0000000..c52a5d5
--- /dev/null
+++ b/apps/web/app/(app)/setup/page.tsx
@@ -0,0 +1,65 @@
+import { redirect } from 'next/navigation';
+import { ProfileSetup } from '../../../components/profile-setup';
+import {
+  ApiUnavailableError,
+  NotAuthenticatedError,
+  fetchMe,
+  fetchProfile,
+} from '../../../lib/api';
+
+export const dynamic = 'force-dynamic';
+
+export const metadata = { title: 'Set up · OutreachGraph' };
+
+/**
+ * The setup step (PRD §7, §11).
+ *
+ * Everything downstream is grounded in what this page collects: the composer
+ * writes from the offering, the scorer ranks against the ICP. Until it is
+ * filled in, the workspace is pointed at a placeholder offering that reads
+ * "Describe what you sell here" — which is what every draft would quote.
+ */
+export default async function SetupPage() {
+  let me;
+  let profile;
+  let offline = false;
+
+  try {
+    [me, profile] = await Promise.all([fetchMe(), fetchProfile()]);
+  } catch (error) {
+    if (error instanceof NotAuthenticatedError) redirect('/login');
+    if (error instanceof ApiUnavailableError) offline = true;
+    else throw error;
+  }
+
+  const verified = me?.emailVerified ?? false;
+
+  return (
+    <div className="pt-4">
+      <header className="mb-5">
+        <h1 className="text-xl font-semibold">Set up your profile</h1>
+        <p className="text-ink-muted mt-1 text-sm">
+          {profile?.configured
+            ? `Currently set to “${profile.offering?.name}”. Reading your site again replaces it.`
+            : 'Outreach is only as good as what we know about you. This takes a minute.'}
+        </p>
+      </header>
+
+      {offline ? (
+        <p className="border-border text-ink-muted rounded-2xl border border-dashed p-8 text-center text-sm">
+          Waiting for the API.
+        </p>
+      ) : !verified ? (
+        // Reading a site costs a model call, and an unverified signup is an
+        // unattributed one. The gate is enforced by the API; this explains it
+        // rather than letting the button fail with a 403.
+        <p className="border-border bg-surface-raised rounded-2xl border p-4 text-sm">
+          Confirm your email address first — we check it before running anything that costs money.
+          The link is in your inbox.
+        </p>
+      ) : (
+        <ProfileSetup {...(profile?.url ? { initialUrl: profile.url } : {})} />
+      )}
+    </div>
+  );
+}
diff --git a/apps/web/app/(app)/today/page.tsx b/apps/web/app/(app)/today/page.tsx
index 25468b5..2122d5b 100644
--- a/apps/web/app/(app)/today/page.tsx
+++ b/apps/web/app/(app)/today/page.tsx
@@ -6,6 +6,7 @@ import {
   NotAuthenticatedError,
   fetchApprovals,
   fetchMe,
+  fetchProfile,
   fetchSignals,
   relativeTime,
 } from '../../../lib/api';
@@ -24,10 +25,16 @@ export default async function TodayPage() {
   let approvals: Awaited<ReturnType<typeof fetchApprovals>> = [];
   let signals: Awaited<ReturnType<typeof fetchSignals>> = [];
   let me: Awaited<ReturnType<typeof fetchMe>> | undefined;
+  let profile: Awaited<ReturnType<typeof fetchProfile>> | undefined;
   let offline = false;
 
   try {
-    [approvals, signals, me] = await Promise.all([fetchApprovals(), fetchSignals(), fetchMe()]);
+    [approvals, signals, me, profile] = await Promise.all([
+      fetchApprovals(),
+      fetchSignals(),
+      fetchMe(),
+      fetchProfile(),
+    ]);
   } catch (error) {
     if (error instanceof NotAuthenticatedError) redirect('/login');
     if (error instanceof ApiUnavailableError) offline = true;
@@ -40,6 +47,21 @@ export default async function TodayPage() {
     <div className="pt-4">
       {me && !me.emailVerified ? <VerifyBanner email={me.user.email} /> : null}
 
+      {/* Until this is done every draft is grounded in placeholder text, so it
+          is worth interrupting for once rather than hiding in a settings page. */}
+      {me?.emailVerified && profile && !profile.configured ? (
+        <Link
+          href="/setup"
+          className="border-accent/40 bg-accent/5 mb-4 block rounded-2xl border p-4"
+        >
+          <span className="text-sm font-medium">Tell us what you sell</span>
+          <span className="text-ink-muted mt-1 block text-[13px] leading-relaxed">
+            Paste your website and we will draft your profile — what you sell, who buys it, and
+            where to find them. Outreach is grounded in it.
+          </span>
+        </Link>
+      ) : null}
+
       <header className="mb-5">
         <h1 className="text-xl font-semibold">Today</h1>
         <p className="text-ink-muted text-sm">
diff --git a/apps/web/components/profile-setup.tsx b/apps/web/components/profile-setup.tsx
new file mode 100644
index 0000000..e6cd5d9
--- /dev/null
+++ b/apps/web/components/profile-setup.tsx
@@ -0,0 +1,321 @@
+'use client';
+
+import { useRouter } from 'next/navigation';
+import { useState, type FormEvent } from 'react';
+
+/**
+ * Setup: paste your own site, get a profile back, correct it, save it.
+ *
+ * Deliberately a review step rather than a save. What comes back is a model's
+ * reading of a marketing page — a good starting point and not a fact about
+ * somebody's business — so it is shown as editable fields and nothing is
+ * written until the person presses save. The alternative, silently adopting
+ * whatever the model said, means every draft afterwards is grounded in a guess
+ * nobody checked.
+ */
+
+interface Draft {
+  offering: {
+    name: string;
+    category: string;
+    description: string;
+    valuePropositions: string[];
+    likelyPains: string[];
+    competitors: string[];
+  };
+  icp: {
+    titles: string[];
+    seniorities: string[];
+    industries: string[];
+    technologies: string[];
+    keywords: string[];
+    exclusions: string[];
+  };
+  voice: { style: string; instructions: string; maxWords: number };
+  whereToFind: string[];
+}
+
+const lines = (values: string[]) => values.join('\n');
+const parseLines = (value: string) =>
+  value
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean);
+
+export function ProfileSetup({ initialUrl }: { initialUrl?: string }) {
+  const router = useRouter();
+  const [url, setUrl] = useState(initialUrl ?? '');
+  const [busy, setBusy] = useState(false);
+  const [saving, setSaving] = useState(false);
+  const [error, setError] = useState<string | undefined>();
+  const [draft, setDraft] = useState<Draft | undefined>();
+  const [saved, setSaved] = useState(false);
+
+  async function read(event: FormEvent) {
+    event.preventDefault();
+    if (!url.trim()) return;
+
+    setBusy(true);
+    setError(undefined);
+    setSaved(false);
+
+    try {
+      const response = await fetch('/api/v1/onboarding/profile', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        credentials: 'same-origin',
+        body: JSON.stringify({ url }),
+      });
+
+      const payload = await response.json().catch(() => ({}));
+
+      if (!response.ok) {
+        setError(payload?.error?.message ?? `that failed (${response.status})`);
+        return;
+      }
+
+      setDraft(payload.draft as Draft);
+    } catch {
+      setError('could not reach the server');
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  async function save() {
+    if (!draft) return;
+    setSaving(true);
+    setError(undefined);
+
+    try {
+      const response = await fetch('/api/v1/onboarding/profile', {
+        method: 'PUT',
+        headers: { 'content-type': 'application/json' },
+        credentials: 'same-origin',
+        body: JSON.stringify({
+          url,
+          offering: draft.offering,
+          icp: draft.icp,
+          voice: draft.voice,
+        }),
+      });
+
+      const payload = await response.json().catch(() => ({}));
+
+      if (!response.ok) {
+        setError(payload?.error?.message ?? `that failed (${response.status})`);
+        return;
+      }
+
+      setSaved(true);
+      router.refresh();
+    } catch {
+      setError('could not reach the server');
+    } finally {
+      setSaving(false);
+    }
+  }
+
+  function edit(patch: Partial<Draft>) {
+    if (!draft) return;
+    setDraft({ ...draft, ...patch });
+  }
+
+  return (
+    <div className="flex flex-col gap-4">
+      <form onSubmit={read} className="border-border bg-surface-raised rounded-2xl border p-4">
+        <label htmlFor="site" className="text-sm font-medium">
+          Your website
+        </label>
+        <p className="text-ink-muted mt-1 text-xs">
+          We read your homepage and draft a profile: what you sell, who buys it, and how you write.
+          You get to correct all of it before anything is saved.
+        </p>
+
+        <div className="mt-3 flex gap-2">
+          <input
+            id="site"
+            value={url}
+            onChange={(e) => setUrl(e.target.value)}
+            placeholder="yourcompany.com"
+            autoCapitalize="none"
+            autoCorrect="off"
+            spellCheck={false}
+            className="border-border bg-surface min-w-0 flex-1 rounded-xl border px-3 py-3"
+          />
+          <button
+            type="submit"
+            disabled={busy || !url.trim()}
+            className="bg-accent shrink-0 rounded-xl px-4 text-sm font-medium text-white disabled:opacity-40"
+          >
+            {busy ? 'Reading…' : 'Read my site'}
+          </button>
+        </div>
+
+        {error ? (
+          <p role="alert" className="text-hot mt-3 text-sm">
+            {error}
+          </p>
+        ) : null}
+      </form>
+
+      {draft ? (
+        <div className="border-border bg-surface-raised flex flex-col gap-5 rounded-2xl border p-4">
+          <Field
+            label="What you sell"
+            hint="Every message is grounded in this. Vague text here makes vague outreach."
+            value={draft.offering.name}
+            onChange={(name) => edit({ offering: { ...draft.offering, name } })}
+          />
+
+          <TextArea
+            label="Description"
+            value={draft.offering.description}
+            rows={3}
+            onChange={(description) => edit({ offering: { ...draft.offering, description } })}
+          />
+
+          <ListField
+            label="Problems your buyer has"
+            hint="In their words, not yours."
+            values={draft.offering.likelyPains}
+            onChange={(likelyPains) => edit({ offering: { ...draft.offering, likelyPains } })}
+          />
+
+          <ListField
+            label="Job titles to target"
+            values={draft.icp.titles}
+            onChange={(titles) => edit({ icp: { ...draft.icp, titles } })}
+          />
+
+          <ListField
+            label="Industries"
+            values={draft.icp.industries}
+            onChange={(industries) => edit({ icp: { ...draft.icp, industries } })}
+          />
+
+          <ListField
+            label="Keywords that signal a fit"
+            hint="What these people say when they have the problem you solve."
+            values={draft.icp.keywords}
+            onChange={(keywords) => edit({ icp: { ...draft.icp, keywords } })}
+          />
+
+          <ListField
+            label="Never target"
+            values={draft.icp.exclusions}
+            onChange={(exclusions) => edit({ icp: { ...draft.icp, exclusions } })}
+          />
+
+          <Field
+            label="How you write"
+            value={draft.voice.style}
+            onChange={(style) => edit({ voice: { ...draft.voice, style } })}
+          />
+
+          {draft.whereToFind.length > 0 ? (
+            <div>
+              <span className="text-sm font-medium">Where these people are</span>
+              <p className="text-ink-muted mt-1 text-xs">
+                Suggestions to act on yourself — we do not search these yet.
+              </p>
+              <ul className="mt-2 flex flex-col gap-1.5">
+                {draft.whereToFind.map((entry) => (
+                  <li key={entry} className="text-ink-muted text-[13px] leading-relaxed">
+                    {entry}
+                  </li>
+                ))}
+              </ul>
+            </div>
+          ) : null}
+
+          <div className="flex items-center gap-3">
+            <button
+              type="button"
+              onClick={() => void save()}
+              disabled={saving || !draft.offering.name.trim()}
+              className="bg-accent shrink-0 rounded-xl px-4 text-sm font-medium text-white disabled:opacity-40"
+            >
+              {saving ? 'Saving…' : 'Save profile'}
+            </button>
+            {saved ? <span className="text-good text-sm">Saved.</span> : null}
+          </div>
+        </div>
+      ) : null}
+    </div>
+  );
+}
+
+function Field({
+  label,
+  hint,
+  value,
+  onChange,
+}: {
+  label: string;
+  hint?: string;
+  value: string;
+  onChange: (value: string) => void;
+}) {
+  return (
+    <label className="flex flex-col gap-1">
+      <span className="text-sm font-medium">{label}</span>
+      {hint ? <span className="text-ink-muted text-xs">{hint}</span> : null}
+      <input
+        value={value}
+        onChange={(e) => onChange(e.target.value)}
+        className="border-border bg-surface mt-1 rounded-xl border px-3 py-3"
+      />
+    </label>
+  );
+}
+
+function TextArea({
+  label,
+  value,
+  rows,
+  onChange,
+}: {
+  label: string;
+  value: string;
+  rows: number;
+  onChange: (value: string) => void;
+}) {
+  return (
+    <label className="flex flex-col gap-1">
+      <span className="text-sm font-medium">{label}</span>
+      <textarea
+        value={value}
+        rows={rows}
+        onChange={(e) => onChange(e.target.value)}
+        className="border-border bg-surface mt-1 rounded-xl border px-3 py-3 text-[15px]"
+      />
+    </label>
+  );
+}
+
+/** One per line. A textarea beats tag chips for correcting a list of twelve. */
+function ListField({
+  label,
+  hint,
+  values,
+  onChange,
+}: {
+  label: string;
+  hint?: string;
+  values: string[];
+  onChange: (values: string[]) => void;
+}) {
+  return (
+    <label className="flex flex-col gap-1">
+      <span className="text-sm font-medium">{label}</span>
+      <span className="text-ink-muted text-xs">{hint ? `${hint} ` : ''}One per line.</span>
+      <textarea
+        value={lines(values)}
+        rows={Math.min(Math.max(values.length + 1, 2), 8)}
+        onChange={(e) => onChange(parseLines(e.target.value))}
+        className="border-border bg-surface mt-1 rounded-xl border px-3 py-3 font-mono text-[13px]"
+      />
+    </label>
+  );
+}
diff --git a/apps/web/lib/api.ts b/apps/web/lib/api.ts
index 8e873c1..ddbc1e5 100644
--- a/apps/web/lib/api.ts
+++ b/apps/web/lib/api.ts
@@ -92,6 +92,17 @@ export async function fetchMe(): Promise<CurrentUser> {
   return request<CurrentUser>('/auth/me');
 }
 
+/** What the workspace believes about itself, for the setup page. */
+export interface WorkspaceProfileView {
+  readonly configured: boolean;
+  readonly url?: string;
+  readonly offering?: { readonly name: string; readonly category: string };
+}
+
+export async function fetchProfile(): Promise<WorkspaceProfileView> {
+  return request<WorkspaceProfileView>('/onboarding/profile');
+}
+
 export async function fetchApprovals(): Promise<ApprovalCard[]> {
   const body = await request<{ recommendations: ApprovalCard[] }>('/recommendations?limit=50');
   return body.recommendations;
diff --git a/packages/ai/src/index.ts b/packages/ai/src/index.ts
index 2f1fb4b..8dc5077 100644
--- a/packages/ai/src/index.ts
+++ b/packages/ai/src/index.ts
@@ -39,3 +39,5 @@ export {
 } from './composer';
 
 export { draftForRecommendation, type DraftResult } from './draft';
+
+export { draftProfile, type ProfileDraft, type ProfileDraftResult } from './profile';
diff --git a/packages/ai/src/profile.ts b/packages/ai/src/profile.ts
new file mode 100644
index 0000000..0f161e8
--- /dev/null
+++ b/packages/ai/src/profile.ts
@@ -0,0 +1,178 @@
+/**
+ * Reading your own site to draft your profile (PRD §7 offerings, §11 targeting).
+ *
+ * This is the mirror image of the crawler that reads a *prospect's* site. Here
+ * the page belongs to the person signing up, and what comes out is not a lead
+ * but a description of their business: what they sell, who plausibly buys it,
+ * and how they write.
+ *
+ * The output is always a draft. Everything here is the model's reading of a
+ * marketing page, which is a starting point for a human to correct rather than
+ * a fact about their business — so nothing is written anywhere until the person
+ * has seen it and confirmed it.
+ */
+
+import type { TextModel } from './model';
+
+export interface ProfileDraft {
+  readonly offering: {
+    readonly name: string;
+    readonly category: string;
+    readonly description: string;
+    readonly valuePropositions: readonly string[];
+    readonly likelyPains: readonly string[];
+    readonly competitors: readonly string[];
+  };
+  readonly icp: {
+    readonly titles: readonly string[];
+    readonly seniorities: readonly string[];
+    readonly industries: readonly string[];
+    readonly technologies: readonly string[];
+    readonly keywords: readonly string[];
+    readonly exclusions: readonly string[];
+  };
+  readonly voice: {
+    readonly style: string;
+    readonly instructions: string;
+    readonly maxWords: number;
+  };
+  /** Where to look for these people, and why. Advice, not configuration. */
+  readonly whereToFind: readonly string[];
+}
+
+export interface ProfileDraftResult {
+  readonly ok: boolean;
+  readonly draft?: ProfileDraft;
+  /** Why there is no draft, in words worth showing someone. */
+  readonly reason?: string;
+}
+
+const SYSTEM = [
+  'You read a company website and describe the business behind it, so its own team',
+  'can find the right people to talk to.',
+  '',
+  'Return one JSON object and nothing else:',
+  '{',
+  ' "offering": {"name":string,"category":string,"description":string,',
+  '   "valuePropositions":string[],"likelyPains":string[],"competitors":string[]},',
+  ' "icp": {"titles":string[],"seniorities":string[],"industries":string[],',
+  '   "technologies":string[],"keywords":string[],"exclusions":string[]},',
+  ' "voice": {"style":string,"instructions":string,"maxWords":number},',
+  ' "whereToFind": string[]',
+  '}',
+  '',
+  'Rules:',
+  '- Ground the offering in what the page actually says. Do not invent products.',
+  '- The ICP is an inference and may go beyond the page, but keep it plausible',
+  '  and specific: real job titles, real industries, not "decision makers".',
+  '- likelyPains are the problems this buyer has, in their words, not yours.',
+  '- competitors only if the page names them or the category makes them obvious.',
+  '- voice.style describes how this company already writes, taken from the page.',
+  '- whereToFind: concrete places these buyers are active and why — a subreddit,',
+  '  a GitHub topic, a conference, a job-board signal. Each entry one sentence.',
+  '- Never mention LinkedIn automation. Research there is fine; automating is not.',
+].join('\n');
+
+/** Pulls the JSON object out of a reply that may be fenced or prefaced. */
+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;
+  }
+}
+
+function strings(value: unknown, limit = 12): string[] {
+  if (!Array.isArray(value)) return [];
+  return value
+    .filter((entry): entry is string => typeof entry === 'string' && entry.trim().length > 0)
+    .map((entry) => entry.trim())
+    .slice(0, limit);
+}
+
+function text(value: unknown, fallback = ''): string {
+  return typeof value === 'string' && value.trim() ? value.trim() : fallback;
+}
+
+/**
+ * Drafts a workspace profile from the text of the customer's own site.
+ *
+ * Never throws. A capped key, a refusal or an unparseable reply all return
+ * `ok: false` with something worth reading, because the fallback is a form the
+ * person fills in themselves — which is a worse first run, not a broken one.
+ */
+export async function draftProfile(
+  model: TextModel,
+  siteText: string,
+  siteUrl: string,
+): Promise<ProfileDraftResult> {
+  if (!siteText.trim()) {
+    return { ok: false, reason: 'that page had no readable text' };
+  }
+
+  let reply;
+  try {
+    reply = await model.generate({
+      system: SYSTEM,
+      user: `Site: ${siteUrl}\n\nPage text:\n${siteText.slice(0, 14_000)}`,
+      maxTokens: 2000,
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    // Surfaced rather than swallowed: "the model is out of budget" is
+    // something the person can act on, and silence here reads as a bug.
+    return { ok: false, reason: `the model could not be reached: ${message}` };
+  }
+
+  if (reply.refused) return { ok: false, reason: 'the model declined to read that page' };
+
+  const parsed = parseReply(reply.text);
+  if (!parsed || typeof parsed !== 'object') {
+    return { ok: false, reason: 'the model did not return a usable profile' };
+  }
+
+  const root = parsed as Record<string, unknown>;
+  const offering = (root.offering ?? {}) as Record<string, unknown>;
+  const icp = (root.icp ?? {}) as Record<string, unknown>;
+  const voice = (root.voice ?? {}) as Record<string, unknown>;
+
+  const name = text(offering.name);
+  if (!name) return { ok: false, reason: 'the model could not identify what this company sells' };
+
+  const maxWords = Number(voice.maxWords);
+
+  return {
+    ok: true,
+    draft: {
+      offering: {
+        name,
+        category: text(offering.category, 'unspecified'),
+        description: text(offering.description),
+        valuePropositions: strings(offering.valuePropositions),
+        likelyPains: strings(offering.likelyPains),
+        competitors: strings(offering.competitors, 8),
+      },
+      icp: {
+        titles: strings(icp.titles),
+        seniorities: strings(icp.seniorities, 8),
+        industries: strings(icp.industries),
+        technologies: strings(icp.technologies),
+        keywords: strings(icp.keywords, 16),
+        exclusions: strings(icp.exclusions),
+      },
+      voice: {
+        style: text(voice.style, 'direct and specific'),
+        instructions: text(voice.instructions),
+        // A cap is what keeps a first message short enough to read on a phone.
+        maxWords: Number.isFinite(maxWords) && maxWords > 0 ? Math.min(maxWords, 400) : 120,
+      },
+      whereToFind: strings(root.whereToFind, 10),
+    },
+  };
+}
diff --git a/packages/contracts/src/index.ts b/packages/contracts/src/index.ts
index fd82d70..9622cb6 100644
--- a/packages/contracts/src/index.ts
+++ b/packages/contracts/src/index.ts
@@ -111,6 +111,43 @@ export const addProspectSchema = z.object({
 
 export type AddProspectInput = z.infer<typeof addProspectSchema>;
 
+/**
+ * The workspace's own profile, as confirmed by a human.
+ *
+ * Lists are capped so a model that decides an ICP has forty job titles cannot
+ * write forty rows of noise into the targeting filters. Everything except the
+ * offering name and category is optional: a person who wants to fill in one
+ * line and get on with it should be able to.
+ */
+const shortList = z.array(z.string().trim().min(1).max(120)).max(20).default([]);
+
+export const workspaceProfileSchema = z.object({
+  url: z.string().trim().max(500).optional(),
+  offering: z.object({
+    name: z.string().trim().min(1).max(200),
+    category: z.string().trim().min(1).max(200),
+    description: z.string().trim().max(4000).optional(),
+    valuePropositions: shortList,
+    likelyPains: shortList,
+    competitors: shortList,
+  }),
+  icp: z.object({
+    titles: shortList,
+    seniorities: shortList,
+    industries: shortList,
+    technologies: shortList,
+    keywords: shortList,
+    exclusions: shortList,
+  }),
+  voice: z.object({
+    style: z.string().trim().min(1).max(500),
+    instructions: z.string().trim().max(2000).optional(),
+    maxWords: z.number().int().positive().max(400).optional(),
+  }),
+});
+
+export type WorkspaceProfile = z.infer<typeof workspaceProfileSchema>;
+
 export const createOfferingSchema = z.object({
   name: z.string().min(1).max(200),
   category: z.string().min(1).max(200),
diff --git a/packages/providers/src/site/provider.ts b/packages/providers/src/site/provider.ts
index d7da7b1..622535b 100644
--- a/packages/providers/src/site/provider.ts
+++ b/packages/providers/src/site/provider.ts
@@ -19,7 +19,7 @@ import type {
 } 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';
+import { extractWithModel, visibleText, type ExtractionModel } from './model-extract';
 
 export interface SiteProviderOptions extends FetchOptions {
   /** Omit to run deterministic-only; the crawl still works, it just reads less. */
@@ -37,6 +37,14 @@ export interface CrawlResult {
   readonly contentHash?: string;
   readonly fetchedAt: string;
   readonly detail?: string;
+  /**
+   * The page's visible prose, markup stripped.
+   *
+   * Carried so a caller that wants to reason about the page itself — reading
+   * your *own* site to draft your profile, rather than mining someone else's
+   * for leads — does not have to fetch it a second time.
+   */
+  readonly pageText?: string;
 }
 
 function emptyCompany(): ExtractedCompany {
@@ -156,6 +164,7 @@ export class SiteProvider implements PersonEnrichmentProvider {
       usedSignals,
       ...(page.contentHash ? { contentHash: page.contentHash } : {}),
       fetchedAt: page.fetchedAt,
+      pageText: visibleText(page.html),
     };
   }
 }